Valve/Proton
1
0
Fork 0
mirror of https://github.com/ValveSoftware/Proton.git synced 2024-12-25 06:05:43 +03:00
Code Issues Packages Projects Releases Wiki Activity

vrclient: Support v1.26.7.

Browse Source 
CW-Bug-Id: #22757
This commit is contained in:
Paul Gofman 2023-09-19 17:15:52 -06:00 committed by Arkadiusz Hiler
parent db0991c4ae
commit d229821fdf
43 changed files with 9885 additions and 832 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
openvr

@ -1 +1 @@
Subproject commit 08de3821dfd3aa46f778376680c68f33b9fdcb6c
Subproject commit 5e45960cf44d6eb19bbadcae4a3d32578a380c17

4
vrclient_x64/gen_wrapper.py
View File

@ -14,6 +14,7 @@ import os
import re
sdk_versions = [
"v1.26.7",
"v1.23.7",
"v1.16.8",
"v1.14.15",
@ -379,7 +380,8 @@ def ivroverlay_set_overlay_texture(cppname, method):
"022" in cppname or \
"024" in cppname or \
"025" in cppname or \
"026" in cppname
"026" in cppname or \
"027" in cppname
return "ivroverlay_set_overlay_texture"
def ivrinput_get_digital_action_data(cppname, method):

35
vrclient_x64/openvr_v1.26.7/ivrclientcore.h Normal file
View File

@ -0,0 +1,35 @@
//========= Copyright Valve Corporation ============//
#include "openvr.h"
namespace vr
{
class IVRClientCore
{
public:
/** Initializes the system */
virtual EVRInitError Init( vr::EVRApplicationType eApplicationType, const char *pStartupInfo ) = 0;
/** cleans up everything in vrclient.dll and prepares the DLL to be unloaded */
virtual void Cleanup() = 0;
/** checks to see if the specified interface/version is supported in this vrclient.dll */
virtual EVRInitError IsInterfaceVersionValid( const char *pchInterfaceVersion ) = 0;
/** Retrieves any interface from vrclient.dll */
virtual void *GetGenericInterface( const char *pchNameAndVersion, EVRInitError *peError ) = 0;
/** Returns true if any driver has an HMD attached. Can be called outside of Init/Cleanup */
virtual bool BIsHmdPresent() = 0;
/** Returns an English error string from inside vrclient.dll which might be newer than the API DLL */
virtual const char *GetEnglishStringForHmdError( vr::EVRInitError eError ) = 0;
/** Returns an error symbol from inside vrclient.dll which might be newer than the API DLL */
virtual const char *GetIDForVRInitError( vr::EVRInitError eError ) = 0;
};
static const char * const IVRClientCore_Version = "IVRClientCore_003";
}

5724
vrclient_x64/openvr_v1.26.7/openvr.h Normal file
View File

File diff suppressed because it is too large Load Diff

871
vrclient_x64/tests/capi_thunks_autogen.c
View File

File diff suppressed because it is too large Load Diff

332
vrclient_x64/tests/capi_thunks_autogen.h
View File

@ -383,171 +383,167 @@ EVRNotificationError __thiscall IVRNotifications_002_CreateNotification(void *_t
EVRNotificationError __thiscall IVRNotifications_002_RemoveNotification(void *_this, VRNotificationId notificationId);
void test_capi_thunks_IVROverlay_026(void);
void test_capi_thunks_IVROverlay_027(void);
EVROverlayError __thiscall IVROverlay_026_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_027_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_027_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_027_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
uint32_t __thiscall IVROverlay_026_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
uint32_t __thiscall IVROverlay_027_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
uint32_t __thiscall IVROverlay_026_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
uint32_t __thiscall IVROverlay_027_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
EVROverlayError __thiscall IVROverlay_026_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
EVROverlayError __thiscall IVROverlay_027_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
EVROverlayError __thiscall IVROverlay_026_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
EVROverlayError __thiscall IVROverlay_027_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
const char * __thiscall IVROverlay_026_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
const char * __thiscall IVROverlay_027_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
EVROverlayError __thiscall IVROverlay_026_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
EVROverlayError __thiscall IVROverlay_027_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
uint32_t __thiscall IVROverlay_026_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
uint32_t __thiscall IVROverlay_027_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
EVROverlayError __thiscall IVROverlay_027_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
EVROverlayError __thiscall IVROverlay_026_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
EVROverlayError __thiscall IVROverlay_027_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
EVROverlayError __thiscall IVROverlay_026_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
EVROverlayError __thiscall IVROverlay_027_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
EVROverlayError __thiscall IVROverlay_026_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
EVROverlayError __thiscall IVROverlay_027_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
EVROverlayError __thiscall IVROverlay_026_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
EVROverlayError __thiscall IVROverlay_027_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
EVROverlayError __thiscall IVROverlay_026_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
EVROverlayError __thiscall IVROverlay_027_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
EVROverlayError __thiscall IVROverlay_026_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
EVROverlayError __thiscall IVROverlay_027_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
EVROverlayError __thiscall IVROverlay_027_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
EVROverlayError __thiscall IVROverlay_027_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
EVROverlayError __thiscall IVROverlay_026_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
EVROverlayError __thiscall IVROverlay_027_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
EVROverlayError __thiscall IVROverlay_026_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
EVROverlayError __thiscall IVROverlay_027_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
EVROverlayError __thiscall IVROverlay_026_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
EVROverlayError __thiscall IVROverlay_027_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
EVROverlayError __thiscall IVROverlay_026_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
EVROverlayError __thiscall IVROverlay_027_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
EVROverlayError __thiscall IVROverlay_026_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
EVROverlayError __thiscall IVROverlay_027_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
EVROverlayError __thiscall IVROverlay_026_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
EVROverlayError __thiscall IVROverlay_027_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
EVROverlayError __thiscall IVROverlay_026_SetOverlayPreCurvePitch(void *_this, VROverlayHandle_t ulOverlayHandle, float fRadians);
EVROverlayError __thiscall IVROverlay_027_SetOverlayPreCurvePitch(void *_this, VROverlayHandle_t ulOverlayHandle, float fRadians);
EVROverlayError __thiscall IVROverlay_026_GetOverlayPreCurvePitch(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRadians);
EVROverlayError __thiscall IVROverlay_027_GetOverlayPreCurvePitch(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRadians);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
EVROverlayError __thiscall IVROverlay_027_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
EVROverlayError __thiscall IVROverlay_027_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_027_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_027_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
EVROverlayError __thiscall IVROverlay_027_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_027_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_027_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_027_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_027_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
EVROverlayError __thiscall IVROverlay_027_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
EVROverlayError __thiscall IVROverlay_027_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
EVROverlayError __thiscall IVROverlay_027_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
EVROverlayError __thiscall IVROverlay_027_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_027_SetOverlayTransformProjection(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_027_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformProjection(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye);
EVROverlayError __thiscall IVROverlay_027_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
bool __thiscall IVROverlay_027_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_027_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
bool __thiscall IVROverlay_026_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_027_WaitFrameSync(void *_this, uint32_t nTimeoutMs);
EVROverlayError __thiscall IVROverlay_026_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
bool __thiscall IVROverlay_027_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
EVROverlayError __thiscall IVROverlay_026_WaitFrameSync(void *_this, uint32_t nTimeoutMs);
EVROverlayError __thiscall IVROverlay_027_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
bool __thiscall IVROverlay_026_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
EVROverlayError __thiscall IVROverlay_027_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
EVROverlayError __thiscall IVROverlay_026_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
EVROverlayError __thiscall IVROverlay_027_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
EVROverlayError __thiscall IVROverlay_026_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
EVROverlayError __thiscall IVROverlay_027_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
EVROverlayError __thiscall IVROverlay_026_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
bool __thiscall IVROverlay_027_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
EVROverlayError __thiscall IVROverlay_026_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
bool __thiscall IVROverlay_027_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
bool __thiscall IVROverlay_026_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
EVROverlayError __thiscall IVROverlay_027_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
bool __thiscall IVROverlay_026_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_027_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
EVROverlayError __thiscall IVROverlay_026_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
EVROverlayError __thiscall IVROverlay_027_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
EVROverlayError __thiscall IVROverlay_026_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
EVROverlayError __thiscall IVROverlay_027_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
EVROverlayError __thiscall IVROverlay_026_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
EVROverlayError __thiscall IVROverlay_027_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
EVROverlayError __thiscall IVROverlay_027_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
EVROverlayError __thiscall IVROverlay_026_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_027_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
EVROverlayError __thiscall IVROverlay_027_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
EVROverlayError __thiscall IVROverlay_026_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_027_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
EVROverlayError __thiscall IVROverlay_026_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
EVROverlayError __thiscall IVROverlay_027_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds);
EVROverlayError __thiscall IVROverlay_026_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
EVROverlayError __thiscall IVROverlay_027_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds);
EVROverlayError __thiscall IVROverlay_027_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
EVROverlayError __thiscall IVROverlay_026_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
EVROverlayError __thiscall IVROverlay_027_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
bool __thiscall IVROverlay_027_IsDashboardVisible(void *_this);
EVROverlayError __thiscall IVROverlay_026_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
bool __thiscall IVROverlay_027_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
bool __thiscall IVROverlay_026_IsDashboardVisible(void *_this);
EVROverlayError __thiscall IVROverlay_027_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
bool __thiscall IVROverlay_026_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_027_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
EVROverlayError __thiscall IVROverlay_026_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
void __thiscall IVROverlay_027_ShowDashboard(void *_this, const char * pchOverlayToShow);
EVROverlayError __thiscall IVROverlay_026_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
TrackedDeviceIndex_t __thiscall IVROverlay_027_GetPrimaryDashboardDevice(void *_this);
void __thiscall IVROverlay_026_ShowDashboard(void *_this, const char * pchOverlayToShow);
EVROverlayError __thiscall IVROverlay_027_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
TrackedDeviceIndex_t __thiscall IVROverlay_026_GetPrimaryDashboardDevice(void *_this);
EVROverlayError __thiscall IVROverlay_027_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
EVROverlayError __thiscall IVROverlay_026_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
uint32_t __thiscall IVROverlay_027_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
EVROverlayError __thiscall IVROverlay_026_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
void __thiscall IVROverlay_027_HideKeyboard(void *_this);
uint32_t __thiscall IVROverlay_026_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
void __thiscall IVROverlay_027_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
void __thiscall IVROverlay_026_HideKeyboard(void *_this);
void __thiscall IVROverlay_027_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
void __thiscall IVROverlay_026_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
VRMessageOverlayResponse __thiscall IVROverlay_027_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
void __thiscall IVROverlay_026_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
VRMessageOverlayResponse __thiscall IVROverlay_026_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
void __thiscall IVROverlay_026_CloseMessageOverlay(void *_this);
void __thiscall IVROverlay_027_CloseMessageOverlay(void *_this);
void test_capi_thunks_IVROverlayView_003(void);
@ -765,6 +761,172 @@ const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_thi
const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError);
void test_capi_thunks_IVROverlay_026(void);
EVROverlayError __thiscall IVROverlay_026_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
uint32_t __thiscall IVROverlay_026_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
uint32_t __thiscall IVROverlay_026_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
EVROverlayError __thiscall IVROverlay_026_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
EVROverlayError __thiscall IVROverlay_026_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
const char * __thiscall IVROverlay_026_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
EVROverlayError __thiscall IVROverlay_026_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
uint32_t __thiscall IVROverlay_026_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
EVROverlayError __thiscall IVROverlay_026_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
EVROverlayError __thiscall IVROverlay_026_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
EVROverlayError __thiscall IVROverlay_026_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
EVROverlayError __thiscall IVROverlay_026_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
EVROverlayError __thiscall IVROverlay_026_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
EVROverlayError __thiscall IVROverlay_026_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
EVROverlayError __thiscall IVROverlay_026_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
EVROverlayError __thiscall IVROverlay_026_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
EVROverlayError __thiscall IVROverlay_026_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
EVROverlayError __thiscall IVROverlay_026_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
EVROverlayError __thiscall IVROverlay_026_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
EVROverlayError __thiscall IVROverlay_026_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
EVROverlayError __thiscall IVROverlay_026_SetOverlayPreCurvePitch(void *_this, VROverlayHandle_t ulOverlayHandle, float fRadians);
EVROverlayError __thiscall IVROverlay_026_GetOverlayPreCurvePitch(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRadians);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformProjection(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye);
EVROverlayError __thiscall IVROverlay_026_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
bool __thiscall IVROverlay_026_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
EVROverlayError __thiscall IVROverlay_026_WaitFrameSync(void *_this, uint32_t nTimeoutMs);
bool __thiscall IVROverlay_026_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
EVROverlayError __thiscall IVROverlay_026_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
EVROverlayError __thiscall IVROverlay_026_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
EVROverlayError __thiscall IVROverlay_026_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
EVROverlayError __thiscall IVROverlay_026_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
bool __thiscall IVROverlay_026_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
bool __thiscall IVROverlay_026_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
EVROverlayError __thiscall IVROverlay_026_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
EVROverlayError __thiscall IVROverlay_026_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
EVROverlayError __thiscall IVROverlay_026_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
EVROverlayError __thiscall IVROverlay_026_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
EVROverlayError __thiscall IVROverlay_026_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
EVROverlayError __thiscall IVROverlay_026_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds);
EVROverlayError __thiscall IVROverlay_026_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
EVROverlayError __thiscall IVROverlay_026_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
bool __thiscall IVROverlay_026_IsDashboardVisible(void *_this);
bool __thiscall IVROverlay_026_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
EVROverlayError __thiscall IVROverlay_026_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
void __thiscall IVROverlay_026_ShowDashboard(void *_this, const char * pchOverlayToShow);
TrackedDeviceIndex_t __thiscall IVROverlay_026_GetPrimaryDashboardDevice(void *_this);
EVROverlayError __thiscall IVROverlay_026_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
EVROverlayError __thiscall IVROverlay_026_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
uint32_t __thiscall IVROverlay_026_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
void __thiscall IVROverlay_026_HideKeyboard(void *_this);
void __thiscall IVROverlay_026_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
void __thiscall IVROverlay_026_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
VRMessageOverlayResponse __thiscall IVROverlay_026_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
void __thiscall IVROverlay_026_CloseMessageOverlay(void *_this);
void test_capi_thunks_IVROverlay_025(void);
EVROverlayError __thiscall IVROverlay_025_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);

