suyu/Yucom
25
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

vrclient: Support v1.23.7.

Browse source
This commit is contained in:
Paul Gofman 2023-02-23 19:49:42 -06:00 committed by Arkadiusz Hiler
parent 967b7878e5
commit 2f851ecb82
44 changed files with 9923 additions and 797 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
openvr

@ -1 +1 @@
Subproject commit 4c85abcb7f7f1f02adaf3812018c99fc593bc341
Subproject commit 08de3821dfd3aa46f778376680c68f33b9fdcb6c

4
vrclient_x64/gen_wrapper.py
View file

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

35
vrclient_x64/openvr_v1.23.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";
}

5688
vrclient_x64/openvr_v1.23.7/openvr.h Normal file
View file

File diff suppressed because it is too large Load diff

851
vrclient_x64/tests/capi_thunks_autogen.c
View file

File diff suppressed because it is too large Load diff

326
vrclient_x64/tests/capi_thunks_autogen.h
View file

@ -383,165 +383,171 @@ EVRNotificationError __thiscall IVRNotifications_002_CreateNotification(void *_t
EVRNotificationError __thiscall IVRNotifications_002_RemoveNotification(void *_this, VRNotificationId notificationId);
void test_capi_thunks_IVROverlay_025(void);
void test_capi_thunks_IVROverlay_026(void);
EVROverlayError __thiscall IVROverlay_025_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
uint32_t __thiscall IVROverlay_025_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
uint32_t __thiscall IVROverlay_026_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
uint32_t __thiscall IVROverlay_025_GetOverlayName(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_025_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
EVROverlayError __thiscall IVROverlay_026_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
EVROverlayError __thiscall IVROverlay_025_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
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_025_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
const char * __thiscall IVROverlay_026_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
EVROverlayError __thiscall IVROverlay_025_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
EVROverlayError __thiscall IVROverlay_026_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
uint32_t __thiscall IVROverlay_025_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
uint32_t __thiscall IVROverlay_026_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
EVROverlayError __thiscall IVROverlay_026_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
EVROverlayError __thiscall IVROverlay_025_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
EVROverlayError __thiscall IVROverlay_026_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
EVROverlayError __thiscall IVROverlay_025_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
EVROverlayError __thiscall IVROverlay_026_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
EVROverlayError __thiscall IVROverlay_025_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
EVROverlayError __thiscall IVROverlay_026_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
EVROverlayError __thiscall IVROverlay_025_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
EVROverlayError __thiscall IVROverlay_026_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
EVROverlayError __thiscall IVROverlay_025_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
EVROverlayError __thiscall IVROverlay_026_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
EVROverlayError __thiscall IVROverlay_025_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
EVROverlayError __thiscall IVROverlay_026_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
EVROverlayError __thiscall IVROverlay_025_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
EVROverlayError __thiscall IVROverlay_026_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
EVROverlayError __thiscall IVROverlay_025_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
EVROverlayError __thiscall IVROverlay_026_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
EVROverlayError __thiscall IVROverlay_025_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
EVROverlayError __thiscall IVROverlay_026_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
EVROverlayError __thiscall IVROverlay_025_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
EVROverlayError __thiscall IVROverlay_026_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
EVROverlayError __thiscall IVROverlay_025_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
EVROverlayError __thiscall IVROverlay_026_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
EVROverlayError __thiscall IVROverlay_025_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
EVROverlayError __thiscall IVROverlay_026_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
EVROverlayError __thiscall IVROverlay_026_SetOverlayPreCurvePitch(void *_this, VROverlayHandle_t ulOverlayHandle, float fRadians);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
EVROverlayError __thiscall IVROverlay_026_GetOverlayPreCurvePitch(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRadians);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformProjection(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_025_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_025_HideOverlay(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);
bool __thiscall IVROverlay_025_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
EVROverlayError __thiscall IVROverlay_026_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
bool __thiscall IVROverlay_025_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
bool __thiscall IVROverlay_026_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
EVROverlayError __thiscall IVROverlay_026_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
EVROverlayError __thiscall IVROverlay_025_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
EVROverlayError __thiscall IVROverlay_026_WaitFrameSync(void *_this, uint32_t nTimeoutMs);
EVROverlayError __thiscall IVROverlay_025_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
bool __thiscall IVROverlay_026_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
EVROverlayError __thiscall IVROverlay_025_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
EVROverlayError __thiscall IVROverlay_026_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
bool __thiscall IVROverlay_025_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
EVROverlayError __thiscall IVROverlay_026_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
bool __thiscall IVROverlay_025_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
EVROverlayError __thiscall IVROverlay_025_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
EVROverlayError __thiscall IVROverlay_026_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
EVROverlayError __thiscall IVROverlay_025_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
bool __thiscall IVROverlay_026_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
EVROverlayError __thiscall IVROverlay_025_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
bool __thiscall IVROverlay_026_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
EVROverlayError __thiscall IVROverlay_026_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
EVROverlayError __thiscall IVROverlay_025_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
EVROverlayError __thiscall IVROverlay_026_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
EVROverlayError __thiscall IVROverlay_025_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
EVROverlayError __thiscall IVROverlay_025_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
EVROverlayError __thiscall IVROverlay_026_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
EVROverlayError __thiscall IVROverlay_026_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
EVROverlayError __thiscall IVROverlay_025_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_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
EVROverlayError __thiscall IVROverlay_026_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
EVROverlayError __thiscall IVROverlay_026_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
EVROverlayError __thiscall IVROverlay_025_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
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);
bool __thiscall IVROverlay_025_IsDashboardVisible(void *_this);
EVROverlayError __thiscall IVROverlay_026_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
bool __thiscall IVROverlay_025_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
EVROverlayError __thiscall IVROverlay_025_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
EVROverlayError __thiscall IVROverlay_026_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
EVROverlayError __thiscall IVROverlay_025_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
bool __thiscall IVROverlay_026_IsDashboardVisible(void *_this);
void __thiscall IVROverlay_025_ShowDashboard(void *_this, const char * pchOverlayToShow);
bool __thiscall IVROverlay_026_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
TrackedDeviceIndex_t __thiscall IVROverlay_025_GetPrimaryDashboardDevice(void *_this);
EVROverlayError __thiscall IVROverlay_026_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
EVROverlayError __thiscall IVROverlay_025_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_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
EVROverlayError __thiscall IVROverlay_025_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_026_ShowDashboard(void *_this, const char * pchOverlayToShow);
uint32_t __thiscall IVROverlay_025_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
TrackedDeviceIndex_t __thiscall IVROverlay_026_GetPrimaryDashboardDevice(void *_this);
void __thiscall IVROverlay_025_HideKeyboard(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);
void __thiscall IVROverlay_025_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
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_025_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
uint32_t __thiscall IVROverlay_026_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
VRMessageOverlayResponse __thiscall IVROverlay_025_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_HideKeyboard(void *_this);
void __thiscall IVROverlay_025_CloseMessageOverlay(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_IVROverlayView_003(void);
@ -759,6 +765,166 @@ const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_thi
const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError);
void test_capi_thunks_IVROverlay_025(void);
EVROverlayError __thiscall IVROverlay_025_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
uint32_t __thiscall IVROverlay_025_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
uint32_t __thiscall IVROverlay_025_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
EVROverlayError __thiscall IVROverlay_025_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
EVROverlayError __thiscall IVROverlay_025_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
const char * __thiscall IVROverlay_025_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
EVROverlayError __thiscall IVROverlay_025_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
uint32_t __thiscall IVROverlay_025_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
EVROverlayError __thiscall IVROverlay_025_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
EVROverlayError __thiscall IVROverlay_025_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
EVROverlayError __thiscall IVROverlay_025_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
EVROverlayError __thiscall IVROverlay_025_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
EVROverlayError __thiscall IVROverlay_025_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
EVROverlayError __thiscall IVROverlay_025_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
EVROverlayError __thiscall IVROverlay_025_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
EVROverlayError __thiscall IVROverlay_025_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
EVROverlayError __thiscall IVROverlay_025_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
EVROverlayError __thiscall IVROverlay_025_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
EVROverlayError __thiscall IVROverlay_025_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
EVROverlayError __thiscall IVROverlay_025_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformProjection(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye);
EVROverlayError __thiscall IVROverlay_025_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
bool __thiscall IVROverlay_025_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
bool __thiscall IVROverlay_025_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
EVROverlayError __thiscall IVROverlay_025_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
EVROverlayError __thiscall IVROverlay_025_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
EVROverlayError __thiscall IVROverlay_025_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
EVROverlayError __thiscall IVROverlay_025_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
bool __thiscall IVROverlay_025_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
bool __thiscall IVROverlay_025_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
EVROverlayError __thiscall IVROverlay_025_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
EVROverlayError __thiscall IVROverlay_025_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
EVROverlayError __thiscall IVROverlay_025_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
EVROverlayError __thiscall IVROverlay_025_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
EVROverlayError __thiscall IVROverlay_025_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
EVROverlayError __thiscall IVROverlay_025_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
EVROverlayError __thiscall IVROverlay_025_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_025_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
EVROverlayError __thiscall IVROverlay_025_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
bool __thiscall IVROverlay_025_IsDashboardVisible(void *_this);
bool __thiscall IVROverlay_025_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
EVROverlayError __thiscall IVROverlay_025_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
void __thiscall IVROverlay_025_ShowDashboard(void *_this, const char * pchOverlayToShow);
TrackedDeviceIndex_t __thiscall IVROverlay_025_GetPrimaryDashboardDevice(void *_this);
EVROverlayError __thiscall IVROverlay_025_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_025_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_025_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
void __thiscall IVROverlay_025_HideKeyboard(void *_this);
void __thiscall IVROverlay_025_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
void __thiscall IVROverlay_025_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
VRMessageOverlayResponse __thiscall IVROverlay_025_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
void __thiscall IVROverlay_025_CloseMessageOverlay(void *_this);
void test_capi_thunks_IVRCompositor_026(void);
void __thiscall IVRCompositor_026_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);

1822
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_025();
test_capi_thunks_IVROverlay_026();
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_025();
test_capi_thunks_IVRCompositor_026();
test_capi_thunks_IVROverlay_024();
test_capi_thunks_IVRSystem_021();

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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
vr::EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
InputDigitalActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputDigitalActionData_t_1168_win_to_lin(pActionData, &lin);
struct_InputDigitalActionData_t_1237_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_1168_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputDigitalActionData_t_1237_lin_to_win(&lin, pActionData, unActionDataSize);
return _ret;
}
vr::EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
vr::EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
InputAnalogActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputAnalogActionData_t_1168_win_to_lin(pActionData, &lin);
struct_InputAnalogActionData_t_1237_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_1168_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputAnalogActionData_t_1237_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_1168 * 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_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
InputPoseActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputPoseActionData_t_1168_win_to_lin(pActionData, &lin);
struct_InputPoseActionData_t_1237_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_1168_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputPoseActionData_t_1237_lin_to_win(&lin, pActionData, unActionDataSize);
return _ret;
}
vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
InputPoseActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputPoseActionData_t_1168_win_to_lin(pActionData, &lin);
struct_InputPoseActionData_t_1237_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_1168_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputPoseActionData_t_1237_lin_to_win(&lin, pActionData, unActionDataSize);
return _ret;
}
vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1168 * pActionData, uint32_t unActionDataSize)
vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1237 * pActionData, uint32_t unActionDataSize)
{
InputSkeletalActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputSkeletalActionData_t_1168_win_to_lin(pActionData, &lin);
struct_InputSkeletalActionData_t_1237_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_1168_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputSkeletalActionData_t_1237_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_1168 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_1168 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_1168 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_1168 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_1168 *, 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_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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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_1168_win_to_lin(pvrEvent, &lin);
struct_VREvent_t_1237_win_to_lin(pvrEvent, &lin);
((IVROverlayView*)linux_side)->PostOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pvrEvent ? &lin : nullptr);
}