1848
vrclient_x64/tests/capi_thunks_tests_autogen.c
View File

File diff suppressed because it is too large Load Diff

3
vrclient_x64/tests/main_autogen.c
View File

@ -13,7 +13,7 @@ int main(void)
test_capi_thunks_IVRCompositor_027();
test_capi_thunks_IVRHeadsetView_001();
test_capi_thunks_IVRNotifications_002();
test_capi_thunks_IVROverlay_026();
test_capi_thunks_IVROverlay_027();
test_capi_thunks_IVROverlayView_003();
test_capi_thunks_IVRRenderModels_006();
test_capi_thunks_IVRExtendedDisplay_001();
@ -24,6 +24,7 @@ int main(void)
test_capi_thunks_IVRInput_010();
test_capi_thunks_IVRIOBuffer_002();
test_capi_thunks_IVRClientCore_003();
test_capi_thunks_IVROverlay_026();
test_capi_thunks_IVROverlay_025();
test_capi_thunks_IVRCompositor_026();
test_capi_thunks_IVROverlay_024();

2
vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_007.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

2
vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

2
vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_004.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

2
vrclient_x64/vrclient_x64/cppIVRClientCore_IVRClientCore_003.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

2
vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_027.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

2
vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

2
vrclient_x64/vrclient_x64/cppIVRExtendedDisplay_IVRExtendedDisplay_001.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

2
vrclient_x64/vrclient_x64/cppIVRHeadsetView_IVRHeadsetView_001.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

2
vrclient_x64/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_002.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

32
vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
@ -34,63 +34,63 @@ vr::EVRInputError cppIVRInput_IVRInput_010_UpdateActionState(void *linux_side, V
return ((IVRInput*)linux_side)->UpdateActionState((vr::VRActiveActionSet_t *)pSets, (uint32_t)unSizeOfVRSelectedActionSet_t, (uint32_t)unSetCount);
}
vr::EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
vr::EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
InputDigitalActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputDigitalActionData_t_1237_win_to_lin(pActionData, &lin);
struct_InputDigitalActionData_t_1267_win_to_lin(pActionData, &lin);
_ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if(pActionData)
struct_InputDigitalActionData_t_1237_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputDigitalActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize);
return _ret;
}
vr::EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
vr::EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
InputAnalogActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputAnalogActionData_t_1237_win_to_lin(pActionData, &lin);
struct_InputAnalogActionData_t_1267_win_to_lin(pActionData, &lin);
_ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if(pActionData)
struct_InputAnalogActionData_t_1237_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputAnalogActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize);
return _ret;
}
vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
InputPoseActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputPoseActionData_t_1237_win_to_lin(pActionData, &lin);
struct_InputPoseActionData_t_1267_win_to_lin(pActionData, &lin);
_ret = ((IVRInput*)linux_side)->GetPoseActionDataRelativeToNow((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if(pActionData)
struct_InputPoseActionData_t_1237_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputPoseActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize);
return _ret;
}
vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
InputPoseActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputPoseActionData_t_1237_win_to_lin(pActionData, &lin);
struct_InputPoseActionData_t_1267_win_to_lin(pActionData, &lin);
_ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0, (vr::VRInputValueHandle_t)ulRestrictToDevice);
if(pActionData)
struct_InputPoseActionData_t_1237_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputPoseActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize);
return _ret;
}
vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1237 * pActionData, uint32_t unActionDataSize)
vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1267 * pActionData, uint32_t unActionDataSize)
{
InputSkeletalActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputSkeletalActionData_t_1237_win_to_lin(pActionData, &lin);
struct_InputSkeletalActionData_t_1267_win_to_lin(pActionData, &lin);
_ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0);
if(pActionData)
struct_InputSkeletalActionData_t_1237_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputSkeletalActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize);
return _ret;
}

10
vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.h
View File

@ -6,11 +6,11 @@ extern EVRInputError cppIVRInput_IVRInput_010_GetActionSetHandle(void *, const c
extern EVRInputError cppIVRInput_IVRInput_010_GetActionHandle(void *, const char *, VRActionHandle_t *);
extern EVRInputError cppIVRInput_IVRInput_010_GetInputSourceHandle(void *, const char *, VRInputValueHandle_t *);
extern EVRInputError cppIVRInput_IVRInput_010_UpdateActionState(void *, VRActiveActionSet_t *, uint32_t, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *, VRActionHandle_t, winInputDigitalActionData_t_1237 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_1237 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_1237 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_1237 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_1237 *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *, VRActionHandle_t, winInputDigitalActionData_t_1267 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_1267 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_1267 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_1267 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_1267 *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetDominantHand(void *, ETrackedControllerRole *);
extern EVRInputError cppIVRInput_IVRInput_010_SetDominantHand(void *, ETrackedControllerRole);
extern EVRInputError cppIVRInput_IVRInput_010_GetBoneCount(void *, VRActionHandle_t, uint32_t *);

2
vrclient_x64/vrclient_x64/cppIVRNotifications_IVRNotifications_002.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

4
vrclient_x64/vrclient_x64/cppIVROverlayView_IVROverlayView_003.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
@ -23,7 +23,7 @@ void cppIVROverlayView_IVROverlayView_003_PostOverlayEvent(void *linux_side, VRO
{
VREvent_t lin;
if(pvrEvent)
struct_VREvent_t_1237_win_to_lin(pvrEvent, &lin);
struct_VREvent_t_1267_win_to_lin(pvrEvent, &lin);
((IVROverlayView*)linux_side)->PostOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pvrEvent ? &lin : nullptr);
}

421
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_027.cpp Normal file
View File

@ -0,0 +1,421 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
}
#include "cppIVROverlay_IVROverlay_027.h"
#ifdef __cplusplus
extern "C" {
#endif
vr::EVROverlayError cppIVROverlay_IVROverlay_027_FindOverlay(void *linux_side, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
{
return ((IVROverlay*)linux_side)->FindOverlay((const char *)pchOverlayKey, (vr::VROverlayHandle_t *)pOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_CreateOverlay(void *linux_side, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
{
return ((IVROverlay*)linux_side)->CreateOverlay((const char *)pchOverlayKey, (const char *)pchOverlayName, (vr::VROverlayHandle_t *)pOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_DestroyOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->DestroyOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
uint32_t cppIVROverlay_IVROverlay_027_GetOverlayKey(void *linux_side, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
{
return ((IVROverlay*)linux_side)->GetOverlayKey((vr::VROverlayHandle_t)ulOverlayHandle, (char *)pchValue, (uint32_t)unBufferSize, (vr::EVROverlayError *)pError);
}
uint32_t cppIVROverlay_IVROverlay_027_GetOverlayName(void *linux_side, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
{
return ((IVROverlay*)linux_side)->GetOverlayName((vr::VROverlayHandle_t)ulOverlayHandle, (char *)pchValue, (uint32_t)unBufferSize, (vr::EVROverlayError *)pError);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayName(void *linux_side, VROverlayHandle_t ulOverlayHandle, const char * pchName)
{
return ((IVROverlay*)linux_side)->SetOverlayName((vr::VROverlayHandle_t)ulOverlayHandle, (const char *)pchName);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayImageData(void *linux_side, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
{
return ((IVROverlay*)linux_side)->GetOverlayImageData((vr::VROverlayHandle_t)ulOverlayHandle, (void *)pvBuffer, (uint32_t)unBufferSize, (uint32_t *)punWidth, (uint32_t *)punHeight);
}
const char * cppIVROverlay_IVROverlay_027_GetOverlayErrorNameFromEnum(void *linux_side, EVROverlayError error)
{
return ((IVROverlay*)linux_side)->GetOverlayErrorNameFromEnum((vr::EVROverlayError)error);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayRenderingPid(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
{
return ((IVROverlay*)linux_side)->SetOverlayRenderingPid((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t)unPID);
}
uint32_t cppIVROverlay_IVROverlay_027_GetOverlayRenderingPid(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->GetOverlayRenderingPid((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayFlag(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
{
return ((IVROverlay*)linux_side)->SetOverlayFlag((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayFlags)eOverlayFlag, (bool)bEnabled);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayFlag(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
{
return ((IVROverlay*)linux_side)->GetOverlayFlag((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayFlags)eOverlayFlag, (bool *)pbEnabled);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayFlags(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
{
return ((IVROverlay*)linux_side)->GetOverlayFlags((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t *)pFlags);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayColor(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
{
return ((IVROverlay*)linux_side)->SetOverlayColor((vr::VROverlayHandle_t)ulOverlayHandle, (float)fRed, (float)fGreen, (float)fBlue);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayColor(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
{
return ((IVROverlay*)linux_side)->GetOverlayColor((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfRed, (float *)pfGreen, (float *)pfBlue);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fAlpha)
{
return ((IVROverlay*)linux_side)->SetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float)fAlpha);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
{
return ((IVROverlay*)linux_side)->GetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfAlpha);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
{
return ((IVROverlay*)linux_side)->SetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float)fTexelAspect);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
{
return ((IVROverlay*)linux_side)->GetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfTexelAspect);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlaySortOrder(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
{
return ((IVROverlay*)linux_side)->SetOverlaySortOrder((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t)unSortOrder);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlaySortOrder(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
{
return ((IVROverlay*)linux_side)->GetOverlaySortOrder((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t *)punSortOrder);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
{
return ((IVROverlay*)linux_side)->SetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float)fWidthInMeters);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
{
return ((IVROverlay*)linux_side)->GetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfWidthInMeters);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayCurvature(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fCurvature)
{
return ((IVROverlay*)linux_side)->SetOverlayCurvature((vr::VROverlayHandle_t)ulOverlayHandle, (float)fCurvature);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayCurvature(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
{
return ((IVROverlay*)linux_side)->GetOverlayCurvature((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfCurvature);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayPreCurvePitch(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fRadians)
{
return ((IVROverlay*)linux_side)->SetOverlayPreCurvePitch((vr::VROverlayHandle_t)ulOverlayHandle, (float)fRadians);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayPreCurvePitch(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfRadians)
{
return ((IVROverlay*)linux_side)->GetOverlayPreCurvePitch((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfRadians);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTextureColorSpace(void *linux_side, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
{
return ((IVROverlay*)linux_side)->SetOverlayTextureColorSpace((vr::VROverlayHandle_t)ulOverlayHandle, (vr::EColorSpace)eTextureColorSpace);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTextureColorSpace(void *linux_side, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
{
return ((IVROverlay*)linux_side)->GetOverlayTextureColorSpace((vr::VROverlayHandle_t)ulOverlayHandle, (vr::EColorSpace *)peTextureColorSpace);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTextureBounds(void *linux_side, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
{
return ((IVROverlay*)linux_side)->SetOverlayTextureBounds((vr::VROverlayHandle_t)ulOverlayHandle, (const vr::VRTextureBounds_t *)pOverlayTextureBounds);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTextureBounds(void *linux_side, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
{
return ((IVROverlay*)linux_side)->GetOverlayTextureBounds((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VRTextureBounds_t *)pOverlayTextureBounds);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformType(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
{
return ((IVROverlay*)linux_side)->GetOverlayTransformType((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayTransformType *)peTransformType);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformAbsolute(void *linux_side, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
{
return ((IVROverlay*)linux_side)->SetOverlayTransformAbsolute((vr::VROverlayHandle_t)ulOverlayHandle, (vr::ETrackingUniverseOrigin)eTrackingOrigin, (const vr::HmdMatrix34_t *)pmatTrackingOriginToOverlayTransform);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformAbsolute(void *linux_side, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
{
return ((IVROverlay*)linux_side)->GetOverlayTransformAbsolute((vr::VROverlayHandle_t)ulOverlayHandle, (vr::ETrackingUniverseOrigin *)peTrackingOrigin, (vr::HmdMatrix34_t *)pmatTrackingOriginToOverlayTransform);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceRelative(void *linux_side, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
{
return ((IVROverlay*)linux_side)->SetOverlayTransformTrackedDeviceRelative((vr::VROverlayHandle_t)ulOverlayHandle, (vr::TrackedDeviceIndex_t)unTrackedDevice, (const vr::HmdMatrix34_t *)pmatTrackedDeviceToOverlayTransform);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceRelative(void *linux_side, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
{
return ((IVROverlay*)linux_side)->GetOverlayTransformTrackedDeviceRelative((vr::VROverlayHandle_t)ulOverlayHandle, (vr::TrackedDeviceIndex_t *)punTrackedDevice, (vr::HmdMatrix34_t *)pmatTrackedDeviceToOverlayTransform);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceComponent(void *linux_side, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
{
return ((IVROverlay*)linux_side)->SetOverlayTransformTrackedDeviceComponent((vr::VROverlayHandle_t)ulOverlayHandle, (vr::TrackedDeviceIndex_t)unDeviceIndex, (const char *)pchComponentName);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceComponent(void *linux_side, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
{
return ((IVROverlay*)linux_side)->GetOverlayTransformTrackedDeviceComponent((vr::VROverlayHandle_t)ulOverlayHandle, (vr::TrackedDeviceIndex_t *)punDeviceIndex, (char *)pchComponentName, (uint32_t)unComponentNameSize);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformCursor(void *linux_side, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot)
{
return ((IVROverlay*)linux_side)->SetOverlayTransformCursor((vr::VROverlayHandle_t)ulCursorOverlayHandle, (const vr::HmdVector2_t *)pvHotspot);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformCursor(void *linux_side, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot)
{
return ((IVROverlay*)linux_side)->GetOverlayTransformCursor((vr::VROverlayHandle_t)ulOverlayHandle, (vr::HmdVector2_t *)pvHotspot);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformProjection(void *linux_side, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye)
{
return ((IVROverlay*)linux_side)->SetOverlayTransformProjection((vr::VROverlayHandle_t)ulOverlayHandle, (vr::ETrackingUniverseOrigin)eTrackingOrigin, (const vr::HmdMatrix34_t *)pmatTrackingOriginToOverlayTransform, (const vr::VROverlayProjection_t *)pProjection, (vr::EVREye)eEye);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_ShowOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->ShowOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_HideOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->HideOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
bool cppIVROverlay_IVROverlay_027_IsOverlayVisible(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->IsOverlayVisible((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetTransformForOverlayCoordinates(void *linux_side, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
{
return ((IVROverlay*)linux_side)->GetTransformForOverlayCoordinates((vr::VROverlayHandle_t)ulOverlayHandle, (vr::ETrackingUniverseOrigin)eTrackingOrigin, (vr::HmdVector2_t)coordinatesInOverlay, (vr::HmdMatrix34_t *)pmatTransform);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_WaitFrameSync(void *linux_side, uint32_t nTimeoutMs)
{
return ((IVROverlay*)linux_side)->WaitFrameSync((uint32_t)nTimeoutMs);
}
bool cppIVROverlay_IVROverlay_027_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1267 * pEvent, uint32_t uncbVREvent)
{
VREvent_t lin;
bool _ret;
if(pEvent)
struct_VREvent_t_1267_win_to_lin(pEvent, &lin);
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, uncbVREvent ? sizeof(lin) : 0);
if(pEvent)
struct_VREvent_t_1267_lin_to_win(&lin, pEvent, uncbVREvent);
return _ret;
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayInputMethod(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
{
return ((IVROverlay*)linux_side)->GetOverlayInputMethod((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayInputMethod *)peInputMethod);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayInputMethod(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
{
return ((IVROverlay*)linux_side)->SetOverlayInputMethod((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayInputMethod)eInputMethod);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayMouseScale(void *linux_side, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
{
return ((IVROverlay*)linux_side)->GetOverlayMouseScale((vr::VROverlayHandle_t)ulOverlayHandle, (vr::HmdVector2_t *)pvecMouseScale);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayMouseScale(void *linux_side, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
{
return ((IVROverlay*)linux_side)->SetOverlayMouseScale((vr::VROverlayHandle_t)ulOverlayHandle, (const vr::HmdVector2_t *)pvecMouseScale);
}
bool cppIVROverlay_IVROverlay_027_ComputeOverlayIntersection(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
{
return ((IVROverlay*)linux_side)->ComputeOverlayIntersection((vr::VROverlayHandle_t)ulOverlayHandle, (const vr::VROverlayIntersectionParams_t *)pParams, (vr::VROverlayIntersectionResults_t *)pResults);
}
bool cppIVROverlay_IVROverlay_027_IsHoverTargetOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->IsHoverTargetOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayIntersectionMask(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
{
return ((IVROverlay*)linux_side)->SetOverlayIntersectionMask((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayIntersectionMaskPrimitive_t *)pMaskPrimitives, (uint32_t)unNumMaskPrimitives, (uint32_t)unPrimitiveSize);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_TriggerLaserMouseHapticVibration(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude)
{
return ((IVROverlay*)linux_side)->TriggerLaserMouseHapticVibration((vr::VROverlayHandle_t)ulOverlayHandle, (float)fDurationSeconds, (float)fFrequency, (float)fAmplitude);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayCursor(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle)
{
return ((IVROverlay*)linux_side)->SetOverlayCursor((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayHandle_t)ulCursorHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayCursorPositionOverride(void *linux_side, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor)
{
return ((IVROverlay*)linux_side)->SetOverlayCursorPositionOverride((vr::VROverlayHandle_t)ulOverlayHandle, (const vr::HmdVector2_t *)pvCursor);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_ClearOverlayCursorPositionOverride(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->ClearOverlayCursorPositionOverride((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTexture(void *linux_side, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
{
return ((IVROverlay*)linux_side)->SetOverlayTexture((vr::VROverlayHandle_t)ulOverlayHandle, (const vr::Texture_t *)pTexture);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_ClearOverlayTexture(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->ClearOverlayTexture((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayRaw(void *linux_side, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel)
{
return ((IVROverlay*)linux_side)->SetOverlayRaw((vr::VROverlayHandle_t)ulOverlayHandle, (void *)pvBuffer, (uint32_t)unWidth, (uint32_t)unHeight, (uint32_t)unBytesPerPixel);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayFromFile(void *linux_side, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
{
return ((IVROverlay*)linux_side)->SetOverlayFromFile((vr::VROverlayHandle_t)ulOverlayHandle, (const char *)pchFilePath);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTexture(void *linux_side, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds)
{
return ((IVROverlay*)linux_side)->GetOverlayTexture((vr::VROverlayHandle_t)ulOverlayHandle, (void **)pNativeTextureHandle, (void *)pNativeTextureRef, (uint32_t *)pWidth, (uint32_t *)pHeight, (uint32_t *)pNativeFormat, (vr::ETextureType *)pAPIType, (vr::EColorSpace *)pColorSpace, (vr::VRTextureBounds_t *)pTextureBounds);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_ReleaseNativeOverlayHandle(void *linux_side, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
{
return ((IVROverlay*)linux_side)->ReleaseNativeOverlayHandle((vr::VROverlayHandle_t)ulOverlayHandle, (void *)pNativeTextureHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTextureSize(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
{
return ((IVROverlay*)linux_side)->GetOverlayTextureSize((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t *)pWidth, (uint32_t *)pHeight);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_CreateDashboardOverlay(void *linux_side, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
{
return ((IVROverlay*)linux_side)->CreateDashboardOverlay((const char *)pchOverlayKey, (const char *)pchOverlayFriendlyName, (vr::VROverlayHandle_t *)pMainHandle, (vr::VROverlayHandle_t *)pThumbnailHandle);
}
bool cppIVROverlay_IVROverlay_027_IsDashboardVisible(void *linux_side)
{
return ((IVROverlay*)linux_side)->IsDashboardVisible();
}
bool cppIVROverlay_IVROverlay_027_IsActiveDashboardOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->IsActiveDashboardOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetDashboardOverlaySceneProcess(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
{
return ((IVROverlay*)linux_side)->SetDashboardOverlaySceneProcess((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t)unProcessId);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetDashboardOverlaySceneProcess(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
{
return ((IVROverlay*)linux_side)->GetDashboardOverlaySceneProcess((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t *)punProcessId);
}
void cppIVROverlay_IVROverlay_027_ShowDashboard(void *linux_side, const char * pchOverlayToShow)
{
((IVROverlay*)linux_side)->ShowDashboard((const char *)pchOverlayToShow);
}
vr::TrackedDeviceIndex_t cppIVROverlay_IVROverlay_027_GetPrimaryDashboardDevice(void *linux_side)
{
return ((IVROverlay*)linux_side)->GetPrimaryDashboardDevice();
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_ShowKeyboard(void *linux_side, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue)
{
return ((IVROverlay*)linux_side)->ShowKeyboard((vr::EGamepadTextInputMode)eInputMode, (vr::EGamepadTextInputLineMode)eLineInputMode, (uint32_t)unFlags, (const char *)pchDescription, (uint32_t)unCharMax, (const char *)pchExistingText, (uint64_t)uUserValue);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_027_ShowKeyboardForOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue)
{
return ((IVROverlay*)linux_side)->ShowKeyboardForOverlay((vr::VROverlayHandle_t)ulOverlayHandle, (vr::EGamepadTextInputMode)eInputMode, (vr::EGamepadTextInputLineMode)eLineInputMode, (uint32_t)unFlags, (const char *)pchDescription, (uint32_t)unCharMax, (const char *)pchExistingText, (uint64_t)uUserValue);
}
uint32_t cppIVROverlay_IVROverlay_027_GetKeyboardText(void *linux_side, char * pchText, uint32_t cchText)
{
return ((IVROverlay*)linux_side)->GetKeyboardText((char *)pchText, (uint32_t)cchText);
}
void cppIVROverlay_IVROverlay_027_HideKeyboard(void *linux_side)
{
((IVROverlay*)linux_side)->HideKeyboard();
}
void cppIVROverlay_IVROverlay_027_SetKeyboardTransformAbsolute(void *linux_side, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
{
((IVROverlay*)linux_side)->SetKeyboardTransformAbsolute((vr::ETrackingUniverseOrigin)eTrackingOrigin, (const vr::HmdMatrix34_t *)pmatTrackingOriginToKeyboardTransform);
}
void cppIVROverlay_IVROverlay_027_SetKeyboardPositionForOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
{
((IVROverlay*)linux_side)->SetKeyboardPositionForOverlay((vr::VROverlayHandle_t)ulOverlayHandle, (vr::HmdRect2_t)avoidRect);
}
vr::VRMessageOverlayResponse cppIVROverlay_IVROverlay_027_ShowMessageOverlay(void *linux_side, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text)
{
return ((IVROverlay*)linux_side)->ShowMessageOverlay((const char *)pchText, (const char *)pchCaption, (const char *)pchButton0Text, (const char *)pchButton1Text, (const char *)pchButton2Text, (const char *)pchButton3Text);
}
void cppIVROverlay_IVROverlay_027_CloseMessageOverlay(void *linux_side)
{
((IVROverlay*)linux_side)->CloseMessageOverlay();
}
#ifdef __cplusplus
}
#endif

86
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_027.h Normal file
View File

@ -0,0 +1,86 @@
#ifdef __cplusplus
extern "C" {
#endif
extern EVROverlayError cppIVROverlay_IVROverlay_027_FindOverlay(void *, const char *, VROverlayHandle_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_CreateOverlay(void *, const char *, const char *, VROverlayHandle_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_DestroyOverlay(void *, VROverlayHandle_t);
extern uint32_t cppIVROverlay_IVROverlay_027_GetOverlayKey(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
extern uint32_t cppIVROverlay_IVROverlay_027_GetOverlayName(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayName(void *, VROverlayHandle_t, const char *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayImageData(void *, VROverlayHandle_t, void *, uint32_t, uint32_t *, uint32_t *);
extern const char * cppIVROverlay_IVROverlay_027_GetOverlayErrorNameFromEnum(void *, EVROverlayError);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayRenderingPid(void *, VROverlayHandle_t, uint32_t);
extern uint32_t cppIVROverlay_IVROverlay_027_GetOverlayRenderingPid(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayFlags(void *, VROverlayHandle_t, uint32_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayColor(void *, VROverlayHandle_t, float, float, float);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayColor(void *, VROverlayHandle_t, float *, float *, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayAlpha(void *, VROverlayHandle_t, float);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayAlpha(void *, VROverlayHandle_t, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTexelAspect(void *, VROverlayHandle_t, float);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTexelAspect(void *, VROverlayHandle_t, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayWidthInMeters(void *, VROverlayHandle_t, float);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayWidthInMeters(void *, VROverlayHandle_t, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayCurvature(void *, VROverlayHandle_t, float);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayCurvature(void *, VROverlayHandle_t, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayPreCurvePitch(void *, VROverlayHandle_t, float);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayPreCurvePitch(void *, VROverlayHandle_t, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformType(void *, VROverlayHandle_t, VROverlayTransformType *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin *, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t, const char *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, char *, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformCursor(void *, VROverlayHandle_t, HmdVector2_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformCursor(void *, VROverlayHandle_t, HmdVector2_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformProjection(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdMatrix34_t *, VROverlayProjection_t *, EVREye);
extern EVROverlayError cppIVROverlay_IVROverlay_027_ShowOverlay(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_HideOverlay(void *, VROverlayHandle_t);
extern bool cppIVROverlay_IVROverlay_027_IsOverlayVisible(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetTransformForOverlayCoordinates(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdVector2_t, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_WaitFrameSync(void *, uint32_t);
extern bool cppIVROverlay_IVROverlay_027_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1267 *, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
extern bool cppIVROverlay_IVROverlay_027_ComputeOverlayIntersection(void *, VROverlayHandle_t, VROverlayIntersectionParams_t *, VROverlayIntersectionResults_t *);
extern bool cppIVROverlay_IVROverlay_027_IsHoverTargetOverlay(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayIntersectionMask(void *, VROverlayHandle_t, VROverlayIntersectionMaskPrimitive_t *, uint32_t, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_TriggerLaserMouseHapticVibration(void *, VROverlayHandle_t, float, float, float);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayCursor(void *, VROverlayHandle_t, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayCursorPositionOverride(void *, VROverlayHandle_t, HmdVector2_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_ClearOverlayCursorPositionOverride(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTexture(void *, VROverlayHandle_t, Texture_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_ClearOverlayTexture(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayRaw(void *, VROverlayHandle_t, void *, uint32_t, uint32_t, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayFromFile(void *, VROverlayHandle_t, const char *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTexture(void *, VROverlayHandle_t, void **, void *, uint32_t *, uint32_t *, uint32_t *, ETextureType *, EColorSpace *, VRTextureBounds_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_ReleaseNativeOverlayHandle(void *, VROverlayHandle_t, void *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTextureSize(void *, VROverlayHandle_t, uint32_t *, uint32_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_CreateDashboardOverlay(void *, const char *, const char *, VROverlayHandle_t *, VROverlayHandle_t *);
extern bool cppIVROverlay_IVROverlay_027_IsDashboardVisible(void *);
extern bool cppIVROverlay_IVROverlay_027_IsActiveDashboardOverlay(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_SetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_GetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t *);
extern void cppIVROverlay_IVROverlay_027_ShowDashboard(void *, const char *);
extern TrackedDeviceIndex_t cppIVROverlay_IVROverlay_027_GetPrimaryDashboardDevice(void *);
extern EVROverlayError cppIVROverlay_IVROverlay_027_ShowKeyboard(void *, EGamepadTextInputMode, EGamepadTextInputLineMode, uint32_t, const char *, uint32_t, const char *, uint64_t);
extern EVROverlayError cppIVROverlay_IVROverlay_027_ShowKeyboardForOverlay(void *, VROverlayHandle_t, EGamepadTextInputMode, EGamepadTextInputLineMode, uint32_t, const char *, uint32_t, const char *, uint64_t);
extern uint32_t cppIVROverlay_IVROverlay_027_GetKeyboardText(void *, char *, uint32_t);
extern void cppIVROverlay_IVROverlay_027_HideKeyboard(void *);
extern void cppIVROverlay_IVROverlay_027_SetKeyboardTransformAbsolute(void *, ETrackingUniverseOrigin, HmdMatrix34_t *);
extern void cppIVROverlay_IVROverlay_027_SetKeyboardPositionForOverlay(void *, VROverlayHandle_t, HmdRect2_t);
extern VRMessageOverlayResponse cppIVROverlay_IVROverlay_027_ShowMessageOverlay(void *, const char *, const char *, const char *, const char *, const char *, const char *);
extern void cppIVROverlay_IVROverlay_027_CloseMessageOverlay(void *);
#ifdef __cplusplus
}
#endif

20
vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
@ -9,34 +9,34 @@ extern "C" {
#ifdef __cplusplus
extern "C" {
#endif
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1237 ** ppRenderModel)
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1267 ** ppRenderModel)
{
RenderModel_t *lin;
vr::EVRRenderModelError _ret;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, ppRenderModel ? &lin : nullptr);
if(_ret == 0)
*ppRenderModel = struct_RenderModel_t_1237_wrap(lin);
*ppRenderModel = struct_RenderModel_t_1267_wrap(lin);
return _ret;
}
void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1237 * pRenderModel)
void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1267 * pRenderModel)
{
((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1237_unwrap(pRenderModel));
((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1267_unwrap(pRenderModel));
}
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1237 ** ppTexture)
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1267 ** ppTexture)
{
RenderModel_TextureMap_t *lin;
vr::EVRRenderModelError _ret;
_ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, ppTexture ? &lin : nullptr);
if(_ret == 0)
*ppTexture = struct_RenderModel_TextureMap_t_1237_wrap(lin);
*ppTexture = struct_RenderModel_TextureMap_t_1267_wrap(lin);
return _ret;
}
void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1237 * pTexture)
void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1267 * pTexture)
{
((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1237_unwrap(pTexture));
((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1267_unwrap(pTexture));
}
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTextureD3D11_Async(void *linux_side, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D)
@ -94,7 +94,7 @@ bool cppIVRRenderModels_IVRRenderModels_006_GetComponentState(void *linux_side,
VRControllerState001_t lin;
bool _ret;
if(pControllerState)
struct_VRControllerState001_t_1237_win_to_lin(pControllerState, &lin);
struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin);
_ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin : nullptr, (const vr::RenderModel_ControllerMode_State_t *)pState, (vr::RenderModel_ComponentState_t *)pComponentState);
return _ret;
}

8
vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.h
View File

@ -1,10 +1,10 @@
#ifdef __cplusplus
extern "C" {
#endif
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1237 **);
extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_1237 *);
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1237 **);
extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_1237 *);
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1267 **);
extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_1267 *);
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1267 **);
extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_1267 *);
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTextureD3D11_Async(void *, TextureID_t, void *, void **);
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadIntoTextureD3D11_Async(void *, TextureID_t, void *);
extern void cppIVRRenderModels_IVRRenderModels_006_FreeTextureD3D11(void *, void *);

2
vrclient_x64/vrclient_x64/cppIVRResources_IVRResources_001.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

2
vrclient_x64/vrclient_x64/cppIVRScreenshots_IVRScreenshots_001.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

2
vrclient_x64/vrclient_x64/cppIVRSettings_IVRSettings_003.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

26
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_022.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
@ -154,27 +154,27 @@ const char * cppIVRSystem_IVRSystem_022_GetPropErrorNameFromEnum(void *linux_sid
return ((IVRSystem*)linux_side)->GetPropErrorNameFromEnum((vr::ETrackedPropertyError)error);
}
bool cppIVRSystem_IVRSystem_022_PollNextEvent(void *linux_side, winVREvent_t_1237 * pEvent, uint32_t uncbVREvent)
bool cppIVRSystem_IVRSystem_022_PollNextEvent(void *linux_side, winVREvent_t_1267 * pEvent, uint32_t uncbVREvent)
{
VREvent_t lin;
bool _ret;
if(pEvent)
struct_VREvent_t_1237_win_to_lin(pEvent, &lin);
struct_VREvent_t_1267_win_to_lin(pEvent, &lin);
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, uncbVREvent ? sizeof(lin) : 0);
if(pEvent)
struct_VREvent_t_1237_lin_to_win(&lin, pEvent, uncbVREvent);
struct_VREvent_t_1267_lin_to_win(&lin, pEvent, uncbVREvent);
return _ret;
}
bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1237 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1267 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
{
VREvent_t lin;
bool _ret;
if(pEvent)
struct_VREvent_t_1237_win_to_lin(pEvent, &lin);
struct_VREvent_t_1267_win_to_lin(pEvent, &lin);
_ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, uncbVREvent ? sizeof(lin) : 0, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if(pEvent)
struct_VREvent_t_1237_lin_to_win(&lin, pEvent, uncbVREvent);
struct_VREvent_t_1267_lin_to_win(&lin, pEvent, uncbVREvent);
return _ret;
}
@ -188,27 +188,27 @@ vr::HiddenAreaMesh_t cppIVRSystem_IVRSystem_022_GetHiddenAreaMesh(void *linux_si
return ((IVRSystem*)linux_side)->GetHiddenAreaMesh((vr::EVREye)eEye, (vr::EHiddenAreaMeshType)type);
}
bool cppIVRSystem_IVRSystem_022_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1237 * pControllerState, uint32_t unControllerStateSize)
bool cppIVRSystem_IVRSystem_022_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1267 * pControllerState, uint32_t unControllerStateSize)
{
VRControllerState001_t lin;
bool _ret;
if(pControllerState)
struct_VRControllerState001_t_1237_win_to_lin(pControllerState, &lin);
struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, unControllerStateSize ? sizeof(lin) : 0);
if(pControllerState)
struct_VRControllerState001_t_1237_lin_to_win(&lin, pControllerState, unControllerStateSize);
struct_VRControllerState001_t_1267_lin_to_win(&lin, pControllerState, unControllerStateSize);
return _ret;
}
bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1237 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1267 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
{
VRControllerState001_t lin;
bool _ret;
if(pControllerState)
struct_VRControllerState001_t_1237_win_to_lin(pControllerState, &lin);
struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin);
_ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, unControllerStateSize ? sizeof(lin) : 0, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
if(pControllerState)
struct_VRControllerState001_t_1237_lin_to_win(&lin, pControllerState, unControllerStateSize);
struct_VRControllerState001_t_1267_lin_to_win(&lin, pControllerState, unControllerStateSize);
return _ret;
}

8
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_022.h
View File

@ -30,12 +30,12 @@ extern HmdMatrix34_t cppIVRSystem_IVRSystem_022_GetMatrix34TrackedDeviceProperty
extern uint32_t cppIVRSystem_IVRSystem_022_GetArrayTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, PropertyTypeTag_t, void *, uint32_t, ETrackedPropertyError *);
extern uint32_t cppIVRSystem_IVRSystem_022_GetStringTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, char *, uint32_t, ETrackedPropertyError *);
extern const char * cppIVRSystem_IVRSystem_022_GetPropErrorNameFromEnum(void *, ETrackedPropertyError);
extern bool cppIVRSystem_IVRSystem_022_PollNextEvent(void *, winVREvent_t_1237 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1237 *, uint32_t, TrackedDevicePose_t *);
extern bool cppIVRSystem_IVRSystem_022_PollNextEvent(void *, winVREvent_t_1267 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1267 *, uint32_t, TrackedDevicePose_t *);
extern const char * cppIVRSystem_IVRSystem_022_GetEventTypeNameFromEnum(void *, EVREventType);
extern HiddenAreaMesh_t cppIVRSystem_IVRSystem_022_GetHiddenAreaMesh(void *, EVREye, EHiddenAreaMeshType);
extern bool cppIVRSystem_IVRSystem_022_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1237 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1237 *, uint32_t, TrackedDevicePose_t *);
extern bool cppIVRSystem_IVRSystem_022_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1267 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1267 *, uint32_t, TrackedDevicePose_t *);
extern void cppIVRSystem_IVRSystem_022_TriggerHapticPulse(void *, TrackedDeviceIndex_t, uint32_t, unsigned short);
extern const char * cppIVRSystem_IVRSystem_022_GetButtonIdNameFromEnum(void *, EVRButtonId);
extern const char * cppIVRSystem_IVRSystem_022_GetControllerAxisTypeNameFromEnum(void *, EVRControllerAxisType);

20
vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
#include "openvr_v1.26.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
@ -44,15 +44,15 @@ vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_ReleaseVideoS
return ((IVRTrackedCamera*)linux_side)->ReleaseVideoStreamingService((vr::TrackedCameraHandle_t)hTrackedCamera);
}
vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1237 * pFrameHeader, uint32_t nFrameHeaderSize)
vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1267 * pFrameHeader, uint32_t nFrameHeaderSize)
{
CameraVideoStreamFrameHeader_t lin;
vr::EVRTrackedCameraError _ret;
if(pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1237_win_to_lin(pFrameHeader, &lin);
struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin);
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamFrameBuffer((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pFrameBuffer, (uint32_t)nFrameBufferSize, pFrameHeader ? &lin : nullptr, nFrameHeaderSize ? sizeof(lin) : 0);
if(pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1237_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
return _ret;
}
@ -61,27 +61,27 @@ vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStrea
return ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureSize((vr::TrackedDeviceIndex_t)nDeviceIndex, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::VRTextureBounds_t *)pTextureBounds, (uint32_t *)pnWidth, (uint32_t *)pnHeight);
}
vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1237 * pFrameHeader, uint32_t nFrameHeaderSize)
vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1267 * pFrameHeader, uint32_t nFrameHeaderSize)
{
CameraVideoStreamFrameHeader_t lin;
vr::EVRTrackedCameraError _ret;
if(pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1237_win_to_lin(pFrameHeader, &lin);
struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin);
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureD3D11((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView, pFrameHeader ? &lin : nullptr, nFrameHeaderSize ? sizeof(lin) : 0);
if(pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1237_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
return _ret;
}
vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1237 * pFrameHeader, uint32_t nFrameHeaderSize)
vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1267 * pFrameHeader, uint32_t nFrameHeaderSize)
{
CameraVideoStreamFrameHeader_t lin;
vr::EVRTrackedCameraError _ret;
if(pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1237_win_to_lin(pFrameHeader, &lin);
struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin);
_ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureGL((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::glUInt_t *)pglTextureId, pFrameHeader ? &lin : nullptr, nFrameHeaderSize ? sizeof(lin) : 0);
if(pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1237_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
return _ret;
}

6
vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.h
View File

@ -8,10 +8,10 @@ extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetCameraI
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetCameraProjection(void *, TrackedDeviceIndex_t, uint32_t, EVRTrackedCameraFrameType, float, float, HmdMatrix44_t *);
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_AcquireVideoStreamingService(void *, TrackedDeviceIndex_t, TrackedCameraHandle_t *);
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_ReleaseVideoStreamingService(void *, TrackedCameraHandle_t);
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, uint32_t, winCameraVideoStreamFrameHeader_t_1237 *, uint32_t);
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, uint32_t, winCameraVideoStreamFrameHeader_t_1267 *, uint32_t);
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureSize(void *, TrackedDeviceIndex_t, EVRTrackedCameraFrameType, VRTextureBounds_t *, uint32_t *, uint32_t *);
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, void **, winCameraVideoStreamFrameHeader_t_1237 *, uint32_t);
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, winCameraVideoStreamFrameHeader_t_1237 *, uint32_t);
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, void **, winCameraVideoStreamFrameHeader_t_1267 *, uint32_t);
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, winCameraVideoStreamFrameHeader_t_1267 *, uint32_t);
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_ReleaseVideoStreamTextureGL(void *, TrackedCameraHandle_t, glUInt_t);
extern void cppIVRTrackedCamera_IVRTrackedCamera_006_SetCameraTrackingSpace(void *, ETrackingUniverseOrigin);
extern ETrackingUniverseOrigin cppIVRTrackedCamera_IVRTrackedCamera_006_GetCameraTrackingSpace(void *);

34
vrclient_x64/vrclient_x64/struct_converters.h
View File

@ -1,3 +1,37 @@
typedef struct winVRVulkanTextureArrayData_t_1267 winVRVulkanTextureArrayData_t_1267;
extern void struct_VRVulkanTextureArrayData_t_1267_lin_to_win(void *l, void *w);
extern void struct_VRVulkanTextureArrayData_t_1267_win_to_lin(void *w, void *l);
typedef struct winVREvent_t_1267 winVREvent_t_1267;
extern void struct_VREvent_t_1267_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_VREvent_t_1267_win_to_lin(void *w, void *l);
typedef struct winVRControllerState001_t_1267 winVRControllerState001_t_1267;
extern void struct_VRControllerState001_t_1267_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_VRControllerState001_t_1267_win_to_lin(void *w, void *l);
typedef struct winCameraVideoStreamFrameHeader_t_1267 winCameraVideoStreamFrameHeader_t_1267;
extern void struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(void *w, void *l);
typedef struct winRenderModel_TextureMap_t_1267 winRenderModel_TextureMap_t_1267;
extern void struct_RenderModel_TextureMap_t_1267_lin_to_win(void *l, void *w);
extern void struct_RenderModel_TextureMap_t_1267_win_to_lin(void *w, void *l);
extern struct winRenderModel_TextureMap_t_1267 *struct_RenderModel_TextureMap_t_1267_wrap(void *l);
extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1267_unwrap(winRenderModel_TextureMap_t_1267 *w);
typedef struct winRenderModel_t_1267 winRenderModel_t_1267;
extern void struct_RenderModel_t_1267_lin_to_win(void *l, void *w);
extern void struct_RenderModel_t_1267_win_to_lin(void *w, void *l);
extern struct winRenderModel_t_1267 *struct_RenderModel_t_1267_wrap(void *l);
extern RenderModel_t *struct_RenderModel_t_1267_unwrap(winRenderModel_t_1267 *w);
typedef struct winInputAnalogActionData_t_1267 winInputAnalogActionData_t_1267;
extern void struct_InputAnalogActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_InputAnalogActionData_t_1267_win_to_lin(void *w, void *l);
typedef struct winInputDigitalActionData_t_1267 winInputDigitalActionData_t_1267;
extern void struct_InputDigitalActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_InputDigitalActionData_t_1267_win_to_lin(void *w, void *l);
typedef struct winInputPoseActionData_t_1267 winInputPoseActionData_t_1267;
extern void struct_InputPoseActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_InputPoseActionData_t_1267_win_to_lin(void *w, void *l);
typedef struct winInputSkeletalActionData_t_1267 winInputSkeletalActionData_t_1267;
extern void struct_InputSkeletalActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_InputSkeletalActionData_t_1267_win_to_lin(void *w, void *l);
typedef struct winVRVulkanTextureArrayData_t_1237 winVRVulkanTextureArrayData_t_1237;
extern void struct_VRVulkanTextureArrayData_t_1237_lin_to_win(void *l, void *w);
extern void struct_VRVulkanTextureArrayData_t_1237_win_to_lin(void *w, void *l);

362
vrclient_x64/vrclient_x64/struct_converters_1267.cpp Normal file
View File

@ -0,0 +1,362 @@
#include <stdlib.h>
#include <string.h>
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.26.7/openvr.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
#pragma pack(push, 8)
struct winVRVulkanTextureArrayData_t_1267 {
uint32_t m_unArrayIndex;
uint32_t m_unArraySize;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_VRVulkanTextureArrayData_t_1267_lin_to_win(void *l, void *w)
{
struct winVRVulkanTextureArrayData_t_1267 *win = (struct winVRVulkanTextureArrayData_t_1267 *)w;
VRVulkanTextureArrayData_t *lin = (VRVulkanTextureArrayData_t *)l;
win->m_unArrayIndex = lin->m_unArrayIndex;
win->m_unArraySize = lin->m_unArraySize;
}
void struct_VRVulkanTextureArrayData_t_1267_win_to_lin(void *w, void *l)
{
struct winVRVulkanTextureArrayData_t_1267 *win = (struct winVRVulkanTextureArrayData_t_1267 *)w;
VRVulkanTextureArrayData_t *lin = (VRVulkanTextureArrayData_t *)l;
lin->m_unArrayIndex = win->m_unArrayIndex;
lin->m_unArraySize = win->m_unArraySize;
}
#pragma pack(push, 8)
struct winVREvent_t_1267 {
uint32_t eventType;
vr::TrackedDeviceIndex_t trackedDeviceIndex;
float eventAgeSeconds;
vr::VREvent_Data_t data __attribute__((aligned(8)));
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_VREvent_t_1267_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winVREvent_t_1267 *win = (struct winVREvent_t_1267 *)w;
VREvent_t *lin = (VREvent_t *)l;
win->eventType = lin->eventType;
win->trackedDeviceIndex = lin->trackedDeviceIndex;
win->eventAgeSeconds = lin->eventAgeSeconds;
memcpy(&win->data, &lin->data, sz - (((char*)&win->data) - ((char*)win)));
}
void struct_VREvent_t_1267_win_to_lin(void *w, void *l)
{
struct winVREvent_t_1267 *win = (struct winVREvent_t_1267 *)w;
VREvent_t *lin = (VREvent_t *)l;
lin->eventType = win->eventType;
lin->trackedDeviceIndex = win->trackedDeviceIndex;
lin->eventAgeSeconds = win->eventAgeSeconds;
lin->data = win->data;
}
#pragma pack(push, 8)
struct winVRControllerState001_t_1267 {
uint32_t unPacketNum;
uint64_t ulButtonPressed;
uint64_t ulButtonTouched;
vr::VRControllerAxis_t rAxis[5];
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_VRControllerState001_t_1267_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winVRControllerState001_t_1267 *win = (struct winVRControllerState001_t_1267 *)w;
VRControllerState001_t *lin = (VRControllerState001_t *)l;
win->unPacketNum = lin->unPacketNum;
win->ulButtonPressed = lin->ulButtonPressed;
win->ulButtonTouched = lin->ulButtonTouched;
memcpy(win->rAxis, lin->rAxis, sizeof(win->rAxis));
}
void struct_VRControllerState001_t_1267_win_to_lin(void *w, void *l)
{
struct winVRControllerState001_t_1267 *win = (struct winVRControllerState001_t_1267 *)w;
VRControllerState001_t *lin = (VRControllerState001_t *)l;
lin->unPacketNum = win->unPacketNum;
lin->ulButtonPressed = win->ulButtonPressed;
lin->ulButtonTouched = win->ulButtonTouched;
memcpy(lin->rAxis, win->rAxis, sizeof(lin->rAxis));
}
#pragma pack(push, 8)
struct winCameraVideoStreamFrameHeader_t_1267 {
vr::EVRTrackedCameraFrameType eFrameType;
uint32_t nWidth;
uint32_t nHeight;
uint32_t nBytesPerPixel;
uint32_t nFrameSequence;
vr::TrackedDevicePose_t trackedDevicePose __attribute__((aligned(4)));
uint64_t ulFrameExposureTime;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winCameraVideoStreamFrameHeader_t_1267 *win = (struct winCameraVideoStreamFrameHeader_t_1267 *)w;
CameraVideoStreamFrameHeader_t *lin = (CameraVideoStreamFrameHeader_t *)l;
win->eFrameType = lin->eFrameType;
win->nWidth = lin->nWidth;
win->nHeight = lin->nHeight;
win->nBytesPerPixel = lin->nBytesPerPixel;
win->nFrameSequence = lin->nFrameSequence;
win->trackedDevicePose = lin->trackedDevicePose;
win->ulFrameExposureTime = lin->ulFrameExposureTime;
}
void struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(void *w, void *l)
{
struct winCameraVideoStreamFrameHeader_t_1267 *win = (struct winCameraVideoStreamFrameHeader_t_1267 *)w;
CameraVideoStreamFrameHeader_t *lin = (CameraVideoStreamFrameHeader_t *)l;
lin->eFrameType = win->eFrameType;
lin->nWidth = win->nWidth;
lin->nHeight = win->nHeight;
lin->nBytesPerPixel = win->nBytesPerPixel;
lin->nFrameSequence = win->nFrameSequence;
lin->trackedDevicePose = win->trackedDevicePose;
lin->ulFrameExposureTime = win->ulFrameExposureTime;
}
#pragma pack(push, 8)
struct winRenderModel_TextureMap_t_1267 {
uint16_t unWidth;
uint16_t unHeight;
const uint8_t * rubTextureMapData;
vr::EVRRenderModelTextureFormat format;
uint16_t unMipLevels;
RenderModel_TextureMap_t *linux_side;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_RenderModel_TextureMap_t_1267_lin_to_win(void *l, void *w)
{
struct winRenderModel_TextureMap_t_1267 *win = (struct winRenderModel_TextureMap_t_1267 *)w;
RenderModel_TextureMap_t *lin = (RenderModel_TextureMap_t *)l;
win->unWidth = lin->unWidth;
win->unHeight = lin->unHeight;
win->rubTextureMapData = lin->rubTextureMapData;
win->format = lin->format;
win->unMipLevels = lin->unMipLevels;
}
void struct_RenderModel_TextureMap_t_1267_win_to_lin(void *w, void *l)
{
struct winRenderModel_TextureMap_t_1267 *win = (struct winRenderModel_TextureMap_t_1267 *)w;
RenderModel_TextureMap_t *lin = (RenderModel_TextureMap_t *)l;
lin->unWidth = win->unWidth;
lin->unHeight = win->unHeight;
lin->rubTextureMapData = win->rubTextureMapData;
lin->format = win->format;
lin->unMipLevels = win->unMipLevels;
}
struct winRenderModel_TextureMap_t_1267 *struct_RenderModel_TextureMap_t_1267_wrap(void *l)
{
struct winRenderModel_TextureMap_t_1267 *win = (struct winRenderModel_TextureMap_t_1267 *)malloc(sizeof(*win));
RenderModel_TextureMap_t *lin = (RenderModel_TextureMap_t *)l;
win->unWidth = lin->unWidth;
win->unHeight = lin->unHeight;
win->rubTextureMapData = lin->rubTextureMapData;
win->format = lin->format;
win->unMipLevels = lin->unMipLevels;
win->linux_side = lin;
return win;
}
struct RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1267_unwrap(winRenderModel_TextureMap_t_1267 *w)
{
RenderModel_TextureMap_t *ret = w->linux_side;
free(w);
return ret;
}
#pragma pack(push, 8)
struct winRenderModel_t_1267 {
const vr::RenderModel_Vertex_t * rVertexData;
uint32_t unVertexCount;
const uint16_t * rIndexData;
uint32_t unTriangleCount;
vr::TextureID_t diffuseTextureId;
RenderModel_t *linux_side;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_RenderModel_t_1267_lin_to_win(void *l, void *w)
{
struct winRenderModel_t_1267 *win = (struct winRenderModel_t_1267 *)w;
RenderModel_t *lin = (RenderModel_t *)l;
win->rVertexData = lin->rVertexData;
win->unVertexCount = lin->unVertexCount;
win->rIndexData = lin->rIndexData;
win->unTriangleCount = lin->unTriangleCount;
win->diffuseTextureId = lin->diffuseTextureId;
}
void struct_RenderModel_t_1267_win_to_lin(void *w, void *l)
{
struct winRenderModel_t_1267 *win = (struct winRenderModel_t_1267 *)w;
RenderModel_t *lin = (RenderModel_t *)l;
lin->rVertexData = win->rVertexData;
lin->unVertexCount = win->unVertexCount;
lin->rIndexData = win->rIndexData;
lin->unTriangleCount = win->unTriangleCount;
lin->diffuseTextureId = win->diffuseTextureId;
}
struct winRenderModel_t_1267 *struct_RenderModel_t_1267_wrap(void *l)
{
struct winRenderModel_t_1267 *win = (struct winRenderModel_t_1267 *)malloc(sizeof(*win));
RenderModel_t *lin = (RenderModel_t *)l;
win->rVertexData = lin->rVertexData;
win->unVertexCount = lin->unVertexCount;
win->rIndexData = lin->rIndexData;
win->unTriangleCount = lin->unTriangleCount;
win->diffuseTextureId = lin->diffuseTextureId;
win->linux_side = lin;
return win;
}
struct RenderModel_t *struct_RenderModel_t_1267_unwrap(winRenderModel_t_1267 *w)
{
RenderModel_t *ret = w->linux_side;
free(w);
return ret;
}
#pragma pack(push, 8)
struct winInputAnalogActionData_t_1267 {
bool bActive;
vr::VRInputValueHandle_t activeOrigin;
float x;
float y;
float z;
float deltaX;
float deltaY;
float deltaZ;
float fUpdateTime;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_InputAnalogActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winInputAnalogActionData_t_1267 *win = (struct winInputAnalogActionData_t_1267 *)w;
InputAnalogActionData_t *lin = (InputAnalogActionData_t *)l;
win->bActive = lin->bActive;
win->activeOrigin = lin->activeOrigin;
win->x = lin->x;
win->y = lin->y;
win->z = lin->z;
win->deltaX = lin->deltaX;
win->deltaY = lin->deltaY;
win->deltaZ = lin->deltaZ;
win->fUpdateTime = lin->fUpdateTime;
}
void struct_InputAnalogActionData_t_1267_win_to_lin(void *w, void *l)
{
struct winInputAnalogActionData_t_1267 *win = (struct winInputAnalogActionData_t_1267 *)w;
InputAnalogActionData_t *lin = (InputAnalogActionData_t *)l;
lin->bActive = win->bActive;
lin->activeOrigin = win->activeOrigin;
lin->x = win->x;
lin->y = win->y;
lin->z = win->z;
lin->deltaX = win->deltaX;
lin->deltaY = win->deltaY;
lin->deltaZ = win->deltaZ;
lin->fUpdateTime = win->fUpdateTime;
}
#pragma pack(push, 8)
struct winInputDigitalActionData_t_1267 {
bool bActive;
vr::VRInputValueHandle_t activeOrigin;
bool bState;
bool bChanged;
float fUpdateTime;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_InputDigitalActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winInputDigitalActionData_t_1267 *win = (struct winInputDigitalActionData_t_1267 *)w;
InputDigitalActionData_t *lin = (InputDigitalActionData_t *)l;
win->bActive = lin->bActive;
win->activeOrigin = lin->activeOrigin;
win->bState = lin->bState;
win->bChanged = lin->bChanged;
win->fUpdateTime = lin->fUpdateTime;
}
void struct_InputDigitalActionData_t_1267_win_to_lin(void *w, void *l)
{
struct winInputDigitalActionData_t_1267 *win = (struct winInputDigitalActionData_t_1267 *)w;
InputDigitalActionData_t *lin = (InputDigitalActionData_t *)l;
lin->bActive = win->bActive;
lin->activeOrigin = win->activeOrigin;
lin->bState = win->bState;
lin->bChanged = win->bChanged;
lin->fUpdateTime = win->fUpdateTime;
}
#pragma pack(push, 8)
struct winInputPoseActionData_t_1267 {
bool bActive;
vr::VRInputValueHandle_t activeOrigin;
vr::TrackedDevicePose_t pose __attribute__((aligned(4)));
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_InputPoseActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winInputPoseActionData_t_1267 *win = (struct winInputPoseActionData_t_1267 *)w;
InputPoseActionData_t *lin = (InputPoseActionData_t *)l;
win->bActive = lin->bActive;
win->activeOrigin = lin->activeOrigin;
win->pose = lin->pose;
}
void struct_InputPoseActionData_t_1267_win_to_lin(void *w, void *l)
{
struct winInputPoseActionData_t_1267 *win = (struct winInputPoseActionData_t_1267 *)w;
InputPoseActionData_t *lin = (InputPoseActionData_t *)l;
lin->bActive = win->bActive;
lin->activeOrigin = win->activeOrigin;
lin->pose = win->pose;
}
#pragma pack(push, 8)
struct winInputSkeletalActionData_t_1267 {
bool bActive;
vr::VRInputValueHandle_t activeOrigin;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_InputSkeletalActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winInputSkeletalActionData_t_1267 *win = (struct winInputSkeletalActionData_t_1267 *)w;
InputSkeletalActionData_t *lin = (InputSkeletalActionData_t *)l;
win->bActive = lin->bActive;
win->activeOrigin = lin->activeOrigin;
}
void struct_InputSkeletalActionData_t_1267_win_to_lin(void *w, void *l)
{
struct winInputSkeletalActionData_t_1267 *win = (struct winInputSkeletalActionData_t_1267 *)w;
InputSkeletalActionData_t *lin = (InputSkeletalActionData_t *)l;
lin->bActive = win->bActive;
lin->activeOrigin = win->activeOrigin;
}
}

6
vrclient_x64/vrclient_x64/vrclient_main.c
View File

@ -37,10 +37,10 @@ typedef struct winRenderModel_t_1015 winRenderModel_t_1015;
typedef struct winRenderModel_TextureMap_t_1015 winRenderModel_TextureMap_t_1015;
#include "cppIVRRenderModels_IVRRenderModels_005.h"
/* this is converted to 1237 during load_linux_texture_map, so ensure new
/* this is converted to 1267 during load_linux_texture_map, so ensure new
* structure is compatible before updating this number */
typedef struct winRenderModel_t_1237 winRenderModel_t_1237;
typedef struct winRenderModel_TextureMap_t_1237 winRenderModel_TextureMap_t_1237;
typedef struct winRenderModel_t_1267 winRenderModel_t_1267;
typedef struct winRenderModel_TextureMap_t_1267 winRenderModel_TextureMap_t_1267;
#include "cppIVRRenderModels_IVRRenderModels_006.h"
#include "wine/unixlib.h"

10
vrclient_x64/vrclient_x64/winIVRInput.c
View File

@ -63,35 +63,35 @@ EVRInputError __thiscall winIVRInput_IVRInput_010_UpdateActionState(winIVRInput_
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetDigitalActionData, 28)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetDigitalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputDigitalActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetDigitalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputDigitalActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return ivrinput_get_digital_action_data(cppIVRInput_IVRInput_010_GetDigitalActionData, _this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice, 10);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetAnalogActionData, 28)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetAnalogActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputAnalogActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetAnalogActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputAnalogActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_010_GetAnalogActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow, 36)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(_this->linux_side, action, eOrigin, fPredictedSecondsFromNow, pActionData, unActionDataSize, ulRestrictToDevice);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetPoseActionDataForNextFrame, 32)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(_this->linux_side, action, eOrigin, pActionData, unActionDataSize, ulRestrictToDevice);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetSkeletalActionData, 20)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetSkeletalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputSkeletalActionData_t_1237 * pActionData, uint32_t unActionDataSize)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetSkeletalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputSkeletalActionData_t_1267 * pActionData, uint32_t unActionDataSize)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_010_GetSkeletalActionData(_this->linux_side, action, pActionData, unActionDataSize);

779
vrclient_x64/vrclient_x64/winIVROverlay.c
View File

@ -18,6 +18,785 @@
WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
#include "cppIVROverlay_IVROverlay_027.h"
typedef struct __winIVROverlay_IVROverlay_027 {
vtable_ptr *vtable;
void *linux_side;
} winIVROverlay_IVROverlay_027;
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_FindOverlay, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_FindOverlay(winIVROverlay_IVROverlay_027 *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_FindOverlay(_this->linux_side, pchOverlayKey, pOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_CreateOverlay, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_CreateOverlay(winIVROverlay_IVROverlay_027 *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_CreateOverlay(_this->linux_side, pchOverlayKey, pchOverlayName, pOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_DestroyOverlay, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_DestroyOverlay(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_DestroyOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayKey, 24)
uint32_t __thiscall winIVROverlay_IVROverlay_027_GetOverlayKey(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayKey(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pError);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayName, 24)
uint32_t __thiscall winIVROverlay_IVROverlay_027_GetOverlayName(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayName(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pError);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayName, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayName(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayName(_this->linux_side, ulOverlayHandle, pchName);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayImageData, 28)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayImageData(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayImageData(_this->linux_side, ulOverlayHandle, pvBuffer, unBufferSize, punWidth, punHeight);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayErrorNameFromEnum, 8)
const char * __thiscall winIVROverlay_IVROverlay_027_GetOverlayErrorNameFromEnum(winIVROverlay_IVROverlay_027 *_this, EVROverlayError error)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayErrorNameFromEnum(_this->linux_side, error);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayRenderingPid, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayRenderingPid(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayRenderingPid(_this->linux_side, ulOverlayHandle, unPID);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayRenderingPid, 12)
uint32_t __thiscall winIVROverlay_IVROverlay_027_GetOverlayRenderingPid(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayRenderingPid(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayFlag, 17)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayFlag(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayFlag(_this->linux_side, ulOverlayHandle, eOverlayFlag, bEnabled);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayFlag, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayFlag(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayFlag(_this->linux_side, ulOverlayHandle, eOverlayFlag, pbEnabled);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayFlags, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayFlags(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayFlags(_this->linux_side, ulOverlayHandle, pFlags);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayColor, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayColor(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayColor(_this->linux_side, ulOverlayHandle, fRed, fGreen, fBlue);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayColor, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayColor(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayColor(_this->linux_side, ulOverlayHandle, pfRed, pfGreen, pfBlue);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayAlpha, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayAlpha(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayAlpha(_this->linux_side, ulOverlayHandle, fAlpha);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayAlpha, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayAlpha(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayAlpha(_this->linux_side, ulOverlayHandle, pfAlpha);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTexelAspect, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTexelAspect(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayTexelAspect(_this->linux_side, ulOverlayHandle, fTexelAspect);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTexelAspect, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTexelAspect(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayTexelAspect(_this->linux_side, ulOverlayHandle, pfTexelAspect);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlaySortOrder, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlaySortOrder(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlaySortOrder(_this->linux_side, ulOverlayHandle, unSortOrder);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlaySortOrder, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlaySortOrder(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlaySortOrder(_this->linux_side, ulOverlayHandle, punSortOrder);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayWidthInMeters, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayWidthInMeters(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayWidthInMeters(_this->linux_side, ulOverlayHandle, fWidthInMeters);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayWidthInMeters, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayWidthInMeters(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayWidthInMeters(_this->linux_side, ulOverlayHandle, pfWidthInMeters);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayCurvature, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayCurvature(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayCurvature(_this->linux_side, ulOverlayHandle, fCurvature);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayCurvature, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayCurvature(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayCurvature(_this->linux_side, ulOverlayHandle, pfCurvature);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayPreCurvePitch, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayPreCurvePitch(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float fRadians)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayPreCurvePitch(_this->linux_side, ulOverlayHandle, fRadians);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayPreCurvePitch, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayPreCurvePitch(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float * pfRadians)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayPreCurvePitch(_this->linux_side, ulOverlayHandle, pfRadians);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTextureColorSpace, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTextureColorSpace(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayTextureColorSpace(_this->linux_side, ulOverlayHandle, eTextureColorSpace);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTextureColorSpace, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTextureColorSpace(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayTextureColorSpace(_this->linux_side, ulOverlayHandle, peTextureColorSpace);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTextureBounds, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTextureBounds(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayTextureBounds(_this->linux_side, ulOverlayHandle, pOverlayTextureBounds);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTextureBounds, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTextureBounds(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayTextureBounds(_this->linux_side, ulOverlayHandle, pOverlayTextureBounds);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTransformType, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTransformType(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayTransformType(_this->linux_side, ulOverlayHandle, peTransformType);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTransformAbsolute, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTransformAbsolute(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayTransformAbsolute(_this->linux_side, ulOverlayHandle, eTrackingOrigin, pmatTrackingOriginToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTransformAbsolute, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTransformAbsolute(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayTransformAbsolute(_this->linux_side, ulOverlayHandle, peTrackingOrigin, pmatTrackingOriginToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceRelative, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceRelative(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceRelative(_this->linux_side, ulOverlayHandle, unTrackedDevice, pmatTrackedDeviceToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceRelative, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceRelative(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceRelative(_this->linux_side, ulOverlayHandle, punTrackedDevice, pmatTrackedDeviceToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceComponent, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceComponent(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceComponent(_this->linux_side, ulOverlayHandle, unDeviceIndex, pchComponentName);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceComponent, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceComponent(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceComponent(_this->linux_side, ulOverlayHandle, punDeviceIndex, pchComponentName, unComponentNameSize);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTransformCursor, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTransformCursor(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayTransformCursor(_this->linux_side, ulCursorOverlayHandle, pvHotspot);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTransformCursor, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTransformCursor(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayTransformCursor(_this->linux_side, ulOverlayHandle, pvHotspot);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTransformProjection, 28)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTransformProjection(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayTransformProjection(_this->linux_side, ulOverlayHandle, eTrackingOrigin, pmatTrackingOriginToOverlayTransform, pProjection, eEye);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ShowOverlay, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_ShowOverlay(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_ShowOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_HideOverlay, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_HideOverlay(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_HideOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_IsOverlayVisible, 12)
bool __thiscall winIVROverlay_IVROverlay_027_IsOverlayVisible(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_IsOverlayVisible(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetTransformForOverlayCoordinates, 28)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetTransformForOverlayCoordinates(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetTransformForOverlayCoordinates(_this->linux_side, ulOverlayHandle, eTrackingOrigin, coordinatesInOverlay, pmatTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_WaitFrameSync, 8)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_WaitFrameSync(winIVROverlay_IVROverlay_027 *_this, uint32_t nTimeoutMs)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_WaitFrameSync(_this->linux_side, nTimeoutMs);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_PollNextOverlayEvent, 20)
bool __thiscall winIVROverlay_IVROverlay_027_PollNextOverlayEvent(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1267 * pEvent, uint32_t uncbVREvent)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_PollNextOverlayEvent(_this->linux_side, ulOverlayHandle, pEvent, uncbVREvent);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayInputMethod, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayInputMethod(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayInputMethod(_this->linux_side, ulOverlayHandle, peInputMethod);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayInputMethod, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayInputMethod(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayInputMethod(_this->linux_side, ulOverlayHandle, eInputMethod);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayMouseScale, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayMouseScale(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayMouseScale(_this->linux_side, ulOverlayHandle, pvecMouseScale);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayMouseScale, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayMouseScale(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayMouseScale(_this->linux_side, ulOverlayHandle, pvecMouseScale);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ComputeOverlayIntersection, 20)
bool __thiscall winIVROverlay_IVROverlay_027_ComputeOverlayIntersection(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_ComputeOverlayIntersection(_this->linux_side, ulOverlayHandle, pParams, pResults);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_IsHoverTargetOverlay, 12)
bool __thiscall winIVROverlay_IVROverlay_027_IsHoverTargetOverlay(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_IsHoverTargetOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayIntersectionMask, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayIntersectionMask(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayIntersectionMask(_this->linux_side, ulOverlayHandle, pMaskPrimitives, unNumMaskPrimitives, unPrimitiveSize);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_TriggerLaserMouseHapticVibration, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_TriggerLaserMouseHapticVibration(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_TriggerLaserMouseHapticVibration(_this->linux_side, ulOverlayHandle, fDurationSeconds, fFrequency, fAmplitude);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayCursor, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayCursor(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayCursor(_this->linux_side, ulOverlayHandle, ulCursorHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayCursorPositionOverride, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayCursorPositionOverride(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayCursorPositionOverride(_this->linux_side, ulOverlayHandle, pvCursor);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ClearOverlayCursorPositionOverride, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_ClearOverlayCursorPositionOverride(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_ClearOverlayCursorPositionOverride(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTexture, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTexture(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
{
TRACE("%p\n", _this);
return ivroverlay_set_overlay_texture(cppIVROverlay_IVROverlay_027_SetOverlayTexture, _this->linux_side, ulOverlayHandle, pTexture, 27);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ClearOverlayTexture, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_ClearOverlayTexture(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_ClearOverlayTexture(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayRaw, 28)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayRaw(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayRaw(_this->linux_side, ulOverlayHandle, pvBuffer, unWidth, unHeight, unBytesPerPixel);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayFromFile, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayFromFile(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
{
char lin_pchFilePath[PATH_MAX];
vrclient_dos_path_to_unix_path(pchFilePath, lin_pchFilePath);
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetOverlayFromFile(_this->linux_side, ulOverlayHandle, pchFilePath ? lin_pchFilePath : NULL);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTexture, 44)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTexture(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayTexture(_this->linux_side, ulOverlayHandle, pNativeTextureHandle, pNativeTextureRef, pWidth, pHeight, pNativeFormat, pAPIType, pColorSpace, pTextureBounds);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ReleaseNativeOverlayHandle, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_ReleaseNativeOverlayHandle(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_ReleaseNativeOverlayHandle(_this->linux_side, ulOverlayHandle, pNativeTextureHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTextureSize, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTextureSize(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetOverlayTextureSize(_this->linux_side, ulOverlayHandle, pWidth, pHeight);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_CreateDashboardOverlay, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_CreateDashboardOverlay(winIVROverlay_IVROverlay_027 *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_CreateDashboardOverlay(_this->linux_side, pchOverlayKey, pchOverlayFriendlyName, pMainHandle, pThumbnailHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_IsDashboardVisible, 4)
bool __thiscall winIVROverlay_IVROverlay_027_IsDashboardVisible(winIVROverlay_IVROverlay_027 *_this)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_IsDashboardVisible(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_IsActiveDashboardOverlay, 12)
bool __thiscall winIVROverlay_IVROverlay_027_IsActiveDashboardOverlay(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_IsActiveDashboardOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetDashboardOverlaySceneProcess, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetDashboardOverlaySceneProcess(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_SetDashboardOverlaySceneProcess(_this->linux_side, ulOverlayHandle, unProcessId);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetDashboardOverlaySceneProcess, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetDashboardOverlaySceneProcess(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetDashboardOverlaySceneProcess(_this->linux_side, ulOverlayHandle, punProcessId);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ShowDashboard, 8)
void __thiscall winIVROverlay_IVROverlay_027_ShowDashboard(winIVROverlay_IVROverlay_027 *_this, const char * pchOverlayToShow)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_027_ShowDashboard(_this->linux_side, pchOverlayToShow);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetPrimaryDashboardDevice, 4)
TrackedDeviceIndex_t __thiscall winIVROverlay_IVROverlay_027_GetPrimaryDashboardDevice(winIVROverlay_IVROverlay_027 *_this)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetPrimaryDashboardDevice(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ShowKeyboard, 36)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_ShowKeyboard(winIVROverlay_IVROverlay_027 *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_ShowKeyboard(_this->linux_side, eInputMode, eLineInputMode, unFlags, pchDescription, unCharMax, pchExistingText, uUserValue);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ShowKeyboardForOverlay, 44)
EVROverlayError __thiscall winIVROverlay_IVROverlay_027_ShowKeyboardForOverlay(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_ShowKeyboardForOverlay(_this->linux_side, ulOverlayHandle, eInputMode, eLineInputMode, unFlags, pchDescription, unCharMax, pchExistingText, uUserValue);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetKeyboardText, 12)
uint32_t __thiscall winIVROverlay_IVROverlay_027_GetKeyboardText(winIVROverlay_IVROverlay_027 *_this, char * pchText, uint32_t cchText)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_GetKeyboardText(_this->linux_side, pchText, cchText);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_HideKeyboard, 4)
void __thiscall winIVROverlay_IVROverlay_027_HideKeyboard(winIVROverlay_IVROverlay_027 *_this)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_027_HideKeyboard(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetKeyboardTransformAbsolute, 12)
void __thiscall winIVROverlay_IVROverlay_027_SetKeyboardTransformAbsolute(winIVROverlay_IVROverlay_027 *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_027_SetKeyboardTransformAbsolute(_this->linux_side, eTrackingOrigin, pmatTrackingOriginToKeyboardTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetKeyboardPositionForOverlay, 28)
void __thiscall winIVROverlay_IVROverlay_027_SetKeyboardPositionForOverlay(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_027_SetKeyboardPositionForOverlay(_this->linux_side, ulOverlayHandle, avoidRect);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ShowMessageOverlay, 28)
VRMessageOverlayResponse __thiscall winIVROverlay_IVROverlay_027_ShowMessageOverlay(winIVROverlay_IVROverlay_027 *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_027_ShowMessageOverlay(_this->linux_side, pchText, pchCaption, pchButton0Text, pchButton1Text, pchButton2Text, pchButton3Text);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_CloseMessageOverlay, 4)
void __thiscall winIVROverlay_IVROverlay_027_CloseMessageOverlay(winIVROverlay_IVROverlay_027 *_this)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_027_CloseMessageOverlay(_this->linux_side);
}
extern vtable_ptr winIVROverlay_IVROverlay_027_vtable;
#ifndef __GNUC__
void __asm_dummy_vtables(void) {
#endif
__ASM_VTABLE(winIVROverlay_IVROverlay_027,
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_FindOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_CreateOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_DestroyOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayKey)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayName)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayName)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayImageData)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayErrorNameFromEnum)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayRenderingPid)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayRenderingPid)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayFlag)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayFlag)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayFlags)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayColor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayColor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayAlpha)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayAlpha)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTexelAspect)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTexelAspect)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlaySortOrder)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlaySortOrder)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayWidthInMeters)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayWidthInMeters)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayCurvature)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayCurvature)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayPreCurvePitch)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayPreCurvePitch)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTextureColorSpace)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTextureColorSpace)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTextureBounds)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTextureBounds)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTransformType)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTransformAbsolute)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTransformAbsolute)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceRelative)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceRelative)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceComponent)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceComponent)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTransformCursor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTransformCursor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTransformProjection)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ShowOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_HideOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_IsOverlayVisible)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetTransformForOverlayCoordinates)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_WaitFrameSync)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_PollNextOverlayEvent)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayInputMethod)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayInputMethod)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayMouseScale)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayMouseScale)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ComputeOverlayIntersection)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_IsHoverTargetOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayIntersectionMask)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_TriggerLaserMouseHapticVibration)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayCursor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayCursorPositionOverride)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ClearOverlayCursorPositionOverride)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTexture)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ClearOverlayTexture)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayRaw)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayFromFile)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTexture)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ReleaseNativeOverlayHandle)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTextureSize)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_CreateDashboardOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_IsDashboardVisible)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_IsActiveDashboardOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetDashboardOverlaySceneProcess)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetDashboardOverlaySceneProcess)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ShowDashboard)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetPrimaryDashboardDevice)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ShowKeyboard)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ShowKeyboardForOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetKeyboardText)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_HideKeyboard)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetKeyboardTransformAbsolute)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetKeyboardPositionForOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ShowMessageOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_CloseMessageOverlay)
);
#ifndef __GNUC__
}
#endif
winIVROverlay_IVROverlay_027 *create_winIVROverlay_IVROverlay_027(void *linux_side)
{
winIVROverlay_IVROverlay_027 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_027));
TRACE("-> %p\n", r);
r->vtable = &winIVROverlay_IVROverlay_027_vtable;
r->linux_side = linux_side;
return r;
}
void destroy_winIVROverlay_IVROverlay_027(void *object)
{
TRACE("%p\n", object);
HeapFree(GetProcessHeap(), 0, object);
}
winIVROverlay_IVROverlay_027 *create_winIVROverlay_IVROverlay_027_FnTable(void *linux_side)
{
winIVROverlay_IVROverlay_027 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_027));
struct thunk *thunks = alloc_thunks(80);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 80 * sizeof(*vtable));
int i;
TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_027_FindOverlay, 2, FALSE, FALSE);
init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_027_CreateOverlay, 3, FALSE, FALSE);
init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_027_DestroyOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_027_GetOverlayKey, 4, FALSE, FALSE);
init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_027_GetOverlayName, 4, FALSE, FALSE);
init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_027_SetOverlayName, 2, FALSE, FALSE);
init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_027_GetOverlayImageData, 5, FALSE, FALSE);
init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_027_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_027_SetOverlayRenderingPid, 2, FALSE, FALSE);
init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_027_GetOverlayRenderingPid, 1, FALSE, FALSE);
init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_027_SetOverlayFlag, 3, FALSE, FALSE);
init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_027_GetOverlayFlag, 3, FALSE, FALSE);
init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_027_GetOverlayFlags, 2, FALSE, FALSE);
init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_027_SetOverlayColor, 4, TRUE, TRUE);
init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_027_GetOverlayColor, 4, FALSE, FALSE);
init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_027_SetOverlayAlpha, 2, TRUE, FALSE);
init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_027_GetOverlayAlpha, 2, FALSE, FALSE);
init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_027_SetOverlayTexelAspect, 2, TRUE, FALSE);
init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_027_GetOverlayTexelAspect, 2, FALSE, FALSE);
init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_027_SetOverlaySortOrder, 2, FALSE, FALSE);
init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_027_GetOverlaySortOrder, 2, FALSE, FALSE);
init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_027_SetOverlayWidthInMeters, 2, TRUE, FALSE);
init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_027_GetOverlayWidthInMeters, 2, FALSE, FALSE);
init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_027_SetOverlayCurvature, 2, TRUE, FALSE);
init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_027_GetOverlayCurvature, 2, FALSE, FALSE);
init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_027_SetOverlayPreCurvePitch, 2, TRUE, FALSE);
init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_027_GetOverlayPreCurvePitch, 2, FALSE, FALSE);
init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_027_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_027_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_027_SetOverlayTextureBounds, 2, FALSE, FALSE);
init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_027_GetOverlayTextureBounds, 2, FALSE, FALSE);
init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_027_GetOverlayTransformType, 2, FALSE, FALSE);
init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_027_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_027_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_027_SetOverlayTransformCursor, 2, FALSE, FALSE);
init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_027_GetOverlayTransformCursor, 2, FALSE, FALSE);
init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_027_SetOverlayTransformProjection, 5, FALSE, FALSE);
init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_027_ShowOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_027_HideOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_027_IsOverlayVisible, 1, FALSE, FALSE);
init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_027_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_027_WaitFrameSync, 1, FALSE, FALSE);
init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_027_PollNextOverlayEvent, 3, FALSE, FALSE);
init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_027_GetOverlayInputMethod, 2, FALSE, FALSE);
init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_027_SetOverlayInputMethod, 2, FALSE, FALSE);
init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_027_GetOverlayMouseScale, 2, FALSE, FALSE);
init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_027_SetOverlayMouseScale, 2, FALSE, FALSE);
init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_027_ComputeOverlayIntersection, 3, FALSE, FALSE);
init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_027_IsHoverTargetOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_027_SetOverlayIntersectionMask, 4, FALSE, FALSE);
init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_027_TriggerLaserMouseHapticVibration, 4, TRUE, TRUE);
init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_027_SetOverlayCursor, 2, FALSE, FALSE);
init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_027_SetOverlayCursorPositionOverride, 2, FALSE, FALSE);
init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_027_ClearOverlayCursorPositionOverride, 1, FALSE, FALSE);
init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_027_SetOverlayTexture, 2, FALSE, FALSE);
init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_027_ClearOverlayTexture, 1, FALSE, FALSE);
init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_027_SetOverlayRaw, 5, FALSE, FALSE);
init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_027_SetOverlayFromFile, 2, FALSE, FALSE);
init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_027_GetOverlayTexture, 9, FALSE, FALSE);
init_thunk(&thunks[63], r, winIVROverlay_IVROverlay_027_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
init_thunk(&thunks[64], r, winIVROverlay_IVROverlay_027_GetOverlayTextureSize, 3, FALSE, FALSE);
init_thunk(&thunks[65], r, winIVROverlay_IVROverlay_027_CreateDashboardOverlay, 4, FALSE, FALSE);
init_thunk(&thunks[66], r, winIVROverlay_IVROverlay_027_IsDashboardVisible, 0, FALSE, FALSE);
init_thunk(&thunks[67], r, winIVROverlay_IVROverlay_027_IsActiveDashboardOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[68], r, winIVROverlay_IVROverlay_027_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
init_thunk(&thunks[69], r, winIVROverlay_IVROverlay_027_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
init_thunk(&thunks[70], r, winIVROverlay_IVROverlay_027_ShowDashboard, 1, FALSE, FALSE);
init_thunk(&thunks[71], r, winIVROverlay_IVROverlay_027_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
init_thunk(&thunks[72], r, winIVROverlay_IVROverlay_027_ShowKeyboard, 7, FALSE, FALSE);
init_thunk(&thunks[73], r, winIVROverlay_IVROverlay_027_ShowKeyboardForOverlay, 8, FALSE, FALSE);
init_thunk(&thunks[74], r, winIVROverlay_IVROverlay_027_GetKeyboardText, 2, FALSE, FALSE);
init_thunk(&thunks[75], r, winIVROverlay_IVROverlay_027_HideKeyboard, 0, FALSE, FALSE);
init_thunk(&thunks[76], r, winIVROverlay_IVROverlay_027_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
init_thunk(&thunks[77], r, winIVROverlay_IVROverlay_027_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
init_thunk(&thunks[78], r, winIVROverlay_IVROverlay_027_ShowMessageOverlay, 6, FALSE, FALSE);
init_thunk(&thunks[79], r, winIVROverlay_IVROverlay_027_CloseMessageOverlay, 0, FALSE, FALSE);
for (i = 0; i < 80; i++)
vtable[i] = &thunks[i];
r->linux_side = linux_side;
r->vtable = (void *)vtable;
return r;
}
void destroy_winIVROverlay_IVROverlay_027_FnTable(void *object)
{
winIVROverlay_IVROverlay_027 *win_object = object;
TRACE("%p\n", win_object);
VirtualFree(win_object->vtable[0], 0, MEM_RELEASE);
HeapFree(GetProcessHeap(), 0, win_object->vtable);
HeapFree(GetProcessHeap(), 0, win_object);
}
#include "cppIVROverlay_IVROverlay_026.h"
typedef struct __winIVROverlay_IVROverlay_026 {

8
vrclient_x64/vrclient_x64/winIVRRenderModels.c
View File

@ -26,28 +26,28 @@ typedef struct __winIVRRenderModels_IVRRenderModels_006 {
} winIVRRenderModels_IVRRenderModels_006;
DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async, 12)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, winRenderModel_t_1237 ** ppRenderModel)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, winRenderModel_t_1267 ** ppRenderModel)
{
TRACE("%p\n", _this);
return cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(_this->linux_side, pchRenderModelName, ppRenderModel);
}
DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_FreeRenderModel, 8)
void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeRenderModel(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_t_1237 * pRenderModel)
void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeRenderModel(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_t_1267 * pRenderModel)
{
TRACE("%p\n", _this);
cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(_this->linux_side, pRenderModel);
}
DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async, 12)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_1237 ** ppTexture)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_1267 ** ppTexture)
{
TRACE("%p\n", _this);
return cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(_this->linux_side, textureId, ppTexture);
}
DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_FreeTexture, 8)
void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeTexture(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_TextureMap_t_1237 * pTexture)
void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeTexture(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_TextureMap_t_1267 * pTexture)
{
TRACE("%p\n", _this);
cppIVRRenderModels_IVRRenderModels_006_FreeTexture(_this->linux_side, pTexture);

8
vrclient_x64/vrclient_x64/winIVRSystem.c
View File

@ -234,14 +234,14 @@ const char * __thiscall winIVRSystem_IVRSystem_022_GetPropErrorNameFromEnum(winI
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_022_PollNextEvent, 12)
bool __thiscall winIVRSystem_IVRSystem_022_PollNextEvent(winIVRSystem_IVRSystem_022 *_this, winVREvent_t_1237 * pEvent, uint32_t uncbVREvent)
bool __thiscall winIVRSystem_IVRSystem_022_PollNextEvent(winIVRSystem_IVRSystem_022 *_this, winVREvent_t_1267 * pEvent, uint32_t uncbVREvent)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_022_PollNextEvent(_this->linux_side, pEvent, uncbVREvent);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_022_PollNextEventWithPose, 20)
bool __thiscall winIVRSystem_IVRSystem_022_PollNextEventWithPose(winIVRSystem_IVRSystem_022 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1237 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
bool __thiscall winIVRSystem_IVRSystem_022_PollNextEventWithPose(winIVRSystem_IVRSystem_022 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1267 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_022_PollNextEventWithPose(_this->linux_side, eOrigin, pEvent, uncbVREvent, pTrackedDevicePose);
@ -263,14 +263,14 @@ HiddenAreaMesh_t *__thiscall winIVRSystem_IVRSystem_022_GetHiddenAreaMesh(winIVR
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_022_GetControllerState, 16)
bool __thiscall winIVRSystem_IVRSystem_022_GetControllerState(winIVRSystem_IVRSystem_022 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1237 * pControllerState, uint32_t unControllerStateSize)
bool __thiscall winIVRSystem_IVRSystem_022_GetControllerState(winIVRSystem_IVRSystem_022 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1267 * pControllerState, uint32_t unControllerStateSize)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_022_GetControllerState(_this->linux_side, unControllerDeviceIndex, pControllerState, unControllerStateSize);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_022_GetControllerStateWithPose, 24)
bool __thiscall winIVRSystem_IVRSystem_022_GetControllerStateWithPose(winIVRSystem_IVRSystem_022 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1237 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
bool __thiscall winIVRSystem_IVRSystem_022_GetControllerStateWithPose(winIVRSystem_IVRSystem_022 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1267 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(_this->linux_side, eOrigin, unControllerDeviceIndex, pControllerState, unControllerStateSize, pTrackedDevicePose);

6
vrclient_x64/vrclient_x64/winIVRTrackedCamera.c
View File

@ -75,7 +75,7 @@ EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_Releas
}
DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer, 32)
EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1237 * pFrameHeader, uint32_t nFrameHeaderSize)
EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1267 * pFrameHeader, uint32_t nFrameHeaderSize)
{
TRACE("%p\n", _this);
return cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(_this->linux_side, hTrackedCamera, eFrameType, pFrameBuffer, nFrameBufferSize, pFrameHeader, nFrameHeaderSize);
@ -89,14 +89,14 @@ EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVid
}
DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11, 32)
EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1237 * pFrameHeader, uint32_t nFrameHeaderSize)
EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1267 * pFrameHeader, uint32_t nFrameHeaderSize)
{
TRACE("%p\n", _this);
return cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(_this->linux_side, hTrackedCamera, eFrameType, pD3D11DeviceOrResource, ppD3D11ShaderResourceView, pFrameHeader, nFrameHeaderSize);
}
DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL, 28)
EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1237 * pFrameHeader, uint32_t nFrameHeaderSize)
EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1267 * pFrameHeader, uint32_t nFrameHeaderSize)
{
TRACE("%p\n", _this);
return cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(_this->linux_side, hTrackedCamera, eFrameType, pglTextureId, pFrameHeader, nFrameHeaderSize);

6
vrclient_x64/vrclient_x64/win_constructors.h
View File

@ -14,8 +14,8 @@ extern void *create_winIVRHeadsetView_IVRHeadsetView_001(void *);
extern void *create_winIVRHeadsetView_IVRHeadsetView_001_FnTable(void *);
extern void *create_winIVRNotifications_IVRNotifications_002(void *);
extern void *create_winIVRNotifications_IVRNotifications_002_FnTable(void *);
extern void *create_winIVROverlay_IVROverlay_026(void *);
extern void *create_winIVROverlay_IVROverlay_026_FnTable(void *);
extern void *create_winIVROverlay_IVROverlay_027(void *);
extern void *create_winIVROverlay_IVROverlay_027_FnTable(void *);
extern void *create_winIVROverlayView_IVROverlayView_003(void *);
extern void *create_winIVROverlayView_IVROverlayView_003_FnTable(void *);
extern void *create_winIVRRenderModels_IVRRenderModels_006(void *);
@ -36,6 +36,8 @@ extern void *create_winIVRIOBuffer_IVRIOBuffer_002(void *);
extern void *create_winIVRIOBuffer_IVRIOBuffer_002_FnTable(void *);
extern void *create_winIVRClientCore_IVRClientCore_003(void *);
extern void *create_winIVRClientCore_IVRClientCore_003_FnTable(void *);
extern void *create_winIVROverlay_IVROverlay_026(void *);
extern void *create_winIVROverlay_IVROverlay_026_FnTable(void *);
extern void *create_winIVROverlay_IVROverlay_025(void *);
extern void *create_winIVROverlay_IVROverlay_025_FnTable(void *);
extern void *create_winIVRCompositor_IVRCompositor_026(void *);

6
vrclient_x64/vrclient_x64/win_constructors_table.dat
View File

@ -14,8 +14,8 @@
{"FnTable:IVRHeadsetView_001", &create_winIVRHeadsetView_IVRHeadsetView_001_FnTable, &destroy_winIVRHeadsetView_IVRHeadsetView_001_FnTable},
{"IVRNotifications_002", &create_winIVRNotifications_IVRNotifications_002, &destroy_winIVRNotifications_IVRNotifications_002},
{"FnTable:IVRNotifications_002", &create_winIVRNotifications_IVRNotifications_002_FnTable, &destroy_winIVRNotifications_IVRNotifications_002_FnTable},
{"IVROverlay_026", &create_winIVROverlay_IVROverlay_026, &destroy_winIVROverlay_IVROverlay_026},
{"FnTable:IVROverlay_026", &create_winIVROverlay_IVROverlay_026_FnTable, &destroy_winIVROverlay_IVROverlay_026_FnTable},
{"IVROverlay_027", &create_winIVROverlay_IVROverlay_027, &destroy_winIVROverlay_IVROverlay_027},
{"FnTable:IVROverlay_027", &create_winIVROverlay_IVROverlay_027_FnTable, &destroy_winIVROverlay_IVROverlay_027_FnTable},
{"IVROverlayView_003", &create_winIVROverlayView_IVROverlayView_003, &destroy_winIVROverlayView_IVROverlayView_003},
{"FnTable:IVROverlayView_003", &create_winIVROverlayView_IVROverlayView_003_FnTable, &destroy_winIVROverlayView_IVROverlayView_003_FnTable},
{"IVRRenderModels_006", &create_winIVRRenderModels_IVRRenderModels_006, &destroy_winIVRRenderModels_IVRRenderModels_006},
@ -36,6 +36,8 @@
{"FnTable:IVRIOBuffer_002", &create_winIVRIOBuffer_IVRIOBuffer_002_FnTable, &destroy_winIVRIOBuffer_IVRIOBuffer_002_FnTable},
{"IVRClientCore_003", &create_winIVRClientCore_IVRClientCore_003, &destroy_winIVRClientCore_IVRClientCore_003},
{"FnTable:IVRClientCore_003", &create_winIVRClientCore_IVRClientCore_003_FnTable, &destroy_winIVRClientCore_IVRClientCore_003_FnTable},
{"IVROverlay_026", &create_winIVROverlay_IVROverlay_026, &destroy_winIVROverlay_IVROverlay_026},
{"FnTable:IVROverlay_026", &create_winIVROverlay_IVROverlay_026_FnTable, &destroy_winIVROverlay_IVROverlay_026_FnTable},
{"IVROverlay_025", &create_winIVROverlay_IVROverlay_025, &destroy_winIVROverlay_IVROverlay_025},
{"FnTable:IVROverlay_025", &create_winIVROverlay_IVROverlay_025_FnTable, &destroy_winIVROverlay_IVROverlay_025_FnTable},
{"IVRCompositor_026", &create_winIVRCompositor_IVRCompositor_026, &destroy_winIVRCompositor_IVRCompositor_026},

6
vrclient_x64/vrclient_x64/win_destructors.h
View File

@ -14,8 +14,8 @@ extern void destroy_winIVRHeadsetView_IVRHeadsetView_001(void *);
extern void destroy_winIVRHeadsetView_IVRHeadsetView_001_FnTable(void *);
extern void destroy_winIVRNotifications_IVRNotifications_002(void *);
extern void destroy_winIVRNotifications_IVRNotifications_002_FnTable(void *);
extern void destroy_winIVROverlay_IVROverlay_026(void *);
extern void destroy_winIVROverlay_IVROverlay_026_FnTable(void *);
extern void destroy_winIVROverlay_IVROverlay_027(void *);
extern void destroy_winIVROverlay_IVROverlay_027_FnTable(void *);
extern void destroy_winIVROverlayView_IVROverlayView_003(void *);
extern void destroy_winIVROverlayView_IVROverlayView_003_FnTable(void *);
extern void destroy_winIVRRenderModels_IVRRenderModels_006(void *);
@ -36,6 +36,8 @@ extern void destroy_winIVRIOBuffer_IVRIOBuffer_002(void *);
extern void destroy_winIVRIOBuffer_IVRIOBuffer_002_FnTable(void *);
extern void destroy_winIVRClientCore_IVRClientCore_003(void *);
extern void destroy_winIVRClientCore_IVRClientCore_003_FnTable(void *);
extern void destroy_winIVROverlay_IVROverlay_026(void *);
extern void destroy_winIVROverlay_IVROverlay_026_FnTable(void *);
extern void destroy_winIVROverlay_IVROverlay_025(void *);
extern void destroy_winIVROverlay_IVROverlay_025_FnTable(void *);
extern void destroy_winIVRCompositor_IVRCompositor_026(void *);