431
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_026.cpp Normal file
View file

@ -0,0 +1,431 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.23.7/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
}
#include "cppIVROverlay_IVROverlay_026.h"
#ifdef __cplusplus
extern "C" {
#endif
vr::EVROverlayError cppIVROverlay_IVROverlay_026_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_026_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_026_DestroyOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->DestroyOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
uint32_t cppIVROverlay_IVROverlay_026_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_026_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_026_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_026_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_026_GetOverlayErrorNameFromEnum(void *linux_side, EVROverlayError error)
{
return ((IVROverlay*)linux_side)->GetOverlayErrorNameFromEnum((vr::EVROverlayError)error);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_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_026_GetOverlayRenderingPid(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->GetOverlayRenderingPid((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_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_026_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_026_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_026_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_026_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_026_SetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fAlpha)
{
return ((IVROverlay*)linux_side)->SetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float)fAlpha);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
{
return ((IVROverlay*)linux_side)->GetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfAlpha);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
{
return ((IVROverlay*)linux_side)->SetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float)fTexelAspect);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
{
return ((IVROverlay*)linux_side)->GetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfTexelAspect);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_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_026_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_026_SetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
{
return ((IVROverlay*)linux_side)->SetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float)fWidthInMeters);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
{
return ((IVROverlay*)linux_side)->GetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfWidthInMeters);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayCurvature(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fCurvature)
{
return ((IVROverlay*)linux_side)->SetOverlayCurvature((vr::VROverlayHandle_t)ulOverlayHandle, (float)fCurvature);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayCurvature(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
{
return ((IVROverlay*)linux_side)->GetOverlayCurvature((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfCurvature);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayPreCurvePitch(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fRadians)
{
return ((IVROverlay*)linux_side)->SetOverlayPreCurvePitch((vr::VROverlayHandle_t)ulOverlayHandle, (float)fRadians);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayPreCurvePitch(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfRadians)
{
return ((IVROverlay*)linux_side)->GetOverlayPreCurvePitch((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfRadians);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_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_026_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_026_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_026_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_026_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_026_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_026_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_026_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_026_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_026_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_026_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_026_GetOverlayTransformOverlayRelative(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
{
return ((IVROverlay*)linux_side)->GetOverlayTransformOverlayRelative((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayHandle_t *)ulOverlayHandleParent, (vr::HmdMatrix34_t *)pmatParentOverlayToOverlayTransform);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayTransformOverlayRelative(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
{
return ((IVROverlay*)linux_side)->SetOverlayTransformOverlayRelative((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayHandle_t)ulOverlayHandleParent, (const vr::HmdMatrix34_t *)pmatParentOverlayToOverlayTransform);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_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_026_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_026_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_026_ShowOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->ShowOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_HideOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->HideOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
bool cppIVROverlay_IVROverlay_026_IsOverlayVisible(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->IsOverlayVisible((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_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_026_WaitFrameSync(void *linux_side, uint32_t nTimeoutMs)
{
return ((IVROverlay*)linux_side)->WaitFrameSync((uint32_t)nTimeoutMs);
}
bool cppIVROverlay_IVROverlay_026_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1237 * pEvent, uint32_t uncbVREvent)
{
VREvent_t lin;
bool _ret;
if(pEvent)
struct_VREvent_t_1237_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_1237_lin_to_win(&lin, pEvent, uncbVREvent);
return _ret;
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_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_026_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_026_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_026_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_026_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_026_IsHoverTargetOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->IsHoverTargetOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_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_026_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_026_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_026_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_026_ClearOverlayCursorPositionOverride(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->ClearOverlayCursorPositionOverride((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_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_026_ClearOverlayTexture(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->ClearOverlayTexture((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_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_026_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_026_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_026_ReleaseNativeOverlayHandle(void *linux_side, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
{
return ((IVROverlay*)linux_side)->ReleaseNativeOverlayHandle((vr::VROverlayHandle_t)ulOverlayHandle, (void *)pNativeTextureHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_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_026_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_026_IsDashboardVisible(void *linux_side)
{
return ((IVROverlay*)linux_side)->IsDashboardVisible();
}
bool cppIVROverlay_IVROverlay_026_IsActiveDashboardOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->IsActiveDashboardOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_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_026_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_026_ShowDashboard(void *linux_side, const char * pchOverlayToShow)
{
((IVROverlay*)linux_side)->ShowDashboard((const char *)pchOverlayToShow);
}
vr::TrackedDeviceIndex_t cppIVROverlay_IVROverlay_026_GetPrimaryDashboardDevice(void *linux_side)
{
return ((IVROverlay*)linux_side)->GetPrimaryDashboardDevice();
}
vr::EVROverlayError cppIVROverlay_IVROverlay_026_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_026_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_026_GetKeyboardText(void *linux_side, char * pchText, uint32_t cchText)
{
return ((IVROverlay*)linux_side)->GetKeyboardText((char *)pchText, (uint32_t)cchText);
}
void cppIVROverlay_IVROverlay_026_HideKeyboard(void *linux_side)
{
((IVROverlay*)linux_side)->HideKeyboard();
}
void cppIVROverlay_IVROverlay_026_SetKeyboardTransformAbsolute(void *linux_side, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
{
((IVROverlay*)linux_side)->SetKeyboardTransformAbsolute((vr::ETrackingUniverseOrigin)eTrackingOrigin, (const vr::HmdMatrix34_t *)pmatTrackingOriginToKeyboardTransform);
}
void cppIVROverlay_IVROverlay_026_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_026_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_026_CloseMessageOverlay(void *linux_side)
{
((IVROverlay*)linux_side)->CloseMessageOverlay();
}
#ifdef __cplusplus
}
#endif

88
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_026.h Normal file
View file

@ -0,0 +1,88 @@
#ifdef __cplusplus
extern "C" {
#endif
extern EVROverlayError cppIVROverlay_IVROverlay_026_FindOverlay(void *, const char *, VROverlayHandle_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_CreateOverlay(void *, const char *, const char *, VROverlayHandle_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_DestroyOverlay(void *, VROverlayHandle_t);
extern uint32_t cppIVROverlay_IVROverlay_026_GetOverlayKey(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
extern uint32_t cppIVROverlay_IVROverlay_026_GetOverlayName(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayName(void *, VROverlayHandle_t, const char *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayImageData(void *, VROverlayHandle_t, void *, uint32_t, uint32_t *, uint32_t *);
extern const char * cppIVROverlay_IVROverlay_026_GetOverlayErrorNameFromEnum(void *, EVROverlayError);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayRenderingPid(void *, VROverlayHandle_t, uint32_t);
extern uint32_t cppIVROverlay_IVROverlay_026_GetOverlayRenderingPid(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayFlags(void *, VROverlayHandle_t, uint32_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayColor(void *, VROverlayHandle_t, float, float, float);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayColor(void *, VROverlayHandle_t, float *, float *, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayAlpha(void *, VROverlayHandle_t, float);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayAlpha(void *, VROverlayHandle_t, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayTexelAspect(void *, VROverlayHandle_t, float);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayTexelAspect(void *, VROverlayHandle_t, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayWidthInMeters(void *, VROverlayHandle_t, float);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayWidthInMeters(void *, VROverlayHandle_t, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayCurvature(void *, VROverlayHandle_t, float);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayCurvature(void *, VROverlayHandle_t, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayPreCurvePitch(void *, VROverlayHandle_t, float);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayPreCurvePitch(void *, VROverlayHandle_t, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayTransformType(void *, VROverlayHandle_t, VROverlayTransformType *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin *, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t, const char *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, char *, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayTransformOverlayRelative(void *, VROverlayHandle_t, VROverlayHandle_t *, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayTransformOverlayRelative(void *, VROverlayHandle_t, VROverlayHandle_t, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayTransformCursor(void *, VROverlayHandle_t, HmdVector2_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayTransformCursor(void *, VROverlayHandle_t, HmdVector2_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayTransformProjection(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdMatrix34_t *, VROverlayProjection_t *, EVREye);
extern EVROverlayError cppIVROverlay_IVROverlay_026_ShowOverlay(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_HideOverlay(void *, VROverlayHandle_t);
extern bool cppIVROverlay_IVROverlay_026_IsOverlayVisible(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetTransformForOverlayCoordinates(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdVector2_t, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_WaitFrameSync(void *, uint32_t);
extern bool cppIVROverlay_IVROverlay_026_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1237 *, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
extern bool cppIVROverlay_IVROverlay_026_ComputeOverlayIntersection(void *, VROverlayHandle_t, VROverlayIntersectionParams_t *, VROverlayIntersectionResults_t *);
extern bool cppIVROverlay_IVROverlay_026_IsHoverTargetOverlay(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayIntersectionMask(void *, VROverlayHandle_t, VROverlayIntersectionMaskPrimitive_t *, uint32_t, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_TriggerLaserMouseHapticVibration(void *, VROverlayHandle_t, float, float, float);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayCursor(void *, VROverlayHandle_t, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayCursorPositionOverride(void *, VROverlayHandle_t, HmdVector2_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_ClearOverlayCursorPositionOverride(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayTexture(void *, VROverlayHandle_t, Texture_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_ClearOverlayTexture(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayRaw(void *, VROverlayHandle_t, void *, uint32_t, uint32_t, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetOverlayFromFile(void *, VROverlayHandle_t, const char *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayTexture(void *, VROverlayHandle_t, void **, void *, uint32_t *, uint32_t *, uint32_t *, ETextureType *, EColorSpace *, VRTextureBounds_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_ReleaseNativeOverlayHandle(void *, VROverlayHandle_t, void *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetOverlayTextureSize(void *, VROverlayHandle_t, uint32_t *, uint32_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_CreateDashboardOverlay(void *, const char *, const char *, VROverlayHandle_t *, VROverlayHandle_t *);
extern bool cppIVROverlay_IVROverlay_026_IsDashboardVisible(void *);
extern bool cppIVROverlay_IVROverlay_026_IsActiveDashboardOverlay(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_SetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_GetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t *);
extern void cppIVROverlay_IVROverlay_026_ShowDashboard(void *, const char *);
extern TrackedDeviceIndex_t cppIVROverlay_IVROverlay_026_GetPrimaryDashboardDevice(void *);
extern EVROverlayError cppIVROverlay_IVROverlay_026_ShowKeyboard(void *, EGamepadTextInputMode, EGamepadTextInputLineMode, uint32_t, const char *, uint32_t, const char *, uint64_t);
extern EVROverlayError cppIVROverlay_IVROverlay_026_ShowKeyboardForOverlay(void *, VROverlayHandle_t, EGamepadTextInputMode, EGamepadTextInputLineMode, uint32_t, const char *, uint32_t, const char *, uint64_t);
extern uint32_t cppIVROverlay_IVROverlay_026_GetKeyboardText(void *, char *, uint32_t);
extern void cppIVROverlay_IVROverlay_026_HideKeyboard(void *);
extern void cppIVROverlay_IVROverlay_026_SetKeyboardTransformAbsolute(void *, ETrackingUniverseOrigin, HmdMatrix34_t *);
extern void cppIVROverlay_IVROverlay_026_SetKeyboardPositionForOverlay(void *, VROverlayHandle_t, HmdRect2_t);
extern VRMessageOverlayResponse cppIVROverlay_IVROverlay_026_ShowMessageOverlay(void *, const char *, const char *, const char *, const char *, const char *, const char *);
extern void cppIVROverlay_IVROverlay_026_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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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_1168 ** ppRenderModel)
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1237 ** 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_1168_wrap(lin);
*ppRenderModel = struct_RenderModel_t_1237_wrap(lin);
return _ret;
}
void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1168 * pRenderModel)
void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1237 * pRenderModel)
{
((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1168_unwrap(pRenderModel));
((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1237_unwrap(pRenderModel));
}
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1168 ** ppTexture)
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1237 ** 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_1168_wrap(lin);
*ppTexture = struct_RenderModel_TextureMap_t_1237_wrap(lin);
return _ret;
}
void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1168 * pTexture)
void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1237 * pTexture)
{
((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1168_unwrap(pTexture));
((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1237_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_1168_win_to_lin(pControllerState, &lin);
struct_VRControllerState001_t_1237_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_1168 **);
extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_1168 *);
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1168 **);
extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_1168 *);
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_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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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_1168 * pEvent, uint32_t uncbVREvent)
bool cppIVRSystem_IVRSystem_022_PollNextEvent(void *linux_side, winVREvent_t_1237 * pEvent, uint32_t uncbVREvent)
{
VREvent_t lin;
bool _ret;
if(pEvent)
struct_VREvent_t_1168_win_to_lin(pEvent, &lin);
struct_VREvent_t_1237_win_to_lin(pEvent, &lin);
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, uncbVREvent ? sizeof(lin) : 0);
if(pEvent)
struct_VREvent_t_1168_lin_to_win(&lin, pEvent, uncbVREvent);
struct_VREvent_t_1237_lin_to_win(&lin, pEvent, uncbVREvent);
return _ret;
}
bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1168 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1237 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
{
VREvent_t lin;
bool _ret;
if(pEvent)
struct_VREvent_t_1168_win_to_lin(pEvent, &lin);
struct_VREvent_t_1237_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_1168_lin_to_win(&lin, pEvent, uncbVREvent);
struct_VREvent_t_1237_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_1168 * pControllerState, uint32_t unControllerStateSize)
bool cppIVRSystem_IVRSystem_022_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1237 * pControllerState, uint32_t unControllerStateSize)
{
VRControllerState001_t lin;
bool _ret;
if(pControllerState)
struct_VRControllerState001_t_1168_win_to_lin(pControllerState, &lin);
struct_VRControllerState001_t_1237_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_1168_lin_to_win(&lin, pControllerState, unControllerStateSize);
struct_VRControllerState001_t_1237_lin_to_win(&lin, pControllerState, unControllerStateSize);
return _ret;
}
bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1168 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1237 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
{
VRControllerState001_t lin;
bool _ret;
if(pControllerState)
struct_VRControllerState001_t_1168_win_to_lin(pControllerState, &lin);
struct_VRControllerState001_t_1237_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_1168_lin_to_win(&lin, pControllerState, unControllerStateSize);
struct_VRControllerState001_t_1237_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_1168 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1168 *, uint32_t, TrackedDevicePose_t *);
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 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_1168 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1168 *, uint32_t, TrackedDevicePose_t *);
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 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.16.8/ivrclientcore.h"
#include "openvr_v1.23.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_1168 * 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_1237 * pFrameHeader, uint32_t nFrameHeaderSize)
{
CameraVideoStreamFrameHeader_t lin;
vr::EVRTrackedCameraError _ret;
if(pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1168_win_to_lin(pFrameHeader, &lin);
struct_CameraVideoStreamFrameHeader_t_1237_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_1168_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1237_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_1168 * pFrameHeader, uint32_t nFrameHeaderSize)
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)
{
CameraVideoStreamFrameHeader_t lin;
vr::EVRTrackedCameraError _ret;
if(pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1168_win_to_lin(pFrameHeader, &lin);
struct_CameraVideoStreamFrameHeader_t_1237_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_1168_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1237_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_1168 * pFrameHeader, uint32_t nFrameHeaderSize)
vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1237 * pFrameHeader, uint32_t nFrameHeaderSize)
{
CameraVideoStreamFrameHeader_t lin;
vr::EVRTrackedCameraError _ret;
if(pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_1168_win_to_lin(pFrameHeader, &lin);
struct_CameraVideoStreamFrameHeader_t_1237_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_1168_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1237_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_1168 *, uint32_t);
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, uint32_t, winCameraVideoStreamFrameHeader_t_1237 *, 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_1168 *, uint32_t);
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, winCameraVideoStreamFrameHeader_t_1168 *, 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_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_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);
typedef struct winVREvent_t_1237 winVREvent_t_1237;
extern void struct_VREvent_t_1237_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_VREvent_t_1237_win_to_lin(void *w, void *l);
typedef struct winVRControllerState001_t_1237 winVRControllerState001_t_1237;
extern void struct_VRControllerState001_t_1237_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_VRControllerState001_t_1237_win_to_lin(void *w, void *l);
typedef struct winCameraVideoStreamFrameHeader_t_1237 winCameraVideoStreamFrameHeader_t_1237;
extern void struct_CameraVideoStreamFrameHeader_t_1237_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_CameraVideoStreamFrameHeader_t_1237_win_to_lin(void *w, void *l);
typedef struct winRenderModel_TextureMap_t_1237 winRenderModel_TextureMap_t_1237;
extern void struct_RenderModel_TextureMap_t_1237_lin_to_win(void *l, void *w);
extern void struct_RenderModel_TextureMap_t_1237_win_to_lin(void *w, void *l);
extern struct winRenderModel_TextureMap_t_1237 *struct_RenderModel_TextureMap_t_1237_wrap(void *l);
extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1237_unwrap(winRenderModel_TextureMap_t_1237 *w);
typedef struct winRenderModel_t_1237 winRenderModel_t_1237;
extern void struct_RenderModel_t_1237_lin_to_win(void *l, void *w);
extern void struct_RenderModel_t_1237_win_to_lin(void *w, void *l);
extern struct winRenderModel_t_1237 *struct_RenderModel_t_1237_wrap(void *l);
extern RenderModel_t *struct_RenderModel_t_1237_unwrap(winRenderModel_t_1237 *w);
typedef struct winInputAnalogActionData_t_1237 winInputAnalogActionData_t_1237;
extern void struct_InputAnalogActionData_t_1237_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_InputAnalogActionData_t_1237_win_to_lin(void *w, void *l);
typedef struct winInputDigitalActionData_t_1237 winInputDigitalActionData_t_1237;
extern void struct_InputDigitalActionData_t_1237_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_InputDigitalActionData_t_1237_win_to_lin(void *w, void *l);
typedef struct winInputPoseActionData_t_1237 winInputPoseActionData_t_1237;
extern void struct_InputPoseActionData_t_1237_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_InputPoseActionData_t_1237_win_to_lin(void *w, void *l);
typedef struct winInputSkeletalActionData_t_1237 winInputSkeletalActionData_t_1237;
extern void struct_InputSkeletalActionData_t_1237_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_InputSkeletalActionData_t_1237_win_to_lin(void *w, void *l);
typedef struct winVRVulkanTextureArrayData_t_1168 winVRVulkanTextureArrayData_t_1168;
extern void struct_VRVulkanTextureArrayData_t_1168_lin_to_win(void *l, void *w);
extern void struct_VRVulkanTextureArrayData_t_1168_win_to_lin(void *w, void *l);

362
vrclient_x64/vrclient_x64/struct_converters_1237.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.23.7/openvr.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
#pragma pack(push, 8)
struct winVRVulkanTextureArrayData_t_1237 {
uint32_t m_unArrayIndex;
uint32_t m_unArraySize;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_VRVulkanTextureArrayData_t_1237_lin_to_win(void *l, void *w)
{
struct winVRVulkanTextureArrayData_t_1237 *win = (struct winVRVulkanTextureArrayData_t_1237 *)w;
VRVulkanTextureArrayData_t *lin = (VRVulkanTextureArrayData_t *)l;
win->m_unArrayIndex = lin->m_unArrayIndex;
win->m_unArraySize = lin->m_unArraySize;
}
void struct_VRVulkanTextureArrayData_t_1237_win_to_lin(void *w, void *l)
{
struct winVRVulkanTextureArrayData_t_1237 *win = (struct winVRVulkanTextureArrayData_t_1237 *)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_1237 {
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_1237_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winVREvent_t_1237 *win = (struct winVREvent_t_1237 *)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_1237_win_to_lin(void *w, void *l)
{
struct winVREvent_t_1237 *win = (struct winVREvent_t_1237 *)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_1237 {
uint32_t unPacketNum;
uint64_t ulButtonPressed;
uint64_t ulButtonTouched;
vr::VRControllerAxis_t rAxis[5];
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_VRControllerState001_t_1237_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winVRControllerState001_t_1237 *win = (struct winVRControllerState001_t_1237 *)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_1237_win_to_lin(void *w, void *l)
{
struct winVRControllerState001_t_1237 *win = (struct winVRControllerState001_t_1237 *)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_1237 {
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_1237_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winCameraVideoStreamFrameHeader_t_1237 *win = (struct winCameraVideoStreamFrameHeader_t_1237 *)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_1237_win_to_lin(void *w, void *l)
{
struct winCameraVideoStreamFrameHeader_t_1237 *win = (struct winCameraVideoStreamFrameHeader_t_1237 *)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_1237 {
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_1237_lin_to_win(void *l, void *w)
{
struct winRenderModel_TextureMap_t_1237 *win = (struct winRenderModel_TextureMap_t_1237 *)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_1237_win_to_lin(void *w, void *l)
{
struct winRenderModel_TextureMap_t_1237 *win = (struct winRenderModel_TextureMap_t_1237 *)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_1237 *struct_RenderModel_TextureMap_t_1237_wrap(void *l)
{
struct winRenderModel_TextureMap_t_1237 *win = (struct winRenderModel_TextureMap_t_1237 *)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_1237_unwrap(winRenderModel_TextureMap_t_1237 *w)
{
RenderModel_TextureMap_t *ret = w->linux_side;
free(w);
return ret;
}
#pragma pack(push, 8)
struct winRenderModel_t_1237 {
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_1237_lin_to_win(void *l, void *w)
{
struct winRenderModel_t_1237 *win = (struct winRenderModel_t_1237 *)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_1237_win_to_lin(void *w, void *l)
{
struct winRenderModel_t_1237 *win = (struct winRenderModel_t_1237 *)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_1237 *struct_RenderModel_t_1237_wrap(void *l)
{
struct winRenderModel_t_1237 *win = (struct winRenderModel_t_1237 *)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_1237_unwrap(winRenderModel_t_1237 *w)
{
RenderModel_t *ret = w->linux_side;
free(w);
return ret;
}
#pragma pack(push, 8)
struct winInputAnalogActionData_t_1237 {
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_1237_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winInputAnalogActionData_t_1237 *win = (struct winInputAnalogActionData_t_1237 *)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_1237_win_to_lin(void *w, void *l)
{
struct winInputAnalogActionData_t_1237 *win = (struct winInputAnalogActionData_t_1237 *)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_1237 {
bool bActive;
vr::VRInputValueHandle_t activeOrigin;
bool bState;
bool bChanged;
float fUpdateTime;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_InputDigitalActionData_t_1237_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winInputDigitalActionData_t_1237 *win = (struct winInputDigitalActionData_t_1237 *)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_1237_win_to_lin(void *w, void *l)
{
struct winInputDigitalActionData_t_1237 *win = (struct winInputDigitalActionData_t_1237 *)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_1237 {
bool bActive;
vr::VRInputValueHandle_t activeOrigin;
vr::TrackedDevicePose_t pose __attribute__((aligned(4)));
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_InputPoseActionData_t_1237_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winInputPoseActionData_t_1237 *win = (struct winInputPoseActionData_t_1237 *)w;
InputPoseActionData_t *lin = (InputPoseActionData_t *)l;
win->bActive = lin->bActive;
win->activeOrigin = lin->activeOrigin;
win->pose = lin->pose;
}
void struct_InputPoseActionData_t_1237_win_to_lin(void *w, void *l)
{
struct winInputPoseActionData_t_1237 *win = (struct winInputPoseActionData_t_1237 *)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_1237 {
bool bActive;
vr::VRInputValueHandle_t activeOrigin;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_InputSkeletalActionData_t_1237_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winInputSkeletalActionData_t_1237 *win = (struct winInputSkeletalActionData_t_1237 *)w;
InputSkeletalActionData_t *lin = (InputSkeletalActionData_t *)l;
win->bActive = lin->bActive;
win->activeOrigin = lin->activeOrigin;
}
void struct_InputSkeletalActionData_t_1237_win_to_lin(void *w, void *l)
{
struct winInputSkeletalActionData_t_1237 *win = (struct winInputSkeletalActionData_t_1237 *)w;
InputSkeletalActionData_t *lin = (InputSkeletalActionData_t *)l;
lin->bActive = win->bActive;
lin->activeOrigin = win->activeOrigin;
}
}

1
vrclient_x64/vrclient_x64/vrclient_defs.h
View file

@ -70,6 +70,7 @@ typedef int
EVRSceneApplicationState,
HeadsetViewMode_t,
EVRState,
EVRRenderModelTextureFormat,
vrmb_typeb;
typedef uint32_t DriverId_t;

66
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 cast to 1015 during load_linux_texture_map, so ensure they're
* binary compatible before updating this number */
typedef struct winRenderModel_t_1168 winRenderModel_t_1168;
typedef struct winRenderModel_TextureMap_t_1168 winRenderModel_TextureMap_t_1168;
/* this is converted to 1237 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;
#include "cppIVRRenderModels_IVRRenderModels_006.h"
#include "wine/unixlib.h"
@ -1373,15 +1373,29 @@ uint32_t ivrcompositor_get_vulkan_device_extensions_required(
}
#pragma pack( push, 8 )
struct winRenderModel_TextureMap_t_0918 {
uint16_t unWidth;
uint16_t unHeight;
const uint8_t * rubTextureMapData;
} __attribute__ ((ms_struct));;
struct winRenderModel_TextureMap_t_1015 {
uint16_t unWidth;
uint16_t unHeight;
const uint8_t * rubTextureMapData;
} __attribute__ ((ms_struct));
struct winRenderModel_TextureMap_t_1237 {
uint16_t unWidth;
uint16_t unHeight;
const uint8_t *rubTextureMapData;
EVRRenderModelTextureFormat format;
uint16_t unMipLevels;
} __attribute__ ((ms_struct));
#pragma pack( pop )
static EVRRenderModelError load_into_texture_d3d11(ID3D11Texture2D *texture,
const struct winRenderModel_TextureMap_t_1015 *data)
const struct winRenderModel_TextureMap_t_1237 *data)
{
D3D11_TEXTURE2D_DESC texture_desc;
ID3D11DeviceContext *context;
@ -1409,6 +1423,10 @@ static EVRRenderModelError load_into_texture_d3d11(ID3D11Texture2D *texture,
FIXME("Unexpected height %u.\n", texture_desc.Height);
return VRRenderModelError_NotSupported;
}
if (data->format)
FIXME("Unsupported texture map format %d.\n", data->format);
if (data->unMipLevels)
FIXME("Unsupported unMipLevels %u.\n", data->unMipLevels);
texture->lpVtbl->GetDevice(texture, &device);
device->lpVtbl->GetImmediateContext(device, &context);
@ -1422,32 +1440,50 @@ static EVRRenderModelError load_into_texture_d3d11(ID3D11Texture2D *texture,
}
static EVRRenderModelError load_linux_texture_map(void *linux_side, TextureID_t texture_id,
struct winRenderModel_TextureMap_t_1015 **texture_map, unsigned int version)
struct winRenderModel_TextureMap_t_1237 **texture_map, unsigned int version)
{
EVRRenderModelError ret;
switch(version){
case 4:
return cppIVRRenderModels_IVRRenderModels_004_LoadTexture_Async(linux_side, texture_id, (struct winRenderModel_TextureMap_t_0918 **)texture_map);
{
struct winRenderModel_TextureMap_t_0918 *orig_map;
if ((ret = cppIVRRenderModels_IVRRenderModels_004_LoadTexture_Async(linux_side, texture_id, &orig_map)))
return ret;
*texture_map = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**texture_map));
memcpy(*texture_map, orig_map, sizeof(*orig_map));
cppIVRRenderModels_IVRRenderModels_004_FreeTexture(linux_side, orig_map);
return 0;
}
case 5:
return cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(linux_side, texture_id, texture_map);
{
struct winRenderModel_TextureMap_t_1015 *orig_map;
if ((ret = cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(linux_side, texture_id, &orig_map)))
return ret;
*texture_map = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**texture_map));
memcpy(*texture_map, orig_map, sizeof(*orig_map));
cppIVRRenderModels_IVRRenderModels_005_FreeTexture(linux_side, orig_map);
return 0;
}
case 6:
return cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(linux_side, texture_id, (struct winRenderModel_TextureMap_t_1168 **)texture_map);
return cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(linux_side, texture_id, texture_map);
}
FIXME("Unsupported IVRRenderModels version! %u\n", version);
return VRRenderModelError_NotSupported;
}
static void free_linux_texture_map(void *linux_side,
struct winRenderModel_TextureMap_t_1015 *texture_map, unsigned int version)
struct winRenderModel_TextureMap_t_1237 *texture_map, unsigned int version)
{
switch(version){
case 4:
cppIVRRenderModels_IVRRenderModels_004_FreeTexture(linux_side, (struct winRenderModel_TextureMap_t_0918 *)texture_map);
HeapFree(GetProcessHeap(), 0, texture_map);
break;
case 5:
cppIVRRenderModels_IVRRenderModels_005_FreeTexture(linux_side, texture_map);
HeapFree(GetProcessHeap(), 0, texture_map);
break;
case 6:
cppIVRRenderModels_IVRRenderModels_006_FreeTexture(linux_side, (struct winRenderModel_TextureMap_t_1168 *)texture_map);
cppIVRRenderModels_IVRRenderModels_006_FreeTexture(linux_side, texture_map);
break;
default:
FIXME("Unsupported IVRRenderModels version! %u\n", version);
@ -1460,7 +1496,7 @@ EVRRenderModelError ivrrendermodels_load_texture_d3d11_async(
void *linux_side, TextureID_t texture_id, void *device,
void **dst_texture, unsigned int version)
{
struct winRenderModel_TextureMap_t_1015 *texture_map;
struct winRenderModel_TextureMap_t_1237 *texture_map;
EVRRenderModelError error;
D3D11_TEXTURE2D_DESC desc;
ID3D11Device *d3d11_device = device;
@ -1527,7 +1563,7 @@ EVRRenderModelError ivrrendermodels_load_into_texture_d3d11_async(
EVRRenderModelError (*cpp_func)(void *, TextureID_t, void *),
void *linux_side, TextureID_t texture_id, void *dst_texture, unsigned int version)
{
struct winRenderModel_TextureMap_t_1015 *texture_map;
struct winRenderModel_TextureMap_t_1237 *texture_map;
IUnknown *unk = dst_texture;
EVRRenderModelError error;
ID3D11Texture2D *texture;

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_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetDigitalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputDigitalActionData_t_1237 * 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_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetAnalogActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputAnalogActionData_t_1237 * 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_1168 * 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_1237 * 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_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
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)
{
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_1168 * pActionData, uint32_t unActionDataSize)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetSkeletalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputSkeletalActionData_t_1237 * pActionData, uint32_t unActionDataSize)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_010_GetSkeletalActionData(_this->linux_side, action, pActionData, unActionDataSize);

797
vrclient_x64/vrclient_x64/winIVROverlay.c
View file

@ -18,6 +18,803 @@
WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
#include "cppIVROverlay_IVROverlay_026.h"
typedef struct __winIVROverlay_IVROverlay_026 {
vtable_ptr *vtable;
void *linux_side;
} winIVROverlay_IVROverlay_026;
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_FindOverlay, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_FindOverlay(winIVROverlay_IVROverlay_026 *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_FindOverlay(_this->linux_side, pchOverlayKey, pOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_CreateOverlay, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_CreateOverlay(winIVROverlay_IVROverlay_026 *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_CreateOverlay(_this->linux_side, pchOverlayKey, pchOverlayName, pOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_DestroyOverlay, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_DestroyOverlay(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_DestroyOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayKey, 24)
uint32_t __thiscall winIVROverlay_IVROverlay_026_GetOverlayKey(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayKey(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pError);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayName, 24)
uint32_t __thiscall winIVROverlay_IVROverlay_026_GetOverlayName(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayName(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pError);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayName, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayName(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayName(_this->linux_side, ulOverlayHandle, pchName);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayImageData, 28)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayImageData(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayImageData(_this->linux_side, ulOverlayHandle, pvBuffer, unBufferSize, punWidth, punHeight);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayErrorNameFromEnum, 8)
const char * __thiscall winIVROverlay_IVROverlay_026_GetOverlayErrorNameFromEnum(winIVROverlay_IVROverlay_026 *_this, EVROverlayError error)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayErrorNameFromEnum(_this->linux_side, error);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayRenderingPid, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayRenderingPid(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayRenderingPid(_this->linux_side, ulOverlayHandle, unPID);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayRenderingPid, 12)
uint32_t __thiscall winIVROverlay_IVROverlay_026_GetOverlayRenderingPid(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayRenderingPid(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayFlag, 17)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayFlag(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayFlag(_this->linux_side, ulOverlayHandle, eOverlayFlag, bEnabled);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayFlag, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayFlag(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayFlag(_this->linux_side, ulOverlayHandle, eOverlayFlag, pbEnabled);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayFlags, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayFlags(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayFlags(_this->linux_side, ulOverlayHandle, pFlags);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayColor, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayColor(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayColor(_this->linux_side, ulOverlayHandle, fRed, fGreen, fBlue);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayColor, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayColor(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayColor(_this->linux_side, ulOverlayHandle, pfRed, pfGreen, pfBlue);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayAlpha, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayAlpha(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayAlpha(_this->linux_side, ulOverlayHandle, fAlpha);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayAlpha, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayAlpha(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayAlpha(_this->linux_side, ulOverlayHandle, pfAlpha);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayTexelAspect, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayTexelAspect(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayTexelAspect(_this->linux_side, ulOverlayHandle, fTexelAspect);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayTexelAspect, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayTexelAspect(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayTexelAspect(_this->linux_side, ulOverlayHandle, pfTexelAspect);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlaySortOrder, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlaySortOrder(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlaySortOrder(_this->linux_side, ulOverlayHandle, unSortOrder);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlaySortOrder, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlaySortOrder(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlaySortOrder(_this->linux_side, ulOverlayHandle, punSortOrder);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayWidthInMeters, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayWidthInMeters(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayWidthInMeters(_this->linux_side, ulOverlayHandle, fWidthInMeters);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayWidthInMeters, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayWidthInMeters(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayWidthInMeters(_this->linux_side, ulOverlayHandle, pfWidthInMeters);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayCurvature, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayCurvature(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayCurvature(_this->linux_side, ulOverlayHandle, fCurvature);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayCurvature, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayCurvature(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayCurvature(_this->linux_side, ulOverlayHandle, pfCurvature);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayPreCurvePitch, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayPreCurvePitch(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, float fRadians)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayPreCurvePitch(_this->linux_side, ulOverlayHandle, fRadians);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayPreCurvePitch, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayPreCurvePitch(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, float * pfRadians)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayPreCurvePitch(_this->linux_side, ulOverlayHandle, pfRadians);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayTextureColorSpace, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayTextureColorSpace(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayTextureColorSpace(_this->linux_side, ulOverlayHandle, eTextureColorSpace);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayTextureColorSpace, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayTextureColorSpace(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayTextureColorSpace(_this->linux_side, ulOverlayHandle, peTextureColorSpace);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayTextureBounds, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayTextureBounds(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayTextureBounds(_this->linux_side, ulOverlayHandle, pOverlayTextureBounds);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayTextureBounds, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayTextureBounds(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayTextureBounds(_this->linux_side, ulOverlayHandle, pOverlayTextureBounds);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayTransformType, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayTransformType(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayTransformType(_this->linux_side, ulOverlayHandle, peTransformType);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayTransformAbsolute, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayTransformAbsolute(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayTransformAbsolute(_this->linux_side, ulOverlayHandle, eTrackingOrigin, pmatTrackingOriginToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayTransformAbsolute, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayTransformAbsolute(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayTransformAbsolute(_this->linux_side, ulOverlayHandle, peTrackingOrigin, pmatTrackingOriginToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayTransformTrackedDeviceRelative, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayTransformTrackedDeviceRelative(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayTransformTrackedDeviceRelative(_this->linux_side, ulOverlayHandle, unTrackedDevice, pmatTrackedDeviceToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayTransformTrackedDeviceRelative, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayTransformTrackedDeviceRelative(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayTransformTrackedDeviceRelative(_this->linux_side, ulOverlayHandle, punTrackedDevice, pmatTrackedDeviceToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayTransformTrackedDeviceComponent, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayTransformTrackedDeviceComponent(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayTransformTrackedDeviceComponent(_this->linux_side, ulOverlayHandle, unDeviceIndex, pchComponentName);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayTransformTrackedDeviceComponent, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayTransformTrackedDeviceComponent(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayTransformTrackedDeviceComponent(_this->linux_side, ulOverlayHandle, punDeviceIndex, pchComponentName, unComponentNameSize);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayTransformOverlayRelative, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayTransformOverlayRelative(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayTransformOverlayRelative(_this->linux_side, ulOverlayHandle, ulOverlayHandleParent, pmatParentOverlayToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayTransformOverlayRelative, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayTransformOverlayRelative(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayTransformOverlayRelative(_this->linux_side, ulOverlayHandle, ulOverlayHandleParent, pmatParentOverlayToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayTransformCursor, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayTransformCursor(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayTransformCursor(_this->linux_side, ulCursorOverlayHandle, pvHotspot);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayTransformCursor, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayTransformCursor(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayTransformCursor(_this->linux_side, ulOverlayHandle, pvHotspot);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayTransformProjection, 28)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayTransformProjection(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayTransformProjection(_this->linux_side, ulOverlayHandle, eTrackingOrigin, pmatTrackingOriginToOverlayTransform, pProjection, eEye);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_ShowOverlay, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_ShowOverlay(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_ShowOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_HideOverlay, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_HideOverlay(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_HideOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_IsOverlayVisible, 12)
bool __thiscall winIVROverlay_IVROverlay_026_IsOverlayVisible(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_IsOverlayVisible(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetTransformForOverlayCoordinates, 28)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetTransformForOverlayCoordinates(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetTransformForOverlayCoordinates(_this->linux_side, ulOverlayHandle, eTrackingOrigin, coordinatesInOverlay, pmatTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_WaitFrameSync, 8)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_WaitFrameSync(winIVROverlay_IVROverlay_026 *_this, uint32_t nTimeoutMs)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_WaitFrameSync(_this->linux_side, nTimeoutMs);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_PollNextOverlayEvent, 20)
bool __thiscall winIVROverlay_IVROverlay_026_PollNextOverlayEvent(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1237 * pEvent, uint32_t uncbVREvent)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_PollNextOverlayEvent(_this->linux_side, ulOverlayHandle, pEvent, uncbVREvent);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayInputMethod, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayInputMethod(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayInputMethod(_this->linux_side, ulOverlayHandle, peInputMethod);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayInputMethod, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayInputMethod(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayInputMethod(_this->linux_side, ulOverlayHandle, eInputMethod);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayMouseScale, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayMouseScale(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayMouseScale(_this->linux_side, ulOverlayHandle, pvecMouseScale);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayMouseScale, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayMouseScale(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayMouseScale(_this->linux_side, ulOverlayHandle, pvecMouseScale);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_ComputeOverlayIntersection, 20)
bool __thiscall winIVROverlay_IVROverlay_026_ComputeOverlayIntersection(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_ComputeOverlayIntersection(_this->linux_side, ulOverlayHandle, pParams, pResults);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_IsHoverTargetOverlay, 12)
bool __thiscall winIVROverlay_IVROverlay_026_IsHoverTargetOverlay(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_IsHoverTargetOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayIntersectionMask, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayIntersectionMask(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayIntersectionMask(_this->linux_side, ulOverlayHandle, pMaskPrimitives, unNumMaskPrimitives, unPrimitiveSize);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_TriggerLaserMouseHapticVibration, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_TriggerLaserMouseHapticVibration(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_TriggerLaserMouseHapticVibration(_this->linux_side, ulOverlayHandle, fDurationSeconds, fFrequency, fAmplitude);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayCursor, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayCursor(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayCursor(_this->linux_side, ulOverlayHandle, ulCursorHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayCursorPositionOverride, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayCursorPositionOverride(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayCursorPositionOverride(_this->linux_side, ulOverlayHandle, pvCursor);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_ClearOverlayCursorPositionOverride, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_ClearOverlayCursorPositionOverride(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_ClearOverlayCursorPositionOverride(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayTexture, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayTexture(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
{
TRACE("%p\n", _this);
return ivroverlay_set_overlay_texture(cppIVROverlay_IVROverlay_026_SetOverlayTexture, _this->linux_side, ulOverlayHandle, pTexture, 26);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_ClearOverlayTexture, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_ClearOverlayTexture(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_ClearOverlayTexture(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayRaw, 28)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayRaw(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetOverlayRaw(_this->linux_side, ulOverlayHandle, pvBuffer, unWidth, unHeight, unBytesPerPixel);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetOverlayFromFile, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetOverlayFromFile(winIVROverlay_IVROverlay_026 *_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_026_SetOverlayFromFile(_this->linux_side, ulOverlayHandle, pchFilePath ? lin_pchFilePath : NULL);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayTexture, 44)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayTexture(winIVROverlay_IVROverlay_026 *_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_026_GetOverlayTexture(_this->linux_side, ulOverlayHandle, pNativeTextureHandle, pNativeTextureRef, pWidth, pHeight, pNativeFormat, pAPIType, pColorSpace, pTextureBounds);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_ReleaseNativeOverlayHandle, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_ReleaseNativeOverlayHandle(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_ReleaseNativeOverlayHandle(_this->linux_side, ulOverlayHandle, pNativeTextureHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetOverlayTextureSize, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetOverlayTextureSize(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetOverlayTextureSize(_this->linux_side, ulOverlayHandle, pWidth, pHeight);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_CreateDashboardOverlay, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_CreateDashboardOverlay(winIVROverlay_IVROverlay_026 *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_CreateDashboardOverlay(_this->linux_side, pchOverlayKey, pchOverlayFriendlyName, pMainHandle, pThumbnailHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_IsDashboardVisible, 4)
bool __thiscall winIVROverlay_IVROverlay_026_IsDashboardVisible(winIVROverlay_IVROverlay_026 *_this)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_IsDashboardVisible(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_IsActiveDashboardOverlay, 12)
bool __thiscall winIVROverlay_IVROverlay_026_IsActiveDashboardOverlay(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_IsActiveDashboardOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetDashboardOverlaySceneProcess, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_SetDashboardOverlaySceneProcess(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_SetDashboardOverlaySceneProcess(_this->linux_side, ulOverlayHandle, unProcessId);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetDashboardOverlaySceneProcess, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_GetDashboardOverlaySceneProcess(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetDashboardOverlaySceneProcess(_this->linux_side, ulOverlayHandle, punProcessId);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_ShowDashboard, 8)
void __thiscall winIVROverlay_IVROverlay_026_ShowDashboard(winIVROverlay_IVROverlay_026 *_this, const char * pchOverlayToShow)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_026_ShowDashboard(_this->linux_side, pchOverlayToShow);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetPrimaryDashboardDevice, 4)
TrackedDeviceIndex_t __thiscall winIVROverlay_IVROverlay_026_GetPrimaryDashboardDevice(winIVROverlay_IVROverlay_026 *_this)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetPrimaryDashboardDevice(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_ShowKeyboard, 36)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_ShowKeyboard(winIVROverlay_IVROverlay_026 *_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_026_ShowKeyboard(_this->linux_side, eInputMode, eLineInputMode, unFlags, pchDescription, unCharMax, pchExistingText, uUserValue);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_ShowKeyboardForOverlay, 44)
EVROverlayError __thiscall winIVROverlay_IVROverlay_026_ShowKeyboardForOverlay(winIVROverlay_IVROverlay_026 *_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_026_ShowKeyboardForOverlay(_this->linux_side, ulOverlayHandle, eInputMode, eLineInputMode, unFlags, pchDescription, unCharMax, pchExistingText, uUserValue);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_GetKeyboardText, 12)
uint32_t __thiscall winIVROverlay_IVROverlay_026_GetKeyboardText(winIVROverlay_IVROverlay_026 *_this, char * pchText, uint32_t cchText)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_026_GetKeyboardText(_this->linux_side, pchText, cchText);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_HideKeyboard, 4)
void __thiscall winIVROverlay_IVROverlay_026_HideKeyboard(winIVROverlay_IVROverlay_026 *_this)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_026_HideKeyboard(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetKeyboardTransformAbsolute, 12)
void __thiscall winIVROverlay_IVROverlay_026_SetKeyboardTransformAbsolute(winIVROverlay_IVROverlay_026 *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_026_SetKeyboardTransformAbsolute(_this->linux_side, eTrackingOrigin, pmatTrackingOriginToKeyboardTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_SetKeyboardPositionForOverlay, 28)
void __thiscall winIVROverlay_IVROverlay_026_SetKeyboardPositionForOverlay(winIVROverlay_IVROverlay_026 *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_026_SetKeyboardPositionForOverlay(_this->linux_side, ulOverlayHandle, avoidRect);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_ShowMessageOverlay, 28)
VRMessageOverlayResponse __thiscall winIVROverlay_IVROverlay_026_ShowMessageOverlay(winIVROverlay_IVROverlay_026 *_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_026_ShowMessageOverlay(_this->linux_side, pchText, pchCaption, pchButton0Text, pchButton1Text, pchButton2Text, pchButton3Text);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_026_CloseMessageOverlay, 4)
void __thiscall winIVROverlay_IVROverlay_026_CloseMessageOverlay(winIVROverlay_IVROverlay_026 *_this)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_026_CloseMessageOverlay(_this->linux_side);
}
extern vtable_ptr winIVROverlay_IVROverlay_026_vtable;
#ifndef __GNUC__
void __asm_dummy_vtables(void) {
#endif
__ASM_VTABLE(winIVROverlay_IVROverlay_026,
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_FindOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_CreateOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_DestroyOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayKey)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayName)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayName)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayImageData)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayErrorNameFromEnum)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayRenderingPid)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayRenderingPid)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayFlag)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayFlag)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayFlags)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayColor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayColor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayAlpha)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayAlpha)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayTexelAspect)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayTexelAspect)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlaySortOrder)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlaySortOrder)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayWidthInMeters)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayWidthInMeters)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayCurvature)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayCurvature)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayPreCurvePitch)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayPreCurvePitch)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayTextureColorSpace)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayTextureColorSpace)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayTextureBounds)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayTextureBounds)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayTransformType)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayTransformAbsolute)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayTransformAbsolute)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayTransformTrackedDeviceRelative)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayTransformTrackedDeviceRelative)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayTransformTrackedDeviceComponent)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayTransformTrackedDeviceComponent)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayTransformOverlayRelative)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayTransformOverlayRelative)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayTransformCursor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayTransformCursor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayTransformProjection)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_ShowOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_HideOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_IsOverlayVisible)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetTransformForOverlayCoordinates)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_WaitFrameSync)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_PollNextOverlayEvent)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayInputMethod)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayInputMethod)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayMouseScale)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayMouseScale)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_ComputeOverlayIntersection)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_IsHoverTargetOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayIntersectionMask)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_TriggerLaserMouseHapticVibration)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayCursor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayCursorPositionOverride)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_ClearOverlayCursorPositionOverride)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayTexture)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_ClearOverlayTexture)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayRaw)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetOverlayFromFile)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayTexture)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_ReleaseNativeOverlayHandle)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetOverlayTextureSize)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_CreateDashboardOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_IsDashboardVisible)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_IsActiveDashboardOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetDashboardOverlaySceneProcess)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetDashboardOverlaySceneProcess)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_ShowDashboard)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetPrimaryDashboardDevice)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_ShowKeyboard)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_ShowKeyboardForOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_GetKeyboardText)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_HideKeyboard)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetKeyboardTransformAbsolute)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_SetKeyboardPositionForOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_ShowMessageOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_026_CloseMessageOverlay)
);
#ifndef __GNUC__
}
#endif
winIVROverlay_IVROverlay_026 *create_winIVROverlay_IVROverlay_026(void *linux_side)
{
winIVROverlay_IVROverlay_026 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_026));
TRACE("-> %p\n", r);
r->vtable = &winIVROverlay_IVROverlay_026_vtable;
r->linux_side = linux_side;
return r;
}
void destroy_winIVROverlay_IVROverlay_026(void *object)
{
TRACE("%p\n", object);
HeapFree(GetProcessHeap(), 0, object);
}
winIVROverlay_IVROverlay_026 *create_winIVROverlay_IVROverlay_026_FnTable(void *linux_side)
{
winIVROverlay_IVROverlay_026 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_026));
struct thunk *thunks = alloc_thunks(82);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 82 * sizeof(*vtable));
int i;
TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_026_FindOverlay, 2, FALSE, FALSE);
init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_026_CreateOverlay, 3, FALSE, FALSE);
init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_026_DestroyOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_026_GetOverlayKey, 4, FALSE, FALSE);
init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_026_GetOverlayName, 4, FALSE, FALSE);
init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_026_SetOverlayName, 2, FALSE, FALSE);
init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_026_GetOverlayImageData, 5, FALSE, FALSE);
init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_026_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_026_SetOverlayRenderingPid, 2, FALSE, FALSE);
init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_026_GetOverlayRenderingPid, 1, FALSE, FALSE);
init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_026_SetOverlayFlag, 3, FALSE, FALSE);
init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_026_GetOverlayFlag, 3, FALSE, FALSE);
init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_026_GetOverlayFlags, 2, FALSE, FALSE);
init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_026_SetOverlayColor, 4, TRUE, TRUE);
init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_026_GetOverlayColor, 4, FALSE, FALSE);
init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_026_SetOverlayAlpha, 2, TRUE, FALSE);
init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_026_GetOverlayAlpha, 2, FALSE, FALSE);
init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_026_SetOverlayTexelAspect, 2, TRUE, FALSE);
init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_026_GetOverlayTexelAspect, 2, FALSE, FALSE);
init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_026_SetOverlaySortOrder, 2, FALSE, FALSE);
init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_026_GetOverlaySortOrder, 2, FALSE, FALSE);
init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_026_SetOverlayWidthInMeters, 2, TRUE, FALSE);
init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_026_GetOverlayWidthInMeters, 2, FALSE, FALSE);
init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_026_SetOverlayCurvature, 2, TRUE, FALSE);
init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_026_GetOverlayCurvature, 2, FALSE, FALSE);
init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_026_SetOverlayPreCurvePitch, 2, TRUE, FALSE);
init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_026_GetOverlayPreCurvePitch, 2, FALSE, FALSE);
init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_026_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_026_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_026_SetOverlayTextureBounds, 2, FALSE, FALSE);
init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_026_GetOverlayTextureBounds, 2, FALSE, FALSE);
init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_026_GetOverlayTransformType, 2, FALSE, FALSE);
init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_026_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_026_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_026_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_026_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_026_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_026_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_026_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_026_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_026_SetOverlayTransformCursor, 2, FALSE, FALSE);
init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_026_GetOverlayTransformCursor, 2, FALSE, FALSE);
init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_026_SetOverlayTransformProjection, 5, FALSE, FALSE);
init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_026_ShowOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_026_HideOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_026_IsOverlayVisible, 1, FALSE, FALSE);
init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_026_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_026_WaitFrameSync, 1, FALSE, FALSE);
init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_026_PollNextOverlayEvent, 3, FALSE, FALSE);
init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_026_GetOverlayInputMethod, 2, FALSE, FALSE);
init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_026_SetOverlayInputMethod, 2, FALSE, FALSE);
init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_026_GetOverlayMouseScale, 2, FALSE, FALSE);
init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_026_SetOverlayMouseScale, 2, FALSE, FALSE);
init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_026_ComputeOverlayIntersection, 3, FALSE, FALSE);
init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_026_IsHoverTargetOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_026_SetOverlayIntersectionMask, 4, FALSE, FALSE);
init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_026_TriggerLaserMouseHapticVibration, 4, TRUE, TRUE);
init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_026_SetOverlayCursor, 2, FALSE, FALSE);
init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_026_SetOverlayCursorPositionOverride, 2, FALSE, FALSE);
init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_026_ClearOverlayCursorPositionOverride, 1, FALSE, FALSE);
init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_026_SetOverlayTexture, 2, FALSE, FALSE);
init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_026_ClearOverlayTexture, 1, FALSE, FALSE);
init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_026_SetOverlayRaw, 5, FALSE, FALSE);
init_thunk(&thunks[63], r, winIVROverlay_IVROverlay_026_SetOverlayFromFile, 2, FALSE, FALSE);
init_thunk(&thunks[64], r, winIVROverlay_IVROverlay_026_GetOverlayTexture, 9, FALSE, FALSE);
init_thunk(&thunks[65], r, winIVROverlay_IVROverlay_026_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
init_thunk(&thunks[66], r, winIVROverlay_IVROverlay_026_GetOverlayTextureSize, 3, FALSE, FALSE);
init_thunk(&thunks[67], r, winIVROverlay_IVROverlay_026_CreateDashboardOverlay, 4, FALSE, FALSE);
init_thunk(&thunks[68], r, winIVROverlay_IVROverlay_026_IsDashboardVisible, 0, FALSE, FALSE);
init_thunk(&thunks[69], r, winIVROverlay_IVROverlay_026_IsActiveDashboardOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[70], r, winIVROverlay_IVROverlay_026_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
init_thunk(&thunks[71], r, winIVROverlay_IVROverlay_026_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
init_thunk(&thunks[72], r, winIVROverlay_IVROverlay_026_ShowDashboard, 1, FALSE, FALSE);
init_thunk(&thunks[73], r, winIVROverlay_IVROverlay_026_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
init_thunk(&thunks[74], r, winIVROverlay_IVROverlay_026_ShowKeyboard, 7, FALSE, FALSE);
init_thunk(&thunks[75], r, winIVROverlay_IVROverlay_026_ShowKeyboardForOverlay, 8, FALSE, FALSE);
init_thunk(&thunks[76], r, winIVROverlay_IVROverlay_026_GetKeyboardText, 2, FALSE, FALSE);
init_thunk(&thunks[77], r, winIVROverlay_IVROverlay_026_HideKeyboard, 0, FALSE, FALSE);
init_thunk(&thunks[78], r, winIVROverlay_IVROverlay_026_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
init_thunk(&thunks[79], r, winIVROverlay_IVROverlay_026_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
init_thunk(&thunks[80], r, winIVROverlay_IVROverlay_026_ShowMessageOverlay, 6, FALSE, FALSE);
init_thunk(&thunks[81], r, winIVROverlay_IVROverlay_026_CloseMessageOverlay, 0, FALSE, FALSE);
for (i = 0; i < 82; i++)
vtable[i] = &thunks[i];
r->linux_side = linux_side;
r->vtable = (void *)vtable;
return r;
}
void destroy_winIVROverlay_IVROverlay_026_FnTable(void *object)
{
winIVROverlay_IVROverlay_026 *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_025.h"
typedef struct __winIVROverlay_IVROverlay_025 {

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_1168 ** ppRenderModel)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, winRenderModel_t_1237 ** 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_1168 * pRenderModel)
void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeRenderModel(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_t_1237 * 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_1168 ** ppTexture)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_1237 ** 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_1168 * pTexture)
void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeTexture(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_TextureMap_t_1237 * 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_1168 * pEvent, uint32_t uncbVREvent)
bool __thiscall winIVRSystem_IVRSystem_022_PollNextEvent(winIVRSystem_IVRSystem_022 *_this, winVREvent_t_1237 * 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_1168 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
bool __thiscall winIVRSystem_IVRSystem_022_PollNextEventWithPose(winIVRSystem_IVRSystem_022 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1237 * 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_1168 * pControllerState, uint32_t unControllerStateSize)
bool __thiscall winIVRSystem_IVRSystem_022_GetControllerState(winIVRSystem_IVRSystem_022 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1237 * 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_1168 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
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)
{
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_1168 * 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_1237 * 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_1168 * 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_1237 * 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_1168 * pFrameHeader, uint32_t nFrameHeaderSize)
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)
{
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_025(void *);
extern void *create_winIVROverlay_IVROverlay_025_FnTable(void *);
extern void *create_winIVROverlay_IVROverlay_026(void *);
extern void *create_winIVROverlay_IVROverlay_026_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_025(void *);
extern void *create_winIVROverlay_IVROverlay_025_FnTable(void *);
extern void *create_winIVRCompositor_IVRCompositor_026(void *);
extern void *create_winIVRCompositor_IVRCompositor_026_FnTable(void *);
extern void *create_winIVROverlay_IVROverlay_024(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_025", &create_winIVROverlay_IVROverlay_025, &destroy_winIVROverlay_IVROverlay_025},
{"FnTable:IVROverlay_025", &create_winIVROverlay_IVROverlay_025_FnTable, &destroy_winIVROverlay_IVROverlay_025_FnTable},
{"IVROverlay_026", &create_winIVROverlay_IVROverlay_026, &destroy_winIVROverlay_IVROverlay_026},
{"FnTable:IVROverlay_026", &create_winIVROverlay_IVROverlay_026_FnTable, &destroy_winIVROverlay_IVROverlay_026_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_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},
{"FnTable:IVRCompositor_026", &create_winIVRCompositor_IVRCompositor_026_FnTable, &destroy_winIVRCompositor_IVRCompositor_026_FnTable},
{"IVROverlay_024", &create_winIVROverlay_IVROverlay_024, &destroy_winIVROverlay_IVROverlay_024},

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_025(void *);
extern void destroy_winIVROverlay_IVROverlay_025_FnTable(void *);
extern void destroy_winIVROverlay_IVROverlay_026(void *);
extern void destroy_winIVROverlay_IVROverlay_026_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_025(void *);
extern void destroy_winIVROverlay_IVROverlay_025_FnTable(void *);
extern void destroy_winIVRCompositor_IVRCompositor_026(void *);
extern void destroy_winIVRCompositor_IVRCompositor_026_FnTable(void *);
extern void destroy_winIVROverlay_IVROverlay_024(void *);