gfdgd_xi
/
Proton
mirror of https://github.com/ValveSoftware/Proton.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

vrclient: Support v1.16.8. 

Signed-off-by: Paul Gofman <pgofman@codeweavers.com>
This commit is contained in:
Paul Gofman 2021-03-19 18:15:18 +03:00 committed by Andrew Eikum
parent 53f2b7aea2
commit e0f82e30cb
46 changed files with 11856 additions and 1191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
openvr

@ -1 +1 @@
Subproject commit 52065df3d6f3af96300dac98cdf7397f26abfcd7
Subproject commit 4c85abcb7f7f1f02adaf3812018c99fc593bc341

4
vrclient_x64/gen_wrapper.py
View File

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

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

5623
vrclient_x64/openvr_v1.16.8/openvr.h Normal file
View File

File diff suppressed because it is too large Load Diff

1279
vrclient_x64/tests/capi_thunks_autogen.c
View File

File diff suppressed because it is too large Load Diff

526
vrclient_x64/tests/capi_thunks_autogen.h
View File

@ -253,109 +253,109 @@ void __thiscall IVRChaperoneSetup_006_HideWorkingSetPreview(void *_this);
void __thiscall IVRChaperoneSetup_006_RoomSetupStarting(void *_this);
void test_capi_thunks_IVRCompositor_026(void);
void test_capi_thunks_IVRCompositor_027(void);
void __thiscall IVRCompositor_026_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
void __thiscall IVRCompositor_027_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
ETrackingUniverseOrigin __thiscall IVRCompositor_026_GetTrackingSpace(void *_this);
ETrackingUniverseOrigin __thiscall IVRCompositor_027_GetTrackingSpace(void *_this);
EVRCompositorError __thiscall IVRCompositor_026_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
EVRCompositorError __thiscall IVRCompositor_027_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
EVRCompositorError __thiscall IVRCompositor_026_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
EVRCompositorError __thiscall IVRCompositor_027_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
EVRCompositorError __thiscall IVRCompositor_026_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
EVRCompositorError __thiscall IVRCompositor_027_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
EVRCompositorError __thiscall IVRCompositor_026_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
EVRCompositorError __thiscall IVRCompositor_027_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
void __thiscall IVRCompositor_026_ClearLastSubmittedFrame(void *_this);
void __thiscall IVRCompositor_027_ClearLastSubmittedFrame(void *_this);
void __thiscall IVRCompositor_026_PostPresentHandoff(void *_this);
void __thiscall IVRCompositor_027_PostPresentHandoff(void *_this);
bool __thiscall IVRCompositor_026_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
bool __thiscall IVRCompositor_027_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
uint32_t __thiscall IVRCompositor_026_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames);
uint32_t __thiscall IVRCompositor_027_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames);
float __thiscall IVRCompositor_026_GetFrameTimeRemaining(void *_this);
float __thiscall IVRCompositor_027_GetFrameTimeRemaining(void *_this);
void __thiscall IVRCompositor_026_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
void __thiscall IVRCompositor_027_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
void __thiscall IVRCompositor_026_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
void __thiscall IVRCompositor_027_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
HmdColor_t *__thiscall IVRCompositor_026_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground);
HmdColor_t *__thiscall IVRCompositor_027_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground);
void __thiscall IVRCompositor_026_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
void __thiscall IVRCompositor_027_FadeGrid(void *_this, float fSeconds, bool bFadeGridIn);
float __thiscall IVRCompositor_026_GetCurrentGridAlpha(void *_this);
float __thiscall IVRCompositor_027_GetCurrentGridAlpha(void *_this);
EVRCompositorError __thiscall IVRCompositor_026_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
EVRCompositorError __thiscall IVRCompositor_027_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
void __thiscall IVRCompositor_026_ClearSkyboxOverride(void *_this);
void __thiscall IVRCompositor_027_ClearSkyboxOverride(void *_this);
void __thiscall IVRCompositor_026_CompositorBringToFront(void *_this);
void __thiscall IVRCompositor_027_CompositorBringToFront(void *_this);
void __thiscall IVRCompositor_026_CompositorGoToBack(void *_this);
void __thiscall IVRCompositor_027_CompositorGoToBack(void *_this);
void __thiscall IVRCompositor_026_CompositorQuit(void *_this);
void __thiscall IVRCompositor_027_CompositorQuit(void *_this);
bool __thiscall IVRCompositor_026_IsFullscreen(void *_this);
bool __thiscall IVRCompositor_027_IsFullscreen(void *_this);
uint32_t __thiscall IVRCompositor_026_GetCurrentSceneFocusProcess(void *_this);
uint32_t __thiscall IVRCompositor_027_GetCurrentSceneFocusProcess(void *_this);
uint32_t __thiscall IVRCompositor_026_GetLastFrameRenderer(void *_this);
uint32_t __thiscall IVRCompositor_027_GetLastFrameRenderer(void *_this);
bool __thiscall IVRCompositor_026_CanRenderScene(void *_this);
bool __thiscall IVRCompositor_027_CanRenderScene(void *_this);
void __thiscall IVRCompositor_026_ShowMirrorWindow(void *_this);
void __thiscall IVRCompositor_027_ShowMirrorWindow(void *_this);
void __thiscall IVRCompositor_026_HideMirrorWindow(void *_this);
void __thiscall IVRCompositor_027_HideMirrorWindow(void *_this);
bool __thiscall IVRCompositor_026_IsMirrorWindowVisible(void *_this);
bool __thiscall IVRCompositor_027_IsMirrorWindowVisible(void *_this);
void __thiscall IVRCompositor_026_CompositorDumpImages(void *_this);
void __thiscall IVRCompositor_027_CompositorDumpImages(void *_this);
bool __thiscall IVRCompositor_026_ShouldAppRenderWithLowResources(void *_this);
bool __thiscall IVRCompositor_027_ShouldAppRenderWithLowResources(void *_this);
void __thiscall IVRCompositor_026_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
void __thiscall IVRCompositor_027_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
void __thiscall IVRCompositor_026_ForceReconnectProcess(void *_this);
void __thiscall IVRCompositor_027_ForceReconnectProcess(void *_this);
void __thiscall IVRCompositor_026_SuspendRendering(void *_this, bool bSuspend);
void __thiscall IVRCompositor_027_SuspendRendering(void *_this, bool bSuspend);
EVRCompositorError __thiscall IVRCompositor_026_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
EVRCompositorError __thiscall IVRCompositor_027_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
void __thiscall IVRCompositor_026_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView);
void __thiscall IVRCompositor_027_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView);
EVRCompositorError __thiscall IVRCompositor_026_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
EVRCompositorError __thiscall IVRCompositor_027_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
bool __thiscall IVRCompositor_026_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
bool __thiscall IVRCompositor_027_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
void __thiscall IVRCompositor_026_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
void __thiscall IVRCompositor_027_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
void __thiscall IVRCompositor_026_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
void __thiscall IVRCompositor_027_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
uint32_t __thiscall IVRCompositor_026_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize);
uint32_t __thiscall IVRCompositor_027_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize);
uint32_t __thiscall IVRCompositor_026_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize);
uint32_t __thiscall IVRCompositor_027_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize);
void __thiscall IVRCompositor_026_SetExplicitTimingMode(void *_this, EVRCompositorTimingMode eTimingMode);
void __thiscall IVRCompositor_027_SetExplicitTimingMode(void *_this, EVRCompositorTimingMode eTimingMode);
EVRCompositorError __thiscall IVRCompositor_026_SubmitExplicitTimingData(void *_this);
EVRCompositorError __thiscall IVRCompositor_027_SubmitExplicitTimingData(void *_this);
bool __thiscall IVRCompositor_026_IsMotionSmoothingEnabled(void *_this);
bool __thiscall IVRCompositor_027_IsMotionSmoothingEnabled(void *_this);
bool __thiscall IVRCompositor_026_IsMotionSmoothingSupported(void *_this);
bool __thiscall IVRCompositor_027_IsMotionSmoothingSupported(void *_this);
bool __thiscall IVRCompositor_026_IsCurrentSceneFocusAppLoading(void *_this);
bool __thiscall IVRCompositor_027_IsCurrentSceneFocusAppLoading(void *_this);
EVRCompositorError __thiscall IVRCompositor_026_SetStageOverride_Async(void *_this, const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings);
EVRCompositorError __thiscall IVRCompositor_027_SetStageOverride_Async(void *_this, const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings);
void __thiscall IVRCompositor_026_ClearStageOverride(void *_this);
void __thiscall IVRCompositor_027_ClearStageOverride(void *_this);
bool __thiscall IVRCompositor_026_GetCompositorBenchmarkResults(void *_this, Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults);
bool __thiscall IVRCompositor_027_GetCompositorBenchmarkResults(void *_this, Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults);
EVRCompositorError __thiscall IVRCompositor_026_GetLastPosePredictionIDs(void *_this, uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID);
EVRCompositorError __thiscall IVRCompositor_027_GetLastPosePredictionIDs(void *_this, uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID);
EVRCompositorError __thiscall IVRCompositor_026_GetPosesForFrame(void *_this, uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount);
EVRCompositorError __thiscall IVRCompositor_027_GetPosesForFrame(void *_this, uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount);
void test_capi_thunks_IVRHeadsetView_001(void);
@ -383,163 +383,165 @@ EVRNotificationError __thiscall IVRNotifications_002_CreateNotification(void *_t
EVRNotificationError __thiscall IVRNotifications_002_RemoveNotification(void *_this, VRNotificationId notificationId);
void test_capi_thunks_IVROverlay_024(void);
void test_capi_thunks_IVROverlay_025(void);
EVROverlayError __thiscall IVROverlay_024_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
uint32_t __thiscall IVROverlay_024_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
uint32_t __thiscall IVROverlay_025_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
uint32_t __thiscall IVROverlay_024_GetOverlayName(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_024_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
EVROverlayError __thiscall IVROverlay_025_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
EVROverlayError __thiscall IVROverlay_024_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
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_024_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
const char * __thiscall IVROverlay_025_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
EVROverlayError __thiscall IVROverlay_024_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
EVROverlayError __thiscall IVROverlay_025_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
uint32_t __thiscall IVROverlay_024_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
uint32_t __thiscall IVROverlay_025_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
EVROverlayError __thiscall IVROverlay_025_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
EVROverlayError __thiscall IVROverlay_024_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
EVROverlayError __thiscall IVROverlay_025_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
EVROverlayError __thiscall IVROverlay_024_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
EVROverlayError __thiscall IVROverlay_025_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
EVROverlayError __thiscall IVROverlay_024_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
EVROverlayError __thiscall IVROverlay_025_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
EVROverlayError __thiscall IVROverlay_024_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
EVROverlayError __thiscall IVROverlay_025_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
EVROverlayError __thiscall IVROverlay_024_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
EVROverlayError __thiscall IVROverlay_025_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
EVROverlayError __thiscall IVROverlay_024_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
EVROverlayError __thiscall IVROverlay_025_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
EVROverlayError __thiscall IVROverlay_024_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
EVROverlayError __thiscall IVROverlay_025_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
EVROverlayError __thiscall IVROverlay_024_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
EVROverlayError __thiscall IVROverlay_025_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
EVROverlayError __thiscall IVROverlay_024_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
EVROverlayError __thiscall IVROverlay_025_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
EVROverlayError __thiscall IVROverlay_024_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
EVROverlayError __thiscall IVROverlay_025_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
EVROverlayError __thiscall IVROverlay_024_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
EVROverlayError __thiscall IVROverlay_025_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
EVROverlayError __thiscall IVROverlay_024_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
EVROverlayError __thiscall IVROverlay_025_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformOverlayRelative(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_024_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_024_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformProjection(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye);
EVROverlayError __thiscall IVROverlay_024_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
bool __thiscall IVROverlay_024_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
bool __thiscall IVROverlay_025_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
bool __thiscall IVROverlay_024_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
EVROverlayError __thiscall IVROverlay_025_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
EVROverlayError __thiscall IVROverlay_024_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
bool __thiscall IVROverlay_025_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
EVROverlayError __thiscall IVROverlay_024_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
EVROverlayError __thiscall IVROverlay_025_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
EVROverlayError __thiscall IVROverlay_024_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
EVROverlayError __thiscall IVROverlay_025_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
EVROverlayError __thiscall IVROverlay_024_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
EVROverlayError __thiscall IVROverlay_025_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
bool __thiscall IVROverlay_024_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
EVROverlayError __thiscall IVROverlay_025_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
bool __thiscall IVROverlay_024_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
bool __thiscall IVROverlay_025_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
EVROverlayError __thiscall IVROverlay_024_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
bool __thiscall IVROverlay_025_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
EVROverlayError __thiscall IVROverlay_025_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
EVROverlayError __thiscall IVROverlay_024_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
EVROverlayError __thiscall IVROverlay_025_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
EVROverlayError __thiscall IVROverlay_024_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
EVROverlayError __thiscall IVROverlay_025_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
EVROverlayError __thiscall IVROverlay_024_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
EVROverlayError __thiscall IVROverlay_025_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_025_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
EVROverlayError __thiscall IVROverlay_024_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
EVROverlayError __thiscall IVROverlay_025_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
EVROverlayError __thiscall IVROverlay_025_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
EVROverlayError __thiscall IVROverlay_024_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_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
EVROverlayError __thiscall IVROverlay_024_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
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_024_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
EVROverlayError __thiscall IVROverlay_025_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
EVROverlayError __thiscall IVROverlay_024_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
bool __thiscall IVROverlay_024_IsDashboardVisible(void *_this);
EVROverlayError __thiscall IVROverlay_025_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
bool __thiscall IVROverlay_024_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
bool __thiscall IVROverlay_025_IsDashboardVisible(void *_this);
EVROverlayError __thiscall IVROverlay_024_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
bool __thiscall IVROverlay_025_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
EVROverlayError __thiscall IVROverlay_025_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
void __thiscall IVROverlay_024_ShowDashboard(void *_this, const char * pchOverlayToShow);
EVROverlayError __thiscall IVROverlay_025_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
TrackedDeviceIndex_t __thiscall IVROverlay_024_GetPrimaryDashboardDevice(void *_this);
void __thiscall IVROverlay_025_ShowDashboard(void *_this, const char * pchOverlayToShow);
EVROverlayError __thiscall IVROverlay_024_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
TrackedDeviceIndex_t __thiscall IVROverlay_025_GetPrimaryDashboardDevice(void *_this);
EVROverlayError __thiscall IVROverlay_024_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
EVROverlayError __thiscall IVROverlay_025_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
uint32_t __thiscall IVROverlay_024_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
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_024_HideKeyboard(void *_this);
uint32_t __thiscall IVROverlay_025_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
void __thiscall IVROverlay_024_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
void __thiscall IVROverlay_025_HideKeyboard(void *_this);
void __thiscall IVROverlay_024_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
void __thiscall IVROverlay_025_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
VRMessageOverlayResponse __thiscall IVROverlay_024_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_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
void __thiscall IVROverlay_024_CloseMessageOverlay(void *_this);
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_IVROverlayView_003(void);
@ -757,6 +759,268 @@ const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_thi
const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError);
void test_capi_thunks_IVRCompositor_026(void);
void __thiscall IVRCompositor_026_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
ETrackingUniverseOrigin __thiscall IVRCompositor_026_GetTrackingSpace(void *_this);
EVRCompositorError __thiscall IVRCompositor_026_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
EVRCompositorError __thiscall IVRCompositor_026_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
EVRCompositorError __thiscall IVRCompositor_026_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
EVRCompositorError __thiscall IVRCompositor_026_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
void __thiscall IVRCompositor_026_ClearLastSubmittedFrame(void *_this);
void __thiscall IVRCompositor_026_PostPresentHandoff(void *_this);
bool __thiscall IVRCompositor_026_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
uint32_t __thiscall IVRCompositor_026_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames);
float __thiscall IVRCompositor_026_GetFrameTimeRemaining(void *_this);
void __thiscall IVRCompositor_026_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
void __thiscall IVRCompositor_026_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
HmdColor_t *__thiscall IVRCompositor_026_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground);
void __thiscall IVRCompositor_026_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
float __thiscall IVRCompositor_026_GetCurrentGridAlpha(void *_this);
EVRCompositorError __thiscall IVRCompositor_026_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
void __thiscall IVRCompositor_026_ClearSkyboxOverride(void *_this);
void __thiscall IVRCompositor_026_CompositorBringToFront(void *_this);
void __thiscall IVRCompositor_026_CompositorGoToBack(void *_this);
void __thiscall IVRCompositor_026_CompositorQuit(void *_this);
bool __thiscall IVRCompositor_026_IsFullscreen(void *_this);
uint32_t __thiscall IVRCompositor_026_GetCurrentSceneFocusProcess(void *_this);
uint32_t __thiscall IVRCompositor_026_GetLastFrameRenderer(void *_this);
bool __thiscall IVRCompositor_026_CanRenderScene(void *_this);
void __thiscall IVRCompositor_026_ShowMirrorWindow(void *_this);
void __thiscall IVRCompositor_026_HideMirrorWindow(void *_this);
bool __thiscall IVRCompositor_026_IsMirrorWindowVisible(void *_this);
void __thiscall IVRCompositor_026_CompositorDumpImages(void *_this);
bool __thiscall IVRCompositor_026_ShouldAppRenderWithLowResources(void *_this);
void __thiscall IVRCompositor_026_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
void __thiscall IVRCompositor_026_ForceReconnectProcess(void *_this);
void __thiscall IVRCompositor_026_SuspendRendering(void *_this, bool bSuspend);
EVRCompositorError __thiscall IVRCompositor_026_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
void __thiscall IVRCompositor_026_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView);
EVRCompositorError __thiscall IVRCompositor_026_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
bool __thiscall IVRCompositor_026_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
void __thiscall IVRCompositor_026_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
void __thiscall IVRCompositor_026_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
uint32_t __thiscall IVRCompositor_026_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize);
uint32_t __thiscall IVRCompositor_026_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize);
void __thiscall IVRCompositor_026_SetExplicitTimingMode(void *_this, EVRCompositorTimingMode eTimingMode);
EVRCompositorError __thiscall IVRCompositor_026_SubmitExplicitTimingData(void *_this);
bool __thiscall IVRCompositor_026_IsMotionSmoothingEnabled(void *_this);
bool __thiscall IVRCompositor_026_IsMotionSmoothingSupported(void *_this);
bool __thiscall IVRCompositor_026_IsCurrentSceneFocusAppLoading(void *_this);
EVRCompositorError __thiscall IVRCompositor_026_SetStageOverride_Async(void *_this, const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings);
void __thiscall IVRCompositor_026_ClearStageOverride(void *_this);
bool __thiscall IVRCompositor_026_GetCompositorBenchmarkResults(void *_this, Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults);
EVRCompositorError __thiscall IVRCompositor_026_GetLastPosePredictionIDs(void *_this, uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID);
EVRCompositorError __thiscall IVRCompositor_026_GetPosesForFrame(void *_this, uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount);
void test_capi_thunks_IVROverlay_024(void);
EVROverlayError __thiscall IVROverlay_024_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
uint32_t __thiscall IVROverlay_024_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
uint32_t __thiscall IVROverlay_024_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
EVROverlayError __thiscall IVROverlay_024_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
EVROverlayError __thiscall IVROverlay_024_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
const char * __thiscall IVROverlay_024_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
EVROverlayError __thiscall IVROverlay_024_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
uint32_t __thiscall IVROverlay_024_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
EVROverlayError __thiscall IVROverlay_024_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
EVROverlayError __thiscall IVROverlay_024_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
EVROverlayError __thiscall IVROverlay_024_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
EVROverlayError __thiscall IVROverlay_024_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
EVROverlayError __thiscall IVROverlay_024_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
EVROverlayError __thiscall IVROverlay_024_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
EVROverlayError __thiscall IVROverlay_024_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
EVROverlayError __thiscall IVROverlay_024_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
EVROverlayError __thiscall IVROverlay_024_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
EVROverlayError __thiscall IVROverlay_024_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
EVROverlayError __thiscall IVROverlay_024_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
EVROverlayError __thiscall IVROverlay_024_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
EVROverlayError __thiscall IVROverlay_024_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
bool __thiscall IVROverlay_024_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
bool __thiscall IVROverlay_024_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
EVROverlayError __thiscall IVROverlay_024_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
EVROverlayError __thiscall IVROverlay_024_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
EVROverlayError __thiscall IVROverlay_024_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
EVROverlayError __thiscall IVROverlay_024_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
bool __thiscall IVROverlay_024_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
bool __thiscall IVROverlay_024_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
EVROverlayError __thiscall IVROverlay_024_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
EVROverlayError __thiscall IVROverlay_024_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
EVROverlayError __thiscall IVROverlay_024_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
EVROverlayError __thiscall IVROverlay_024_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
EVROverlayError __thiscall IVROverlay_024_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
EVROverlayError __thiscall IVROverlay_024_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
EVROverlayError __thiscall IVROverlay_024_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_024_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
EVROverlayError __thiscall IVROverlay_024_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
bool __thiscall IVROverlay_024_IsDashboardVisible(void *_this);
bool __thiscall IVROverlay_024_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
EVROverlayError __thiscall IVROverlay_024_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
EVROverlayError __thiscall IVROverlay_024_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
void __thiscall IVROverlay_024_ShowDashboard(void *_this, const char * pchOverlayToShow);
TrackedDeviceIndex_t __thiscall IVROverlay_024_GetPrimaryDashboardDevice(void *_this);
EVROverlayError __thiscall IVROverlay_024_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_024_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_024_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
void __thiscall IVROverlay_024_HideKeyboard(void *_this);
void __thiscall IVROverlay_024_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
void __thiscall IVROverlay_024_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
VRMessageOverlayResponse __thiscall IVROverlay_024_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
void __thiscall IVROverlay_024_CloseMessageOverlay(void *_this);
void test_capi_thunks_IVRSystem_021(void);
void __thiscall IVRSystem_021_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);

2743
vrclient_x64/tests/capi_thunks_tests_autogen.c
View File

File diff suppressed because it is too large Load Diff

6
vrclient_x64/tests/main_autogen.c
View File

@ -10,10 +10,10 @@ int main(void)
test_capi_thunks_IVRSettings_003();
test_capi_thunks_IVRChaperone_004();
test_capi_thunks_IVRChaperoneSetup_006();
test_capi_thunks_IVRCompositor_026();
test_capi_thunks_IVRCompositor_027();
test_capi_thunks_IVRHeadsetView_001();
test_capi_thunks_IVRNotifications_002();
test_capi_thunks_IVROverlay_024();
test_capi_thunks_IVROverlay_025();
test_capi_thunks_IVROverlayView_003();
test_capi_thunks_IVRRenderModels_006();
test_capi_thunks_IVRExtendedDisplay_001();
@ -24,6 +24,8 @@ int main(void)
test_capi_thunks_IVRInput_010();
test_capi_thunks_IVRIOBuffer_002();
test_capi_thunks_IVRClientCore_003();
test_capi_thunks_IVRCompositor_026();
test_capi_thunks_IVROverlay_024();
test_capi_thunks_IVRSystem_021();
test_capi_thunks_IVRChaperone_003();
test_capi_thunks_IVRControlPanel_006();

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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

269
vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_027.cpp Normal file
View File

@ -0,0 +1,269 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.16.8/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
}
#include "cppIVRCompositor_IVRCompositor_027.h"
#ifdef __cplusplus
extern "C" {
#endif
void cppIVRCompositor_IVRCompositor_027_SetTrackingSpace(void *linux_side, ETrackingUniverseOrigin eOrigin)
{
((IVRCompositor*)linux_side)->SetTrackingSpace((vr::ETrackingUniverseOrigin)eOrigin);
}
vr::ETrackingUniverseOrigin cppIVRCompositor_IVRCompositor_027_GetTrackingSpace(void *linux_side)
{
return ((IVRCompositor*)linux_side)->GetTrackingSpace();
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_WaitGetPoses(void *linux_side, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
{
return ((IVRCompositor*)linux_side)->WaitGetPoses((vr::TrackedDevicePose_t *)pRenderPoseArray, (uint32_t)unRenderPoseArrayCount, (vr::TrackedDevicePose_t *)pGamePoseArray, (uint32_t)unGamePoseArrayCount);
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetLastPoses(void *linux_side, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
{
return ((IVRCompositor*)linux_side)->GetLastPoses((vr::TrackedDevicePose_t *)pRenderPoseArray, (uint32_t)unRenderPoseArrayCount, (vr::TrackedDevicePose_t *)pGamePoseArray, (uint32_t)unGamePoseArrayCount);
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
{
return ((IVRCompositor*)linux_side)->GetLastPoseForTrackedDeviceIndex((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::TrackedDevicePose_t *)pOutputPose, (vr::TrackedDevicePose_t *)pOutputGamePose);
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_Submit(void *linux_side, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
{
return ((IVRCompositor*)linux_side)->Submit((vr::EVREye)eEye, (const vr::Texture_t *)pTexture, (const vr::VRTextureBounds_t *)pBounds, (vr::EVRSubmitFlags)nSubmitFlags);
}
void cppIVRCompositor_IVRCompositor_027_ClearLastSubmittedFrame(void *linux_side)
{
((IVRCompositor*)linux_side)->ClearLastSubmittedFrame();
}
void cppIVRCompositor_IVRCompositor_027_PostPresentHandoff(void *linux_side)
{
((IVRCompositor*)linux_side)->PostPresentHandoff();
}
bool cppIVRCompositor_IVRCompositor_027_GetFrameTiming(void *linux_side, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
{
return ((IVRCompositor*)linux_side)->GetFrameTiming((vr::Compositor_FrameTiming *)pTiming, (uint32_t)unFramesAgo);
}
uint32_t cppIVRCompositor_IVRCompositor_027_GetFrameTimings(void *linux_side, Compositor_FrameTiming * pTiming, uint32_t nFrames)
{
return ((IVRCompositor*)linux_side)->GetFrameTimings((vr::Compositor_FrameTiming *)pTiming, (uint32_t)nFrames);
}
float cppIVRCompositor_IVRCompositor_027_GetFrameTimeRemaining(void *linux_side)
{
return ((IVRCompositor*)linux_side)->GetFrameTimeRemaining();
}
void cppIVRCompositor_IVRCompositor_027_GetCumulativeStats(void *linux_side, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
{
((IVRCompositor*)linux_side)->GetCumulativeStats((vr::Compositor_CumulativeStats *)pStats, (uint32_t)nStatsSizeInBytes);
}
void cppIVRCompositor_IVRCompositor_027_FadeToColor(void *linux_side, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
{
((IVRCompositor*)linux_side)->FadeToColor((float)fSeconds, (float)fRed, (float)fGreen, (float)fBlue, (float)fAlpha, (bool)bBackground);
}
vr::HmdColor_t cppIVRCompositor_IVRCompositor_027_GetCurrentFadeColor(void *linux_side, bool bBackground)
{
return ((IVRCompositor*)linux_side)->GetCurrentFadeColor((bool)bBackground);
}
void cppIVRCompositor_IVRCompositor_027_FadeGrid(void *linux_side, float fSeconds, bool bFadeGridIn)
{
((IVRCompositor*)linux_side)->FadeGrid((float)fSeconds, (bool)bFadeGridIn);
}
float cppIVRCompositor_IVRCompositor_027_GetCurrentGridAlpha(void *linux_side)
{
return ((IVRCompositor*)linux_side)->GetCurrentGridAlpha();
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_SetSkyboxOverride(void *linux_side, Texture_t * pTextures, uint32_t unTextureCount)
{
return ((IVRCompositor*)linux_side)->SetSkyboxOverride((const vr::Texture_t *)pTextures, (uint32_t)unTextureCount);
}
void cppIVRCompositor_IVRCompositor_027_ClearSkyboxOverride(void *linux_side)
{
((IVRCompositor*)linux_side)->ClearSkyboxOverride();
}
void cppIVRCompositor_IVRCompositor_027_CompositorBringToFront(void *linux_side)
{
((IVRCompositor*)linux_side)->CompositorBringToFront();
}
void cppIVRCompositor_IVRCompositor_027_CompositorGoToBack(void *linux_side)
{
((IVRCompositor*)linux_side)->CompositorGoToBack();
}
void cppIVRCompositor_IVRCompositor_027_CompositorQuit(void *linux_side)
{
((IVRCompositor*)linux_side)->CompositorQuit();
}
bool cppIVRCompositor_IVRCompositor_027_IsFullscreen(void *linux_side)
{
return ((IVRCompositor*)linux_side)->IsFullscreen();
}
uint32_t cppIVRCompositor_IVRCompositor_027_GetCurrentSceneFocusProcess(void *linux_side)
{
return ((IVRCompositor*)linux_side)->GetCurrentSceneFocusProcess();
}
uint32_t cppIVRCompositor_IVRCompositor_027_GetLastFrameRenderer(void *linux_side)
{
return ((IVRCompositor*)linux_side)->GetLastFrameRenderer();
}
bool cppIVRCompositor_IVRCompositor_027_CanRenderScene(void *linux_side)
{
return ((IVRCompositor*)linux_side)->CanRenderScene();
}
void cppIVRCompositor_IVRCompositor_027_ShowMirrorWindow(void *linux_side)
{
((IVRCompositor*)linux_side)->ShowMirrorWindow();
}
void cppIVRCompositor_IVRCompositor_027_HideMirrorWindow(void *linux_side)
{
((IVRCompositor*)linux_side)->HideMirrorWindow();
}
bool cppIVRCompositor_IVRCompositor_027_IsMirrorWindowVisible(void *linux_side)
{
return ((IVRCompositor*)linux_side)->IsMirrorWindowVisible();
}
void cppIVRCompositor_IVRCompositor_027_CompositorDumpImages(void *linux_side)
{
((IVRCompositor*)linux_side)->CompositorDumpImages();
}
bool cppIVRCompositor_IVRCompositor_027_ShouldAppRenderWithLowResources(void *linux_side)
{
return ((IVRCompositor*)linux_side)->ShouldAppRenderWithLowResources();
}
void cppIVRCompositor_IVRCompositor_027_ForceInterleavedReprojectionOn(void *linux_side, bool bOverride)
{
((IVRCompositor*)linux_side)->ForceInterleavedReprojectionOn((bool)bOverride);
}
void cppIVRCompositor_IVRCompositor_027_ForceReconnectProcess(void *linux_side)
{
((IVRCompositor*)linux_side)->ForceReconnectProcess();
}
void cppIVRCompositor_IVRCompositor_027_SuspendRendering(void *linux_side, bool bSuspend)
{
((IVRCompositor*)linux_side)->SuspendRendering((bool)bSuspend);
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetMirrorTextureD3D11(void *linux_side, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
{
return ((IVRCompositor*)linux_side)->GetMirrorTextureD3D11((vr::EVREye)eEye, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView);
}
void cppIVRCompositor_IVRCompositor_027_ReleaseMirrorTextureD3D11(void *linux_side, void * pD3D11ShaderResourceView)
{
((IVRCompositor*)linux_side)->ReleaseMirrorTextureD3D11((void *)pD3D11ShaderResourceView);
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetMirrorTextureGL(void *linux_side, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
{
return ((IVRCompositor*)linux_side)->GetMirrorTextureGL((vr::EVREye)eEye, (vr::glUInt_t *)pglTextureId, (vr::glSharedTextureHandle_t *)pglSharedTextureHandle);
}
bool cppIVRCompositor_IVRCompositor_027_ReleaseSharedGLTexture(void *linux_side, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
{
return ((IVRCompositor*)linux_side)->ReleaseSharedGLTexture((vr::glUInt_t)glTextureId, (vr::glSharedTextureHandle_t)glSharedTextureHandle);
}
void cppIVRCompositor_IVRCompositor_027_LockGLSharedTextureForAccess(void *linux_side, glSharedTextureHandle_t glSharedTextureHandle)
{
((IVRCompositor*)linux_side)->LockGLSharedTextureForAccess((vr::glSharedTextureHandle_t)glSharedTextureHandle);
}
void cppIVRCompositor_IVRCompositor_027_UnlockGLSharedTextureForAccess(void *linux_side, glSharedTextureHandle_t glSharedTextureHandle)
{
((IVRCompositor*)linux_side)->UnlockGLSharedTextureForAccess((vr::glSharedTextureHandle_t)glSharedTextureHandle);
}
uint32_t cppIVRCompositor_IVRCompositor_027_GetVulkanInstanceExtensionsRequired(void *linux_side, char * pchValue, uint32_t unBufferSize)
{
return ((IVRCompositor*)linux_side)->GetVulkanInstanceExtensionsRequired((char *)pchValue, (uint32_t)unBufferSize);
}
uint32_t cppIVRCompositor_IVRCompositor_027_GetVulkanDeviceExtensionsRequired(void *linux_side, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize)
{
return ((IVRCompositor*)linux_side)->GetVulkanDeviceExtensionsRequired((VkPhysicalDevice_T *)pPhysicalDevice, (char *)pchValue, (uint32_t)unBufferSize);
}
void cppIVRCompositor_IVRCompositor_027_SetExplicitTimingMode(void *linux_side, EVRCompositorTimingMode eTimingMode)
{
((IVRCompositor*)linux_side)->SetExplicitTimingMode((vr::EVRCompositorTimingMode)eTimingMode);
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_SubmitExplicitTimingData(void *linux_side)
{
return ((IVRCompositor*)linux_side)->SubmitExplicitTimingData();
}
bool cppIVRCompositor_IVRCompositor_027_IsMotionSmoothingEnabled(void *linux_side)
{
return ((IVRCompositor*)linux_side)->IsMotionSmoothingEnabled();
}
bool cppIVRCompositor_IVRCompositor_027_IsMotionSmoothingSupported(void *linux_side)
{
return ((IVRCompositor*)linux_side)->IsMotionSmoothingSupported();
}
bool cppIVRCompositor_IVRCompositor_027_IsCurrentSceneFocusAppLoading(void *linux_side)
{
return ((IVRCompositor*)linux_side)->IsCurrentSceneFocusAppLoading();
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_SetStageOverride_Async(void *linux_side, const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings)
{
return ((IVRCompositor*)linux_side)->SetStageOverride_Async((const char *)pchRenderModelPath, (const vr::HmdMatrix34_t *)pTransform, (const vr::Compositor_StageRenderSettings *)pRenderSettings, (uint32_t)nSizeOfRenderSettings);
}
void cppIVRCompositor_IVRCompositor_027_ClearStageOverride(void *linux_side)
{
((IVRCompositor*)linux_side)->ClearStageOverride();
}
bool cppIVRCompositor_IVRCompositor_027_GetCompositorBenchmarkResults(void *linux_side, Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults)
{
return ((IVRCompositor*)linux_side)->GetCompositorBenchmarkResults((vr::Compositor_BenchmarkResults *)pBenchmarkResults, (uint32_t)nSizeOfBenchmarkResults);
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetLastPosePredictionIDs(void *linux_side, uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID)
{
return ((IVRCompositor*)linux_side)->GetLastPosePredictionIDs((uint32_t *)pRenderPosePredictionID, (uint32_t *)pGamePosePredictionID);
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetPosesForFrame(void *linux_side, uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount)
{
return ((IVRCompositor*)linux_side)->GetPosesForFrame((uint32_t)unPosePredictionID, (vr::TrackedDevicePose_t *)pPoseArray, (uint32_t)unPoseArrayCount);
}
#ifdef __cplusplus
}
#endif

57
vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_027.h Normal file
View File

@ -0,0 +1,57 @@
#ifdef __cplusplus
extern "C" {
#endif
extern void cppIVRCompositor_IVRCompositor_027_SetTrackingSpace(void *, ETrackingUniverseOrigin);
extern ETrackingUniverseOrigin cppIVRCompositor_IVRCompositor_027_GetTrackingSpace(void *);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_WaitGetPoses(void *, TrackedDevicePose_t *, uint32_t, TrackedDevicePose_t *, uint32_t);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetLastPoses(void *, TrackedDevicePose_t *, uint32_t, TrackedDevicePose_t *, uint32_t);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex(void *, TrackedDeviceIndex_t, TrackedDevicePose_t *, TrackedDevicePose_t *);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_Submit(void *, EVREye, Texture_t *, VRTextureBounds_t *, EVRSubmitFlags);
extern void cppIVRCompositor_IVRCompositor_027_ClearLastSubmittedFrame(void *);
extern void cppIVRCompositor_IVRCompositor_027_PostPresentHandoff(void *);
extern bool cppIVRCompositor_IVRCompositor_027_GetFrameTiming(void *, Compositor_FrameTiming *, uint32_t);
extern uint32_t cppIVRCompositor_IVRCompositor_027_GetFrameTimings(void *, Compositor_FrameTiming *, uint32_t);
extern float cppIVRCompositor_IVRCompositor_027_GetFrameTimeRemaining(void *);
extern void cppIVRCompositor_IVRCompositor_027_GetCumulativeStats(void *, Compositor_CumulativeStats *, uint32_t);
extern void cppIVRCompositor_IVRCompositor_027_FadeToColor(void *, float, float, float, float, float, bool);
extern HmdColor_t cppIVRCompositor_IVRCompositor_027_GetCurrentFadeColor(void *, bool);
extern void cppIVRCompositor_IVRCompositor_027_FadeGrid(void *, float, bool);
extern float cppIVRCompositor_IVRCompositor_027_GetCurrentGridAlpha(void *);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_SetSkyboxOverride(void *, Texture_t *, uint32_t);
extern void cppIVRCompositor_IVRCompositor_027_ClearSkyboxOverride(void *);
extern void cppIVRCompositor_IVRCompositor_027_CompositorBringToFront(void *);
extern void cppIVRCompositor_IVRCompositor_027_CompositorGoToBack(void *);
extern void cppIVRCompositor_IVRCompositor_027_CompositorQuit(void *);
extern bool cppIVRCompositor_IVRCompositor_027_IsFullscreen(void *);
extern uint32_t cppIVRCompositor_IVRCompositor_027_GetCurrentSceneFocusProcess(void *);
extern uint32_t cppIVRCompositor_IVRCompositor_027_GetLastFrameRenderer(void *);
extern bool cppIVRCompositor_IVRCompositor_027_CanRenderScene(void *);
extern void cppIVRCompositor_IVRCompositor_027_ShowMirrorWindow(void *);
extern void cppIVRCompositor_IVRCompositor_027_HideMirrorWindow(void *);
extern bool cppIVRCompositor_IVRCompositor_027_IsMirrorWindowVisible(void *);
extern void cppIVRCompositor_IVRCompositor_027_CompositorDumpImages(void *);
extern bool cppIVRCompositor_IVRCompositor_027_ShouldAppRenderWithLowResources(void *);
extern void cppIVRCompositor_IVRCompositor_027_ForceInterleavedReprojectionOn(void *, bool);
extern void cppIVRCompositor_IVRCompositor_027_ForceReconnectProcess(void *);
extern void cppIVRCompositor_IVRCompositor_027_SuspendRendering(void *, bool);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetMirrorTextureD3D11(void *, EVREye, void *, void **);
extern void cppIVRCompositor_IVRCompositor_027_ReleaseMirrorTextureD3D11(void *, void *);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetMirrorTextureGL(void *, EVREye, glUInt_t *, glSharedTextureHandle_t *);
extern bool cppIVRCompositor_IVRCompositor_027_ReleaseSharedGLTexture(void *, glUInt_t, glSharedTextureHandle_t);
extern void cppIVRCompositor_IVRCompositor_027_LockGLSharedTextureForAccess(void *, glSharedTextureHandle_t);
extern void cppIVRCompositor_IVRCompositor_027_UnlockGLSharedTextureForAccess(void *, glSharedTextureHandle_t);
extern uint32_t cppIVRCompositor_IVRCompositor_027_GetVulkanInstanceExtensionsRequired(void *, char *, uint32_t);
extern uint32_t cppIVRCompositor_IVRCompositor_027_GetVulkanDeviceExtensionsRequired(void *, VkPhysicalDevice_T *, char *, uint32_t);
extern void cppIVRCompositor_IVRCompositor_027_SetExplicitTimingMode(void *, EVRCompositorTimingMode);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_SubmitExplicitTimingData(void *);
extern bool cppIVRCompositor_IVRCompositor_027_IsMotionSmoothingEnabled(void *);
extern bool cppIVRCompositor_IVRCompositor_027_IsMotionSmoothingSupported(void *);
extern bool cppIVRCompositor_IVRCompositor_027_IsCurrentSceneFocusAppLoading(void *);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_SetStageOverride_Async(void *, const char *, HmdMatrix34_t *, Compositor_StageRenderSettings *, uint32_t);
extern void cppIVRCompositor_IVRCompositor_027_ClearStageOverride(void *);
extern bool cppIVRCompositor_IVRCompositor_027_GetCompositorBenchmarkResults(void *, Compositor_BenchmarkResults *, uint32_t);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetLastPosePredictionIDs(void *, uint32_t *, uint32_t *);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetPosesForFrame(void *, uint32_t, TrackedDevicePose_t *, uint32_t);
#ifdef __cplusplus
}
#endif

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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
vr::EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
InputDigitalActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputDigitalActionData_t_11415_win_to_lin(pActionData, &lin);
struct_InputDigitalActionData_t_1168_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_11415_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputDigitalActionData_t_1168_lin_to_win(&lin, pActionData, unActionDataSize);
return _ret;
}
vr::EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
vr::EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
InputAnalogActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputAnalogActionData_t_11415_win_to_lin(pActionData, &lin);
struct_InputAnalogActionData_t_1168_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_11415_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputAnalogActionData_t_1168_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_11415 * 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_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
InputPoseActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputPoseActionData_t_11415_win_to_lin(pActionData, &lin);
struct_InputPoseActionData_t_1168_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_11415_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputPoseActionData_t_1168_lin_to_win(&lin, pActionData, unActionDataSize);
return _ret;
}
vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
InputPoseActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputPoseActionData_t_11415_win_to_lin(pActionData, &lin);
struct_InputPoseActionData_t_1168_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_11415_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputPoseActionData_t_1168_lin_to_win(&lin, pActionData, unActionDataSize);
return _ret;
}
vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_11415 * pActionData, uint32_t unActionDataSize)
vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1168 * pActionData, uint32_t unActionDataSize)
{
InputSkeletalActionData_t lin;
vr::EVRInputError _ret;
if(pActionData)
struct_InputSkeletalActionData_t_11415_win_to_lin(pActionData, &lin);
struct_InputSkeletalActionData_t_1168_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_11415_lin_to_win(&lin, pActionData, unActionDataSize);
struct_InputSkeletalActionData_t_1168_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_11415 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_11415 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_11415 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_11415 *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_11415 *, 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_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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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_11415_win_to_lin(pvrEvent, &lin);
struct_VREvent_t_1168_win_to_lin(pvrEvent, &lin);
((IVROverlayView*)linux_side)->PostOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pvrEvent ? &lin : nullptr);
}

416
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_025.cpp Normal file
View File

@ -0,0 +1,416 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.16.8/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
}
#include "cppIVROverlay_IVROverlay_025.h"
#ifdef __cplusplus
extern "C" {
#endif
vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_DestroyOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->DestroyOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
uint32_t cppIVROverlay_IVROverlay_025_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_025_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_025_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_025_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_025_GetOverlayErrorNameFromEnum(void *linux_side, EVROverlayError error)
{
return ((IVROverlay*)linux_side)->GetOverlayErrorNameFromEnum((vr::EVROverlayError)error);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_GetOverlayRenderingPid(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->GetOverlayRenderingPid((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_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_025_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_025_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_025_SetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fAlpha)
{
return ((IVROverlay*)linux_side)->SetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float)fAlpha);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
{
return ((IVROverlay*)linux_side)->GetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfAlpha);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
{
return ((IVROverlay*)linux_side)->SetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float)fTexelAspect);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
{
return ((IVROverlay*)linux_side)->GetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfTexelAspect);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_SetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
{
return ((IVROverlay*)linux_side)->SetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float)fWidthInMeters);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
{
return ((IVROverlay*)linux_side)->GetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfWidthInMeters);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayCurvature(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fCurvature)
{
return ((IVROverlay*)linux_side)->SetOverlayCurvature((vr::VROverlayHandle_t)ulOverlayHandle, (float)fCurvature);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayCurvature(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
{
return ((IVROverlay*)linux_side)->GetOverlayCurvature((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfCurvature);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_ShowOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->ShowOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_HideOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->HideOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
bool cppIVROverlay_IVROverlay_025_IsOverlayVisible(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->IsOverlayVisible((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_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);
}
bool cppIVROverlay_IVROverlay_025_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1168 * pEvent, uint32_t uncbVREvent)
{
VREvent_t lin;
bool _ret;
if(pEvent)
struct_VREvent_t_1168_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_1168_lin_to_win(&lin, pEvent, uncbVREvent);
return _ret;
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_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_025_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_025_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_025_IsHoverTargetOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->IsHoverTargetOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_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_025_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_025_ClearOverlayCursorPositionOverride(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->ClearOverlayCursorPositionOverride((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_ClearOverlayTexture(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->ClearOverlayTexture((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_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_025_ReleaseNativeOverlayHandle(void *linux_side, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
{
return ((IVROverlay*)linux_side)->ReleaseNativeOverlayHandle((vr::VROverlayHandle_t)ulOverlayHandle, (void *)pNativeTextureHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_IsDashboardVisible(void *linux_side)
{
return ((IVROverlay*)linux_side)->IsDashboardVisible();
}
bool cppIVROverlay_IVROverlay_025_IsActiveDashboardOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
{
return ((IVROverlay*)linux_side)->IsActiveDashboardOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_ShowDashboard(void *linux_side, const char * pchOverlayToShow)
{
((IVROverlay*)linux_side)->ShowDashboard((const char *)pchOverlayToShow);
}
vr::TrackedDeviceIndex_t cppIVROverlay_IVROverlay_025_GetPrimaryDashboardDevice(void *linux_side)
{
return ((IVROverlay*)linux_side)->GetPrimaryDashboardDevice();
}
vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_GetKeyboardText(void *linux_side, char * pchText, uint32_t cchText)
{
return ((IVROverlay*)linux_side)->GetKeyboardText((char *)pchText, (uint32_t)cchText);
}
void cppIVROverlay_IVROverlay_025_HideKeyboard(void *linux_side)
{
((IVROverlay*)linux_side)->HideKeyboard();
}
void cppIVROverlay_IVROverlay_025_SetKeyboardTransformAbsolute(void *linux_side, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
{
((IVROverlay*)linux_side)->SetKeyboardTransformAbsolute((vr::ETrackingUniverseOrigin)eTrackingOrigin, (const vr::HmdMatrix34_t *)pmatTrackingOriginToKeyboardTransform);
}
void cppIVROverlay_IVROverlay_025_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_025_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_025_CloseMessageOverlay(void *linux_side)
{
((IVROverlay*)linux_side)->CloseMessageOverlay();
}
#ifdef __cplusplus
}
#endif

85
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_025.h Normal file
View File

@ -0,0 +1,85 @@
#ifdef __cplusplus
extern "C" {
#endif
extern EVROverlayError cppIVROverlay_IVROverlay_025_FindOverlay(void *, const char *, VROverlayHandle_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_CreateOverlay(void *, const char *, const char *, VROverlayHandle_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_DestroyOverlay(void *, VROverlayHandle_t);
extern uint32_t cppIVROverlay_IVROverlay_025_GetOverlayKey(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
extern uint32_t cppIVROverlay_IVROverlay_025_GetOverlayName(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayName(void *, VROverlayHandle_t, const char *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayImageData(void *, VROverlayHandle_t, void *, uint32_t, uint32_t *, uint32_t *);
extern const char * cppIVROverlay_IVROverlay_025_GetOverlayErrorNameFromEnum(void *, EVROverlayError);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayRenderingPid(void *, VROverlayHandle_t, uint32_t);
extern uint32_t cppIVROverlay_IVROverlay_025_GetOverlayRenderingPid(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayFlags(void *, VROverlayHandle_t, uint32_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayColor(void *, VROverlayHandle_t, float, float, float);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayColor(void *, VROverlayHandle_t, float *, float *, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayAlpha(void *, VROverlayHandle_t, float);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayAlpha(void *, VROverlayHandle_t, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTexelAspect(void *, VROverlayHandle_t, float);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTexelAspect(void *, VROverlayHandle_t, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayWidthInMeters(void *, VROverlayHandle_t, float);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayWidthInMeters(void *, VROverlayHandle_t, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayCurvature(void *, VROverlayHandle_t, float);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayCurvature(void *, VROverlayHandle_t, float *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTransformType(void *, VROverlayHandle_t, VROverlayTransformType *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin *, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t, const char *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, char *, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTransformOverlayRelative(void *, VROverlayHandle_t, VROverlayHandle_t *, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTransformOverlayRelative(void *, VROverlayHandle_t, VROverlayHandle_t, HmdMatrix34_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTransformCursor(void *, VROverlayHandle_t, HmdVector2_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTransformCursor(void *, VROverlayHandle_t, HmdVector2_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTransformProjection(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdMatrix34_t *, VROverlayProjection_t *, EVREye);
extern EVROverlayError cppIVROverlay_IVROverlay_025_ShowOverlay(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_HideOverlay(void *, VROverlayHandle_t);
extern bool cppIVROverlay_IVROverlay_025_IsOverlayVisible(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinates(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdVector2_t, HmdMatrix34_t *);
extern bool cppIVROverlay_IVROverlay_025_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1168 *, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
extern bool cppIVROverlay_IVROverlay_025_ComputeOverlayIntersection(void *, VROverlayHandle_t, VROverlayIntersectionParams_t *, VROverlayIntersectionResults_t *);
extern bool cppIVROverlay_IVROverlay_025_IsHoverTargetOverlay(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayIntersectionMask(void *, VROverlayHandle_t, VROverlayIntersectionMaskPrimitive_t *, uint32_t, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_TriggerLaserMouseHapticVibration(void *, VROverlayHandle_t, float, float, float);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayCursor(void *, VROverlayHandle_t, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayCursorPositionOverride(void *, VROverlayHandle_t, HmdVector2_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_ClearOverlayCursorPositionOverride(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTexture(void *, VROverlayHandle_t, Texture_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_ClearOverlayTexture(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayRaw(void *, VROverlayHandle_t, void *, uint32_t, uint32_t, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayFromFile(void *, VROverlayHandle_t, const char *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTexture(void *, VROverlayHandle_t, void **, void *, uint32_t *, uint32_t *, uint32_t *, ETextureType *, EColorSpace *, VRTextureBounds_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_ReleaseNativeOverlayHandle(void *, VROverlayHandle_t, void *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTextureSize(void *, VROverlayHandle_t, uint32_t *, uint32_t *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_CreateDashboardOverlay(void *, const char *, const char *, VROverlayHandle_t *, VROverlayHandle_t *);
extern bool cppIVROverlay_IVROverlay_025_IsDashboardVisible(void *);
extern bool cppIVROverlay_IVROverlay_025_IsActiveDashboardOverlay(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_SetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_GetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t *);
extern void cppIVROverlay_IVROverlay_025_ShowDashboard(void *, const char *);
extern TrackedDeviceIndex_t cppIVROverlay_IVROverlay_025_GetPrimaryDashboardDevice(void *);
extern EVROverlayError cppIVROverlay_IVROverlay_025_ShowKeyboard(void *, EGamepadTextInputMode, EGamepadTextInputLineMode, uint32_t, const char *, uint32_t, const char *, uint64_t);
extern EVROverlayError cppIVROverlay_IVROverlay_025_ShowKeyboardForOverlay(void *, VROverlayHandle_t, EGamepadTextInputMode, EGamepadTextInputLineMode, uint32_t, const char *, uint32_t, const char *, uint64_t);
extern uint32_t cppIVROverlay_IVROverlay_025_GetKeyboardText(void *, char *, uint32_t);
extern void cppIVROverlay_IVROverlay_025_HideKeyboard(void *);
extern void cppIVROverlay_IVROverlay_025_SetKeyboardTransformAbsolute(void *, ETrackingUniverseOrigin, HmdMatrix34_t *);
extern void cppIVROverlay_IVROverlay_025_SetKeyboardPositionForOverlay(void *, VROverlayHandle_t, HmdRect2_t);
extern VRMessageOverlayResponse cppIVROverlay_IVROverlay_025_ShowMessageOverlay(void *, const char *, const char *, const char *, const char *, const char *, const char *);
extern void cppIVROverlay_IVROverlay_025_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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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_11415 ** ppRenderModel)
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1168 ** 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_11415_wrap(lin);
*ppRenderModel = struct_RenderModel_t_1168_wrap(lin);
return _ret;
}
void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_11415 * pRenderModel)
void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1168 * pRenderModel)
{
((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_11415_unwrap(pRenderModel));
((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1168_unwrap(pRenderModel));
}
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_11415 ** ppTexture)
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1168 ** 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_11415_wrap(lin);
*ppTexture = struct_RenderModel_TextureMap_t_1168_wrap(lin);
return _ret;
}
void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_11415 * pTexture)
void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1168 * pTexture)
{
((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_11415_unwrap(pTexture));
((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1168_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_11415_win_to_lin(pControllerState, &lin);
struct_VRControllerState001_t_1168_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_11415 **);
extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_11415 *);
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_11415 **);
extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_11415 *);
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_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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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_11415 * pEvent, uint32_t uncbVREvent)
bool cppIVRSystem_IVRSystem_022_PollNextEvent(void *linux_side, winVREvent_t_1168 * pEvent, uint32_t uncbVREvent)
{
VREvent_t lin;
bool _ret;
if(pEvent)
struct_VREvent_t_11415_win_to_lin(pEvent, &lin);
struct_VREvent_t_1168_win_to_lin(pEvent, &lin);
_ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, uncbVREvent ? sizeof(lin) : 0);
if(pEvent)
struct_VREvent_t_11415_lin_to_win(&lin, pEvent, uncbVREvent);
struct_VREvent_t_1168_lin_to_win(&lin, pEvent, uncbVREvent);
return _ret;
}
bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_11415 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1168 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
{
VREvent_t lin;
bool _ret;
if(pEvent)
struct_VREvent_t_11415_win_to_lin(pEvent, &lin);
struct_VREvent_t_1168_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_11415_lin_to_win(&lin, pEvent, uncbVREvent);
struct_VREvent_t_1168_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_11415 * pControllerState, uint32_t unControllerStateSize)
bool cppIVRSystem_IVRSystem_022_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1168 * pControllerState, uint32_t unControllerStateSize)
{
VRControllerState001_t lin;
bool _ret;
if(pControllerState)
struct_VRControllerState001_t_11415_win_to_lin(pControllerState, &lin);
struct_VRControllerState001_t_1168_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_11415_lin_to_win(&lin, pControllerState, unControllerStateSize);
struct_VRControllerState001_t_1168_lin_to_win(&lin, pControllerState, unControllerStateSize);
return _ret;
}
bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_11415 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1168 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
{
VRControllerState001_t lin;
bool _ret;
if(pControllerState)
struct_VRControllerState001_t_11415_win_to_lin(pControllerState, &lin);
struct_VRControllerState001_t_1168_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_11415_lin_to_win(&lin, pControllerState, unControllerStateSize);
struct_VRControllerState001_t_1168_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_11415 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_11415 *, uint32_t, TrackedDevicePose_t *);
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 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_11415 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_11415 *, uint32_t, TrackedDevicePose_t *);
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 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.14.15/ivrclientcore.h"
#include "openvr_v1.16.8/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_11415 * 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_1168 * pFrameHeader, uint32_t nFrameHeaderSize)
{
CameraVideoStreamFrameHeader_t lin;
vr::EVRTrackedCameraError _ret;
if(pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_11415_win_to_lin(pFrameHeader, &lin);
struct_CameraVideoStreamFrameHeader_t_1168_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_11415_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1168_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_11415 * pFrameHeader, uint32_t nFrameHeaderSize)
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)
{
CameraVideoStreamFrameHeader_t lin;
vr::EVRTrackedCameraError _ret;
if(pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_11415_win_to_lin(pFrameHeader, &lin);
struct_CameraVideoStreamFrameHeader_t_1168_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_11415_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1168_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_11415 * pFrameHeader, uint32_t nFrameHeaderSize)
vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1168 * pFrameHeader, uint32_t nFrameHeaderSize)
{
CameraVideoStreamFrameHeader_t lin;
vr::EVRTrackedCameraError _ret;
if(pFrameHeader)
struct_CameraVideoStreamFrameHeader_t_11415_win_to_lin(pFrameHeader, &lin);
struct_CameraVideoStreamFrameHeader_t_1168_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_11415_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
struct_CameraVideoStreamFrameHeader_t_1168_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_11415 *, uint32_t);
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, uint32_t, winCameraVideoStreamFrameHeader_t_1168 *, 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_11415 *, uint32_t);
extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, winCameraVideoStreamFrameHeader_t_11415 *, 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_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_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);
typedef struct winVREvent_t_1168 winVREvent_t_1168;
extern void struct_VREvent_t_1168_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_VREvent_t_1168_win_to_lin(void *w, void *l);
typedef struct winVRControllerState001_t_1168 winVRControllerState001_t_1168;
extern void struct_VRControllerState001_t_1168_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_VRControllerState001_t_1168_win_to_lin(void *w, void *l);
typedef struct winCameraVideoStreamFrameHeader_t_1168 winCameraVideoStreamFrameHeader_t_1168;
extern void struct_CameraVideoStreamFrameHeader_t_1168_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_CameraVideoStreamFrameHeader_t_1168_win_to_lin(void *w, void *l);
typedef struct winRenderModel_TextureMap_t_1168 winRenderModel_TextureMap_t_1168;
extern void struct_RenderModel_TextureMap_t_1168_lin_to_win(void *l, void *w);
extern void struct_RenderModel_TextureMap_t_1168_win_to_lin(void *w, void *l);
extern struct winRenderModel_TextureMap_t_1168 *struct_RenderModel_TextureMap_t_1168_wrap(void *l);
extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1168_unwrap(winRenderModel_TextureMap_t_1168 *w);
typedef struct winRenderModel_t_1168 winRenderModel_t_1168;
extern void struct_RenderModel_t_1168_lin_to_win(void *l, void *w);
extern void struct_RenderModel_t_1168_win_to_lin(void *w, void *l);
extern struct winRenderModel_t_1168 *struct_RenderModel_t_1168_wrap(void *l);
extern RenderModel_t *struct_RenderModel_t_1168_unwrap(winRenderModel_t_1168 *w);
typedef struct winInputAnalogActionData_t_1168 winInputAnalogActionData_t_1168;
extern void struct_InputAnalogActionData_t_1168_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_InputAnalogActionData_t_1168_win_to_lin(void *w, void *l);
typedef struct winInputDigitalActionData_t_1168 winInputDigitalActionData_t_1168;
extern void struct_InputDigitalActionData_t_1168_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_InputDigitalActionData_t_1168_win_to_lin(void *w, void *l);
typedef struct winInputPoseActionData_t_1168 winInputPoseActionData_t_1168;
extern void struct_InputPoseActionData_t_1168_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_InputPoseActionData_t_1168_win_to_lin(void *w, void *l);
typedef struct winInputSkeletalActionData_t_1168 winInputSkeletalActionData_t_1168;
extern void struct_InputSkeletalActionData_t_1168_lin_to_win(void *l, void *w, uint32_t sz);
extern void struct_InputSkeletalActionData_t_1168_win_to_lin(void *w, void *l);
typedef struct winVRVulkanTextureArrayData_t_11415 winVRVulkanTextureArrayData_t_11415;
extern void struct_VRVulkanTextureArrayData_t_11415_lin_to_win(void *l, void *w);
extern void struct_VRVulkanTextureArrayData_t_11415_win_to_lin(void *w, void *l);

358
vrclient_x64/vrclient_x64/struct_converters_1168.cpp Normal file
View File

@ -0,0 +1,358 @@
#include <stdlib.h>
#include <string.h>
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.16.8/openvr.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
#pragma pack(push, 8)
struct winVRVulkanTextureArrayData_t_1168 {
uint32_t m_unArrayIndex;
uint32_t m_unArraySize;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_VRVulkanTextureArrayData_t_1168_lin_to_win(void *l, void *w)
{
struct winVRVulkanTextureArrayData_t_1168 *win = (struct winVRVulkanTextureArrayData_t_1168 *)w;
VRVulkanTextureArrayData_t *lin = (VRVulkanTextureArrayData_t *)l;
win->m_unArrayIndex = lin->m_unArrayIndex;
win->m_unArraySize = lin->m_unArraySize;
}
void struct_VRVulkanTextureArrayData_t_1168_win_to_lin(void *w, void *l)
{
struct winVRVulkanTextureArrayData_t_1168 *win = (struct winVRVulkanTextureArrayData_t_1168 *)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_1168 {
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_1168_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winVREvent_t_1168 *win = (struct winVREvent_t_1168 *)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_1168_win_to_lin(void *w, void *l)
{
struct winVREvent_t_1168 *win = (struct winVREvent_t_1168 *)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_1168 {
uint32_t unPacketNum;
uint64_t ulButtonPressed;
uint64_t ulButtonTouched;
vr::VRControllerAxis_t rAxis[5];
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_VRControllerState001_t_1168_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winVRControllerState001_t_1168 *win = (struct winVRControllerState001_t_1168 *)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_1168_win_to_lin(void *w, void *l)
{
struct winVRControllerState001_t_1168 *win = (struct winVRControllerState001_t_1168 *)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_1168 {
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_1168_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winCameraVideoStreamFrameHeader_t_1168 *win = (struct winCameraVideoStreamFrameHeader_t_1168 *)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_1168_win_to_lin(void *w, void *l)
{
struct winCameraVideoStreamFrameHeader_t_1168 *win = (struct winCameraVideoStreamFrameHeader_t_1168 *)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_1168 {
uint16_t unWidth;
uint16_t unHeight;
const uint8_t * rubTextureMapData;
vr::EVRRenderModelTextureFormat format;
RenderModel_TextureMap_t *linux_side;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_RenderModel_TextureMap_t_1168_lin_to_win(void *l, void *w)
{
struct winRenderModel_TextureMap_t_1168 *win = (struct winRenderModel_TextureMap_t_1168 *)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;
}
void struct_RenderModel_TextureMap_t_1168_win_to_lin(void *w, void *l)
{
struct winRenderModel_TextureMap_t_1168 *win = (struct winRenderModel_TextureMap_t_1168 *)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;
}
struct winRenderModel_TextureMap_t_1168 *struct_RenderModel_TextureMap_t_1168_wrap(void *l)
{
struct winRenderModel_TextureMap_t_1168 *win = (struct winRenderModel_TextureMap_t_1168 *)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->linux_side = lin;
return win;
}
struct RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1168_unwrap(winRenderModel_TextureMap_t_1168 *w)
{
RenderModel_TextureMap_t *ret = w->linux_side;
free(w);
return ret;
}
#pragma pack(push, 8)
struct winRenderModel_t_1168 {
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_1168_lin_to_win(void *l, void *w)
{
struct winRenderModel_t_1168 *win = (struct winRenderModel_t_1168 *)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_1168_win_to_lin(void *w, void *l)
{
struct winRenderModel_t_1168 *win = (struct winRenderModel_t_1168 *)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_1168 *struct_RenderModel_t_1168_wrap(void *l)
{
struct winRenderModel_t_1168 *win = (struct winRenderModel_t_1168 *)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_1168_unwrap(winRenderModel_t_1168 *w)
{
RenderModel_t *ret = w->linux_side;
free(w);
return ret;
}
#pragma pack(push, 8)
struct winInputAnalogActionData_t_1168 {
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_1168_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winInputAnalogActionData_t_1168 *win = (struct winInputAnalogActionData_t_1168 *)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_1168_win_to_lin(void *w, void *l)
{
struct winInputAnalogActionData_t_1168 *win = (struct winInputAnalogActionData_t_1168 *)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_1168 {
bool bActive;
vr::VRInputValueHandle_t activeOrigin;
bool bState;
bool bChanged;
float fUpdateTime;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_InputDigitalActionData_t_1168_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winInputDigitalActionData_t_1168 *win = (struct winInputDigitalActionData_t_1168 *)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_1168_win_to_lin(void *w, void *l)
{
struct winInputDigitalActionData_t_1168 *win = (struct winInputDigitalActionData_t_1168 *)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_1168 {
bool bActive;
vr::VRInputValueHandle_t activeOrigin;
vr::TrackedDevicePose_t pose __attribute__((aligned(4)));
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_InputPoseActionData_t_1168_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winInputPoseActionData_t_1168 *win = (struct winInputPoseActionData_t_1168 *)w;
InputPoseActionData_t *lin = (InputPoseActionData_t *)l;
win->bActive = lin->bActive;
win->activeOrigin = lin->activeOrigin;
win->pose = lin->pose;
}
void struct_InputPoseActionData_t_1168_win_to_lin(void *w, void *l)
{
struct winInputPoseActionData_t_1168 *win = (struct winInputPoseActionData_t_1168 *)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_1168 {
bool bActive;
vr::VRInputValueHandle_t activeOrigin;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_InputSkeletalActionData_t_1168_lin_to_win(void *l, void *w, uint32_t sz)
{
struct winInputSkeletalActionData_t_1168 *win = (struct winInputSkeletalActionData_t_1168 *)w;
InputSkeletalActionData_t *lin = (InputSkeletalActionData_t *)l;
win->bActive = lin->bActive;
win->activeOrigin = lin->activeOrigin;
}
void struct_InputSkeletalActionData_t_1168_win_to_lin(void *w, void *l)
{
struct winInputSkeletalActionData_t_1168 *win = (struct winInputSkeletalActionData_t_1168 *)w;
InputSkeletalActionData_t *lin = (InputSkeletalActionData_t *)l;
lin->bActive = win->bActive;
lin->activeOrigin = win->activeOrigin;
}
}

54
vrclient_x64/vrclient_x64/vrclient_defs.h
View File

@ -132,6 +132,7 @@ typedef struct VRSkeletalSummaryData_t VRSkeletalSummaryData_t;
typedef struct InputBindingInfo_t InputBindingInfo_t;
typedef struct VRNativeDevice_t VRNativeDevice_t;
typedef struct VROverlayView_t VROverlayView_t;
typedef struct VROverlayProjection_t VROverlayProjection_t;
/* dereferenced structs */
typedef struct HmdMatrix34_t
@ -234,6 +235,13 @@ struct VRVulkanTextureData_t
uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
};
struct VRVulkanTextureArrayData_t
{
struct VRVulkanTextureData_t t;
uint32_t m_unArrayIndex;
uint32_t m_unArraySize;
};
typedef struct Texture_t
{
void *handle;
@ -269,30 +277,40 @@ typedef struct VRTextureWithPoseAndDepth_t
typedef enum EVRSubmitFlags
{
// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
Submit_Default = 0x00,
// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
Submit_Default = 0x00,
// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
Submit_LensDistortionAlreadyApplied = 0x01,
// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
Submit_LensDistortionAlreadyApplied = 0x01,
// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
Submit_GlRenderBuffer = 0x02,
// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
Submit_GlRenderBuffer = 0x02,
// Do not use
Submit_Reserved = 0x04,
// Do not use
Submit_Reserved = 0x04,
Submit_Screenshot = 0x04,
Submit_VulkanTexture = 0x04,
// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
// This flag can be combined with Submit_TextureWithDepth to pass a VRTextureWithPoseAndDepth_t.
Submit_TextureWithPose = 0x08,
// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
// This flag can be combined with Submit_TextureWithDepth to pass a VRTextureWithPoseAndDepth_t.
Submit_TextureWithPose = 0x08,
// Set to indicate that pTexture is a pointer to a VRTextureWithDepth_t.
// This flag can be combined with Submit_TextureWithPose to pass a VRTextureWithPoseAndDepth_t.
Submit_TextureWithDepth = 0x10,
// Set to indicate that pTexture is a pointer to a VRTextureWithDepth_t.
// This flag can be combined with Submit_TextureWithPose to pass a VRTextureWithPoseAndDepth_t.
Submit_TextureWithDepth = 0x10,
// Set to indicate a discontinuity between this and the last frame.
// This will prevent motion smoothing from attempting to extrapolate using the pair.
Submit_FrameDiscontinuty = 0x20,
// Set to indicate that pTexture->handle is a contains VRVulkanTextureArrayData_t
Submit_VulkanTextureWithArrayData = 0x40,
// If the texture pointer passed in is an OpenGL Array texture, set this flag
Submit_GlArrayTexture = 0x80,
// Do not use
Submit_Reserved2 = 0x8000,
} EVRSubmitFlags;
typedef enum EVRCompositorTimingMode

28
vrclient_x64/vrclient_x64/vrclient_main.c
View File

@ -41,8 +41,8 @@ typedef struct winRenderModel_TextureMap_t_1015 winRenderModel_TextureMap_t_1015
/* this is cast to 1015 during load_linux_texture_map, so ensure they're
* binary compatible before updating this number */
typedef struct winRenderModel_t_11415 winRenderModel_t_11415;
typedef struct winRenderModel_TextureMap_t_11415 winRenderModel_TextureMap_t_11415;
typedef struct winRenderModel_t_1168 winRenderModel_t_1168;
typedef struct winRenderModel_TextureMap_t_1168 winRenderModel_TextureMap_t_1168;
#include "cppIVRRenderModels_IVRRenderModels_006.h"
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
@ -881,6 +881,7 @@ static EVRCompositorError ivrcompositor_submit_dxvk(
void *linux_side, EVREye eye, Texture_t *texture, VRTextureBounds_t *bounds, EVRSubmitFlags flags,
unsigned int version, IDXGIVkInteropSurface *dxvk_surface)
{
static const EVRSubmitFlags supported_flags = Submit_LensDistortionAlreadyApplied | Submit_FrameDiscontinuty;
struct VRVulkanTextureData_t vkdata;
IDXGIVkInteropDevice *dxvk_device;
struct Texture_t vktexture;
@ -895,8 +896,8 @@ static EVRCompositorError ivrcompositor_submit_dxvk(
compositor_data.dxvk_device = dxvk_device;
if (flags & (Submit_TextureWithPose | Submit_TextureWithDepth))
FIXME("Unhandled flags %#x.\n", flags & (Submit_TextureWithPose | Submit_TextureWithDepth));
if (flags & ~supported_flags)
FIXME("Unhandled flags %#x.\n", flags);
subresources.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
subresources.baseMipLevel = 0;
@ -950,7 +951,8 @@ static EVRCompositorError ivrcompositor_submit_vulkan(
void *linux_side, EVREye eye, Texture_t *texture, VRTextureBounds_t *bounds, EVRSubmitFlags flags,
unsigned int version)
{
struct VRVulkanTextureData_t our_vkdata, our_depth_vkdata, *their_vkdata;
struct VRVulkanTextureData_t our_depth_vkdata, *their_vkdata;
struct VRVulkanTextureArrayData_t our_vkdata;
VRTextureWithPoseAndDepth_t our_both;
VRTextureWithDepth_t our_depth;
VRTextureWithPose_t our_pose;
@ -961,11 +963,13 @@ static EVRCompositorError ivrcompositor_submit_vulkan(
their_vkdata = texture->handle;
our_vkdata = *their_vkdata;
our_vkdata.m_pDevice = get_native_VkDevice(our_vkdata.m_pDevice);
our_vkdata.m_pPhysicalDevice = get_native_VkPhysicalDevice(our_vkdata.m_pPhysicalDevice);
our_vkdata.m_pInstance = get_native_VkInstance(our_vkdata.m_pInstance);
our_vkdata.m_pQueue = get_native_VkQueue(our_vkdata.m_pQueue);
memcpy(&our_vkdata, their_vkdata, flags & Submit_VulkanTextureWithArrayData
? sizeof(struct VRVulkanTextureArrayData_t) : sizeof(struct VRVulkanTextureData_t));
our_vkdata.t.m_pDevice = get_native_VkDevice(our_vkdata.t.m_pDevice);
our_vkdata.t.m_pPhysicalDevice = get_native_VkPhysicalDevice(our_vkdata.t.m_pPhysicalDevice);
our_vkdata.t.m_pInstance = get_native_VkInstance(our_vkdata.t.m_pInstance);
our_vkdata.t.m_pQueue = get_native_VkQueue(our_vkdata.t.m_pQueue);
switch (flags & (Submit_TextureWithPose | Submit_TextureWithDepth))
{
@ -1527,7 +1531,7 @@ static EVRRenderModelError load_linux_texture_map(void *linux_side, TextureID_t
case 5:
return cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(linux_side, texture_id, texture_map);
case 6:
return cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(linux_side, texture_id, (struct winRenderModel_TextureMap_t_11415 **)texture_map);
return cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(linux_side, texture_id, (struct winRenderModel_TextureMap_t_1168 **)texture_map);
}
FIXME("Unsupported IVRRenderModels version! %u\n", version);
return VRRenderModelError_NotSupported;
@ -1544,7 +1548,7 @@ static void free_linux_texture_map(void *linux_side,
cppIVRRenderModels_IVRRenderModels_005_FreeTexture(linux_side, texture_map);
break;
case 6:
cppIVRRenderModels_IVRRenderModels_006_FreeTexture(linux_side, (struct winRenderModel_TextureMap_t_11415 *)texture_map);
cppIVRRenderModels_IVRRenderModels_006_FreeTexture(linux_side, (struct winRenderModel_TextureMap_t_1168 *)texture_map);
break;
default:
FIXME("Unsupported IVRRenderModels version! %u\n", version);

532
vrclient_x64/vrclient_x64/winIVRCompositor.c
View File

@ -18,6 +18,525 @@
WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
#include "cppIVRCompositor_IVRCompositor_027.h"
typedef struct __winIVRCompositor_IVRCompositor_027 {
vtable_ptr *vtable;
void *linux_side;
} winIVRCompositor_IVRCompositor_027;
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_SetTrackingSpace, 8)
void __thiscall winIVRCompositor_IVRCompositor_027_SetTrackingSpace(winIVRCompositor_IVRCompositor_027 *_this, ETrackingUniverseOrigin eOrigin)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_SetTrackingSpace(_this->linux_side, eOrigin);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetTrackingSpace, 4)
ETrackingUniverseOrigin __thiscall winIVRCompositor_IVRCompositor_027_GetTrackingSpace(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetTrackingSpace(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_WaitGetPoses, 20)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_WaitGetPoses(winIVRCompositor_IVRCompositor_027 *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_WaitGetPoses(_this->linux_side, pRenderPoseArray, unRenderPoseArrayCount, pGamePoseArray, unGamePoseArrayCount);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetLastPoses, 20)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_GetLastPoses(winIVRCompositor_IVRCompositor_027 *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetLastPoses(_this->linux_side, pRenderPoseArray, unRenderPoseArrayCount, pGamePoseArray, unGamePoseArrayCount);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex, 16)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex(winIVRCompositor_IVRCompositor_027 *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex(_this->linux_side, unDeviceIndex, pOutputPose, pOutputGamePose);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_Submit, 20)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_Submit(winIVRCompositor_IVRCompositor_027 *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
{
TRACE("%p\n", _this);
return ivrcompositor_submit(cppIVRCompositor_IVRCompositor_027_Submit, _this->linux_side, eEye, pTexture, pBounds, nSubmitFlags, 27);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ClearLastSubmittedFrame, 4)
void __thiscall winIVRCompositor_IVRCompositor_027_ClearLastSubmittedFrame(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_ClearLastSubmittedFrame(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_PostPresentHandoff, 4)
void __thiscall winIVRCompositor_IVRCompositor_027_PostPresentHandoff(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
ivrcompositor_post_present_handoff(cppIVRCompositor_IVRCompositor_027_PostPresentHandoff, _this->linux_side, 27);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetFrameTiming, 12)
bool __thiscall winIVRCompositor_IVRCompositor_027_GetFrameTiming(winIVRCompositor_IVRCompositor_027 *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetFrameTiming(_this->linux_side, pTiming, unFramesAgo);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetFrameTimings, 12)
uint32_t __thiscall winIVRCompositor_IVRCompositor_027_GetFrameTimings(winIVRCompositor_IVRCompositor_027 *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetFrameTimings(_this->linux_side, pTiming, nFrames);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetFrameTimeRemaining, 4)
float __thiscall winIVRCompositor_IVRCompositor_027_GetFrameTimeRemaining(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetFrameTimeRemaining(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetCumulativeStats, 12)
void __thiscall winIVRCompositor_IVRCompositor_027_GetCumulativeStats(winIVRCompositor_IVRCompositor_027 *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_GetCumulativeStats(_this->linux_side, pStats, nStatsSizeInBytes);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_FadeToColor, 25)
void __thiscall winIVRCompositor_IVRCompositor_027_FadeToColor(winIVRCompositor_IVRCompositor_027 *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_FadeToColor(_this->linux_side, fSeconds, fRed, fGreen, fBlue, fAlpha, bBackground);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetCurrentFadeColor, 9)
HmdColor_t *__thiscall winIVRCompositor_IVRCompositor_027_GetCurrentFadeColor(winIVRCompositor_IVRCompositor_027 *_this, HmdColor_t *_r, bool bBackground)
{
TRACE("%p\n", _this);
*_r = cppIVRCompositor_IVRCompositor_027_GetCurrentFadeColor(_this->linux_side, bBackground);
return _r;
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_FadeGrid, 9)
void __thiscall winIVRCompositor_IVRCompositor_027_FadeGrid(winIVRCompositor_IVRCompositor_027 *_this, float fSeconds, bool bFadeGridIn)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_FadeGrid(_this->linux_side, fSeconds, bFadeGridIn);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetCurrentGridAlpha, 4)
float __thiscall winIVRCompositor_IVRCompositor_027_GetCurrentGridAlpha(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetCurrentGridAlpha(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_SetSkyboxOverride, 12)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_SetSkyboxOverride(winIVRCompositor_IVRCompositor_027 *_this, Texture_t * pTextures, uint32_t unTextureCount)
{
TRACE("%p\n", _this);
return ivrcompositor_set_skybox_override(cppIVRCompositor_IVRCompositor_027_SetSkyboxOverride, _this->linux_side, pTextures, unTextureCount, 27);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ClearSkyboxOverride, 4)
void __thiscall winIVRCompositor_IVRCompositor_027_ClearSkyboxOverride(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_ClearSkyboxOverride(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_CompositorBringToFront, 4)
void __thiscall winIVRCompositor_IVRCompositor_027_CompositorBringToFront(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_CompositorBringToFront(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_CompositorGoToBack, 4)
void __thiscall winIVRCompositor_IVRCompositor_027_CompositorGoToBack(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_CompositorGoToBack(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_CompositorQuit, 4)
void __thiscall winIVRCompositor_IVRCompositor_027_CompositorQuit(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_CompositorQuit(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_IsFullscreen, 4)
bool __thiscall winIVRCompositor_IVRCompositor_027_IsFullscreen(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_IsFullscreen(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetCurrentSceneFocusProcess, 4)
uint32_t __thiscall winIVRCompositor_IVRCompositor_027_GetCurrentSceneFocusProcess(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetCurrentSceneFocusProcess(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetLastFrameRenderer, 4)
uint32_t __thiscall winIVRCompositor_IVRCompositor_027_GetLastFrameRenderer(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetLastFrameRenderer(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_CanRenderScene, 4)
bool __thiscall winIVRCompositor_IVRCompositor_027_CanRenderScene(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_CanRenderScene(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ShowMirrorWindow, 4)
void __thiscall winIVRCompositor_IVRCompositor_027_ShowMirrorWindow(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_ShowMirrorWindow(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_HideMirrorWindow, 4)
void __thiscall winIVRCompositor_IVRCompositor_027_HideMirrorWindow(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_HideMirrorWindow(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_IsMirrorWindowVisible, 4)
bool __thiscall winIVRCompositor_IVRCompositor_027_IsMirrorWindowVisible(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_IsMirrorWindowVisible(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_CompositorDumpImages, 4)
void __thiscall winIVRCompositor_IVRCompositor_027_CompositorDumpImages(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_CompositorDumpImages(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ShouldAppRenderWithLowResources, 4)
bool __thiscall winIVRCompositor_IVRCompositor_027_ShouldAppRenderWithLowResources(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_ShouldAppRenderWithLowResources(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ForceInterleavedReprojectionOn, 5)
void __thiscall winIVRCompositor_IVRCompositor_027_ForceInterleavedReprojectionOn(winIVRCompositor_IVRCompositor_027 *_this, bool bOverride)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_ForceInterleavedReprojectionOn(_this->linux_side, bOverride);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ForceReconnectProcess, 4)
void __thiscall winIVRCompositor_IVRCompositor_027_ForceReconnectProcess(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_ForceReconnectProcess(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_SuspendRendering, 5)
void __thiscall winIVRCompositor_IVRCompositor_027_SuspendRendering(winIVRCompositor_IVRCompositor_027 *_this, bool bSuspend)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_SuspendRendering(_this->linux_side, bSuspend);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetMirrorTextureD3D11, 16)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_GetMirrorTextureD3D11(winIVRCompositor_IVRCompositor_027 *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetMirrorTextureD3D11(_this->linux_side, eEye, pD3D11DeviceOrResource, ppD3D11ShaderResourceView);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ReleaseMirrorTextureD3D11, 8)
void __thiscall winIVRCompositor_IVRCompositor_027_ReleaseMirrorTextureD3D11(winIVRCompositor_IVRCompositor_027 *_this, void * pD3D11ShaderResourceView)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_ReleaseMirrorTextureD3D11(_this->linux_side, pD3D11ShaderResourceView);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetMirrorTextureGL, 16)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_GetMirrorTextureGL(winIVRCompositor_IVRCompositor_027 *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetMirrorTextureGL(_this->linux_side, eEye, pglTextureId, pglSharedTextureHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ReleaseSharedGLTexture, 12)
bool __thiscall winIVRCompositor_IVRCompositor_027_ReleaseSharedGLTexture(winIVRCompositor_IVRCompositor_027 *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_ReleaseSharedGLTexture(_this->linux_side, glTextureId, glSharedTextureHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_LockGLSharedTextureForAccess, 8)
void __thiscall winIVRCompositor_IVRCompositor_027_LockGLSharedTextureForAccess(winIVRCompositor_IVRCompositor_027 *_this, glSharedTextureHandle_t glSharedTextureHandle)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_LockGLSharedTextureForAccess(_this->linux_side, glSharedTextureHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_UnlockGLSharedTextureForAccess, 8)
void __thiscall winIVRCompositor_IVRCompositor_027_UnlockGLSharedTextureForAccess(winIVRCompositor_IVRCompositor_027 *_this, glSharedTextureHandle_t glSharedTextureHandle)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_UnlockGLSharedTextureForAccess(_this->linux_side, glSharedTextureHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetVulkanInstanceExtensionsRequired, 12)
uint32_t __thiscall winIVRCompositor_IVRCompositor_027_GetVulkanInstanceExtensionsRequired(winIVRCompositor_IVRCompositor_027 *_this, char * pchValue, uint32_t unBufferSize)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetVulkanInstanceExtensionsRequired(_this->linux_side, pchValue, unBufferSize);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetVulkanDeviceExtensionsRequired, 16)
uint32_t __thiscall winIVRCompositor_IVRCompositor_027_GetVulkanDeviceExtensionsRequired(winIVRCompositor_IVRCompositor_027 *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize)
{
TRACE("%p\n", _this);
return ivrcompositor_get_vulkan_device_extensions_required(cppIVRCompositor_IVRCompositor_027_GetVulkanDeviceExtensionsRequired, _this->linux_side, pPhysicalDevice, pchValue, unBufferSize, 27);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_SetExplicitTimingMode, 8)
void __thiscall winIVRCompositor_IVRCompositor_027_SetExplicitTimingMode(winIVRCompositor_IVRCompositor_027 *_this, EVRCompositorTimingMode eTimingMode)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_SetExplicitTimingMode(_this->linux_side, eTimingMode);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_SubmitExplicitTimingData, 4)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_SubmitExplicitTimingData(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_SubmitExplicitTimingData(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_IsMotionSmoothingEnabled, 4)
bool __thiscall winIVRCompositor_IVRCompositor_027_IsMotionSmoothingEnabled(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_IsMotionSmoothingEnabled(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_IsMotionSmoothingSupported, 4)
bool __thiscall winIVRCompositor_IVRCompositor_027_IsMotionSmoothingSupported(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_IsMotionSmoothingSupported(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_IsCurrentSceneFocusAppLoading, 4)
bool __thiscall winIVRCompositor_IVRCompositor_027_IsCurrentSceneFocusAppLoading(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_IsCurrentSceneFocusAppLoading(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_SetStageOverride_Async, 20)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_SetStageOverride_Async(winIVRCompositor_IVRCompositor_027 *_this, const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings)
{
char lin_pchRenderModelPath[PATH_MAX];
vrclient_dos_path_to_unix_path(pchRenderModelPath, lin_pchRenderModelPath);
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_SetStageOverride_Async(_this->linux_side, pchRenderModelPath ? lin_pchRenderModelPath : NULL, pTransform, pRenderSettings, nSizeOfRenderSettings);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ClearStageOverride, 4)
void __thiscall winIVRCompositor_IVRCompositor_027_ClearStageOverride(winIVRCompositor_IVRCompositor_027 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_027_ClearStageOverride(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetCompositorBenchmarkResults, 12)
bool __thiscall winIVRCompositor_IVRCompositor_027_GetCompositorBenchmarkResults(winIVRCompositor_IVRCompositor_027 *_this, Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetCompositorBenchmarkResults(_this->linux_side, pBenchmarkResults, nSizeOfBenchmarkResults);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetLastPosePredictionIDs, 12)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_GetLastPosePredictionIDs(winIVRCompositor_IVRCompositor_027 *_this, uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetLastPosePredictionIDs(_this->linux_side, pRenderPosePredictionID, pGamePosePredictionID);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetPosesForFrame, 16)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_GetPosesForFrame(winIVRCompositor_IVRCompositor_027 *_this, uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_027_GetPosesForFrame(_this->linux_side, unPosePredictionID, pPoseArray, unPoseArrayCount);
}
extern vtable_ptr winIVRCompositor_IVRCompositor_027_vtable;
#ifndef __GNUC__
void __asm_dummy_vtables(void) {
#endif
__ASM_VTABLE(winIVRCompositor_IVRCompositor_027,
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_SetTrackingSpace)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetTrackingSpace)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_WaitGetPoses)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetLastPoses)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_Submit)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ClearLastSubmittedFrame)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_PostPresentHandoff)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetFrameTiming)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetFrameTimings)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetFrameTimeRemaining)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetCumulativeStats)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_FadeToColor)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetCurrentFadeColor)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_FadeGrid)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetCurrentGridAlpha)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_SetSkyboxOverride)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ClearSkyboxOverride)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_CompositorBringToFront)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_CompositorGoToBack)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_CompositorQuit)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_IsFullscreen)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetCurrentSceneFocusProcess)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetLastFrameRenderer)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_CanRenderScene)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ShowMirrorWindow)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_HideMirrorWindow)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_IsMirrorWindowVisible)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_CompositorDumpImages)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ShouldAppRenderWithLowResources)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ForceInterleavedReprojectionOn)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ForceReconnectProcess)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_SuspendRendering)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetMirrorTextureD3D11)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ReleaseMirrorTextureD3D11)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetMirrorTextureGL)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ReleaseSharedGLTexture)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_LockGLSharedTextureForAccess)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_UnlockGLSharedTextureForAccess)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetVulkanInstanceExtensionsRequired)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetVulkanDeviceExtensionsRequired)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_SetExplicitTimingMode)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_SubmitExplicitTimingData)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_IsMotionSmoothingEnabled)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_IsMotionSmoothingSupported)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_IsCurrentSceneFocusAppLoading)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_SetStageOverride_Async)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ClearStageOverride)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetCompositorBenchmarkResults)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetLastPosePredictionIDs)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetPosesForFrame)
);
#ifndef __GNUC__
}
#endif
winIVRCompositor_IVRCompositor_027 *create_winIVRCompositor_IVRCompositor_027(void *linux_side)
{
winIVRCompositor_IVRCompositor_027 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_027));
TRACE("-> %p\n", r);
r->vtable = &winIVRCompositor_IVRCompositor_027_vtable;
r->linux_side = linux_side;
return r;
}
void destroy_winIVRCompositor_IVRCompositor_027(void *object)
{
TRACE("%p\n", object);
HeapFree(GetProcessHeap(), 0, object);
}
winIVRCompositor_IVRCompositor_027 *create_winIVRCompositor_IVRCompositor_027_FnTable(void *linux_side)
{
winIVRCompositor_IVRCompositor_027 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_027));
struct thunk *thunks = alloc_thunks(51);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 51 * sizeof(*vtable));
int i;
TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_027_SetTrackingSpace, 1, FALSE, FALSE);
init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_027_GetTrackingSpace, 0, FALSE, FALSE);
init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_027_WaitGetPoses, 4, FALSE, FALSE);
init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_027_GetLastPoses, 4, FALSE, FALSE);
init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_027_Submit, 4, FALSE, FALSE);
init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_027_ClearLastSubmittedFrame, 0, FALSE, FALSE);
init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_027_PostPresentHandoff, 0, FALSE, FALSE);
init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_027_GetFrameTiming, 2, FALSE, FALSE);
init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_027_GetFrameTimings, 2, FALSE, FALSE);
init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_027_GetFrameTimeRemaining, 0, FALSE, FALSE);
init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_027_GetCumulativeStats, 2, FALSE, FALSE);
init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_027_FadeToColor, 6, TRUE, TRUE);
init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_027_GetCurrentFadeColor, 2, FALSE, FALSE);
init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_027_FadeGrid, 2, TRUE, FALSE);
init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_027_GetCurrentGridAlpha, 0, FALSE, FALSE);
init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_027_SetSkyboxOverride, 2, FALSE, FALSE);
init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_027_ClearSkyboxOverride, 0, FALSE, FALSE);
init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_027_CompositorBringToFront, 0, FALSE, FALSE);
init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_027_CompositorGoToBack, 0, FALSE, FALSE);
init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_027_CompositorQuit, 0, FALSE, FALSE);
init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_027_IsFullscreen, 0, FALSE, FALSE);
init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_027_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_027_GetLastFrameRenderer, 0, FALSE, FALSE);
init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_027_CanRenderScene, 0, FALSE, FALSE);
init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_027_ShowMirrorWindow, 0, FALSE, FALSE);
init_thunk(&thunks[26], r, winIVRCompositor_IVRCompositor_027_HideMirrorWindow, 0, FALSE, FALSE);
init_thunk(&thunks[27], r, winIVRCompositor_IVRCompositor_027_IsMirrorWindowVisible, 0, FALSE, FALSE);
init_thunk(&thunks[28], r, winIVRCompositor_IVRCompositor_027_CompositorDumpImages, 0, FALSE, FALSE);
init_thunk(&thunks[29], r, winIVRCompositor_IVRCompositor_027_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
init_thunk(&thunks[30], r, winIVRCompositor_IVRCompositor_027_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
init_thunk(&thunks[31], r, winIVRCompositor_IVRCompositor_027_ForceReconnectProcess, 0, FALSE, FALSE);
init_thunk(&thunks[32], r, winIVRCompositor_IVRCompositor_027_SuspendRendering, 1, FALSE, FALSE);
init_thunk(&thunks[33], r, winIVRCompositor_IVRCompositor_027_GetMirrorTextureD3D11, 3, FALSE, FALSE);
init_thunk(&thunks[34], r, winIVRCompositor_IVRCompositor_027_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
init_thunk(&thunks[35], r, winIVRCompositor_IVRCompositor_027_GetMirrorTextureGL, 3, FALSE, FALSE);
init_thunk(&thunks[36], r, winIVRCompositor_IVRCompositor_027_ReleaseSharedGLTexture, 2, FALSE, FALSE);
init_thunk(&thunks[37], r, winIVRCompositor_IVRCompositor_027_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
init_thunk(&thunks[38], r, winIVRCompositor_IVRCompositor_027_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
init_thunk(&thunks[39], r, winIVRCompositor_IVRCompositor_027_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
init_thunk(&thunks[40], r, winIVRCompositor_IVRCompositor_027_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
init_thunk(&thunks[41], r, winIVRCompositor_IVRCompositor_027_SetExplicitTimingMode, 1, FALSE, FALSE);
init_thunk(&thunks[42], r, winIVRCompositor_IVRCompositor_027_SubmitExplicitTimingData, 0, FALSE, FALSE);
init_thunk(&thunks[43], r, winIVRCompositor_IVRCompositor_027_IsMotionSmoothingEnabled, 0, FALSE, FALSE);
init_thunk(&thunks[44], r, winIVRCompositor_IVRCompositor_027_IsMotionSmoothingSupported, 0, FALSE, FALSE);
init_thunk(&thunks[45], r, winIVRCompositor_IVRCompositor_027_IsCurrentSceneFocusAppLoading, 0, FALSE, FALSE);
init_thunk(&thunks[46], r, winIVRCompositor_IVRCompositor_027_SetStageOverride_Async, 4, FALSE, FALSE);
init_thunk(&thunks[47], r, winIVRCompositor_IVRCompositor_027_ClearStageOverride, 0, FALSE, FALSE);
init_thunk(&thunks[48], r, winIVRCompositor_IVRCompositor_027_GetCompositorBenchmarkResults, 2, FALSE, FALSE);
init_thunk(&thunks[49], r, winIVRCompositor_IVRCompositor_027_GetLastPosePredictionIDs, 2, FALSE, FALSE);
init_thunk(&thunks[50], r, winIVRCompositor_IVRCompositor_027_GetPosesForFrame, 3, FALSE, FALSE);
for (i = 0; i < 51; i++)
vtable[i] = &thunks[i];
r->linux_side = linux_side;
r->vtable = (void *)vtable;
return r;
}
void destroy_winIVRCompositor_IVRCompositor_027_FnTable(void *object)
{
winIVRCompositor_IVRCompositor_027 *win_object = object;
TRACE("%p\n", win_object);
VirtualFree(win_object->vtable[0], 0, MEM_RELEASE);
HeapFree(GetProcessHeap(), 0, win_object->vtable);
HeapFree(GetProcessHeap(), 0, win_object);
}
#include "cppIVRCompositor_IVRCompositor_026.h"
typedef struct __winIVRCompositor_IVRCompositor_026 {
@ -302,12 +821,8 @@ void __thiscall winIVRCompositor_IVRCompositor_026_UnlockGLSharedTextureForAcces
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired, 12)
uint32_t __thiscall winIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired(winIVRCompositor_IVRCompositor_026 *_this, char * pchValue, uint32_t unBufferSize)
{
uint32_t ret;
TRACE("%p\n", _this);
ret = cppIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired(_this->linux_side, pchValue, unBufferSize);
TRACE("ret %u, value %s.\n", ret, pchValue);
return ret;
return cppIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired(_this->linux_side, pchValue, unBufferSize);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetVulkanDeviceExtensionsRequired, 16)
@ -1318,12 +1833,7 @@ DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_022_GetVulkanInstanceExte
uint32_t __thiscall winIVRCompositor_IVRCompositor_022_GetVulkanInstanceExtensionsRequired(winIVRCompositor_IVRCompositor_022 *_this, char * pchValue, uint32_t unBufferSize)
{
TRACE("%p\n", _this);
uint32_t ret;
TRACE("%p\n", _this);
ret = cppIVRCompositor_IVRCompositor_022_GetVulkanInstanceExtensionsRequired(_this->linux_side, pchValue, unBufferSize);
TRACE("ret %u, value %s.\n", ret, pchValue);
return ret;
return cppIVRCompositor_IVRCompositor_022_GetVulkanInstanceExtensionsRequired(_this->linux_side, pchValue, unBufferSize);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_022_GetVulkanDeviceExtensionsRequired, 16)

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_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetDigitalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputDigitalActionData_t_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_010_GetDigitalActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetAnalogActionData, 28)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetAnalogActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputAnalogActionData_t_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetAnalogActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputAnalogActionData_t_1168 * 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_11415 * 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_1168 * 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_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
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)
{
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_11415 * pActionData, uint32_t unActionDataSize)
EVRInputError __thiscall winIVRInput_IVRInput_010_GetSkeletalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputSkeletalActionData_t_1168 * pActionData, uint32_t unActionDataSize)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_010_GetSkeletalActionData(_this->linux_side, action, pActionData, unActionDataSize);

770
vrclient_x64/vrclient_x64/winIVROverlay.c
View File

@ -18,6 +18,776 @@
WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
#include "cppIVROverlay_IVROverlay_025.h"
typedef struct __winIVROverlay_IVROverlay_025 {
vtable_ptr *vtable;
void *linux_side;
} winIVROverlay_IVROverlay_025;
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_FindOverlay, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_FindOverlay(winIVROverlay_IVROverlay_025 *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_FindOverlay(_this->linux_side, pchOverlayKey, pOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_CreateOverlay, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_CreateOverlay(winIVROverlay_IVROverlay_025 *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_CreateOverlay(_this->linux_side, pchOverlayKey, pchOverlayName, pOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_DestroyOverlay, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_DestroyOverlay(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_DestroyOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayKey, 24)
uint32_t __thiscall winIVROverlay_IVROverlay_025_GetOverlayKey(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayKey(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pError);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayName, 24)
uint32_t __thiscall winIVROverlay_IVROverlay_025_GetOverlayName(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayName(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pError);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayName, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayName(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayName(_this->linux_side, ulOverlayHandle, pchName);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayImageData, 28)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayImageData(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayImageData(_this->linux_side, ulOverlayHandle, pvBuffer, unBufferSize, punWidth, punHeight);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayErrorNameFromEnum, 8)
const char * __thiscall winIVROverlay_IVROverlay_025_GetOverlayErrorNameFromEnum(winIVROverlay_IVROverlay_025 *_this, EVROverlayError error)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayErrorNameFromEnum(_this->linux_side, error);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayRenderingPid, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayRenderingPid(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayRenderingPid(_this->linux_side, ulOverlayHandle, unPID);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayRenderingPid, 12)
uint32_t __thiscall winIVROverlay_IVROverlay_025_GetOverlayRenderingPid(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayRenderingPid(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayFlag, 17)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayFlag(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayFlag(_this->linux_side, ulOverlayHandle, eOverlayFlag, bEnabled);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayFlag, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayFlag(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayFlag(_this->linux_side, ulOverlayHandle, eOverlayFlag, pbEnabled);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayFlags, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayFlags(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayFlags(_this->linux_side, ulOverlayHandle, pFlags);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayColor, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayColor(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayColor(_this->linux_side, ulOverlayHandle, fRed, fGreen, fBlue);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayColor, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayColor(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayColor(_this->linux_side, ulOverlayHandle, pfRed, pfGreen, pfBlue);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayAlpha, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayAlpha(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayAlpha(_this->linux_side, ulOverlayHandle, fAlpha);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayAlpha, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayAlpha(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayAlpha(_this->linux_side, ulOverlayHandle, pfAlpha);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTexelAspect, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTexelAspect(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayTexelAspect(_this->linux_side, ulOverlayHandle, fTexelAspect);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTexelAspect, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTexelAspect(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayTexelAspect(_this->linux_side, ulOverlayHandle, pfTexelAspect);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlaySortOrder, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlaySortOrder(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlaySortOrder(_this->linux_side, ulOverlayHandle, unSortOrder);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlaySortOrder, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlaySortOrder(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlaySortOrder(_this->linux_side, ulOverlayHandle, punSortOrder);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayWidthInMeters, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayWidthInMeters(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayWidthInMeters(_this->linux_side, ulOverlayHandle, fWidthInMeters);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayWidthInMeters, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayWidthInMeters(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayWidthInMeters(_this->linux_side, ulOverlayHandle, pfWidthInMeters);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayCurvature, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayCurvature(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayCurvature(_this->linux_side, ulOverlayHandle, fCurvature);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayCurvature, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayCurvature(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayCurvature(_this->linux_side, ulOverlayHandle, pfCurvature);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTextureColorSpace, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTextureColorSpace(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayTextureColorSpace(_this->linux_side, ulOverlayHandle, eTextureColorSpace);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTextureColorSpace, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTextureColorSpace(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayTextureColorSpace(_this->linux_side, ulOverlayHandle, peTextureColorSpace);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTextureBounds, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTextureBounds(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayTextureBounds(_this->linux_side, ulOverlayHandle, pOverlayTextureBounds);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTextureBounds, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTextureBounds(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayTextureBounds(_this->linux_side, ulOverlayHandle, pOverlayTextureBounds);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTransformType, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTransformType(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayTransformType(_this->linux_side, ulOverlayHandle, peTransformType);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTransformAbsolute, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTransformAbsolute(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayTransformAbsolute(_this->linux_side, ulOverlayHandle, eTrackingOrigin, pmatTrackingOriginToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTransformAbsolute, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTransformAbsolute(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayTransformAbsolute(_this->linux_side, ulOverlayHandle, peTrackingOrigin, pmatTrackingOriginToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative(_this->linux_side, ulOverlayHandle, unTrackedDevice, pmatTrackedDeviceToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative(_this->linux_side, ulOverlayHandle, punTrackedDevice, pmatTrackedDeviceToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent(_this->linux_side, ulOverlayHandle, unDeviceIndex, pchComponentName);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent(_this->linux_side, ulOverlayHandle, punDeviceIndex, pchComponentName, unComponentNameSize);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTransformOverlayRelative, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTransformOverlayRelative(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayTransformOverlayRelative(_this->linux_side, ulOverlayHandle, ulOverlayHandleParent, pmatParentOverlayToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTransformOverlayRelative, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTransformOverlayRelative(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayTransformOverlayRelative(_this->linux_side, ulOverlayHandle, ulOverlayHandleParent, pmatParentOverlayToOverlayTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTransformCursor, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTransformCursor(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayTransformCursor(_this->linux_side, ulCursorOverlayHandle, pvHotspot);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTransformCursor, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTransformCursor(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayTransformCursor(_this->linux_side, ulOverlayHandle, pvHotspot);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTransformProjection, 28)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTransformProjection(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayTransformProjection(_this->linux_side, ulOverlayHandle, eTrackingOrigin, pmatTrackingOriginToOverlayTransform, pProjection, eEye);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ShowOverlay, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_ShowOverlay(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_ShowOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_HideOverlay, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_HideOverlay(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_HideOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_IsOverlayVisible, 12)
bool __thiscall winIVROverlay_IVROverlay_025_IsOverlayVisible(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_IsOverlayVisible(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinates, 28)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinates(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinates(_this->linux_side, ulOverlayHandle, eTrackingOrigin, coordinatesInOverlay, pmatTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_PollNextOverlayEvent, 20)
bool __thiscall winIVROverlay_IVROverlay_025_PollNextOverlayEvent(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1168 * pEvent, uint32_t uncbVREvent)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_PollNextOverlayEvent(_this->linux_side, ulOverlayHandle, pEvent, uncbVREvent);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayInputMethod, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayInputMethod(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayInputMethod(_this->linux_side, ulOverlayHandle, peInputMethod);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayInputMethod, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayInputMethod(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayInputMethod(_this->linux_side, ulOverlayHandle, eInputMethod);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayMouseScale, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayMouseScale(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayMouseScale(_this->linux_side, ulOverlayHandle, pvecMouseScale);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayMouseScale, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayMouseScale(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayMouseScale(_this->linux_side, ulOverlayHandle, pvecMouseScale);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ComputeOverlayIntersection, 20)
bool __thiscall winIVROverlay_IVROverlay_025_ComputeOverlayIntersection(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_ComputeOverlayIntersection(_this->linux_side, ulOverlayHandle, pParams, pResults);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_IsHoverTargetOverlay, 12)
bool __thiscall winIVROverlay_IVROverlay_025_IsHoverTargetOverlay(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_IsHoverTargetOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayIntersectionMask, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayIntersectionMask(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayIntersectionMask(_this->linux_side, ulOverlayHandle, pMaskPrimitives, unNumMaskPrimitives, unPrimitiveSize);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_TriggerLaserMouseHapticVibration, 24)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_TriggerLaserMouseHapticVibration(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_TriggerLaserMouseHapticVibration(_this->linux_side, ulOverlayHandle, fDurationSeconds, fFrequency, fAmplitude);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayCursor, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayCursor(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayCursor(_this->linux_side, ulOverlayHandle, ulCursorHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayCursorPositionOverride, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayCursorPositionOverride(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayCursorPositionOverride(_this->linux_side, ulOverlayHandle, pvCursor);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ClearOverlayCursorPositionOverride, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_ClearOverlayCursorPositionOverride(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_ClearOverlayCursorPositionOverride(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTexture, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTexture(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
{
TRACE("%p\n", _this);
return ivroverlay_set_overlay_texture(cppIVROverlay_IVROverlay_025_SetOverlayTexture, _this->linux_side, ulOverlayHandle, pTexture, 25);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ClearOverlayTexture, 12)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_ClearOverlayTexture(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_ClearOverlayTexture(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayRaw, 28)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayRaw(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetOverlayRaw(_this->linux_side, ulOverlayHandle, pvBuffer, unWidth, unHeight, unBytesPerPixel);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayFromFile, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayFromFile(winIVROverlay_IVROverlay_025 *_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_025_SetOverlayFromFile(_this->linux_side, ulOverlayHandle, pchFilePath ? lin_pchFilePath : NULL);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTexture, 44)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTexture(winIVROverlay_IVROverlay_025 *_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_025_GetOverlayTexture(_this->linux_side, ulOverlayHandle, pNativeTextureHandle, pNativeTextureRef, pWidth, pHeight, pNativeFormat, pAPIType, pColorSpace, pTextureBounds);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ReleaseNativeOverlayHandle, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_ReleaseNativeOverlayHandle(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_ReleaseNativeOverlayHandle(_this->linux_side, ulOverlayHandle, pNativeTextureHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTextureSize, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTextureSize(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetOverlayTextureSize(_this->linux_side, ulOverlayHandle, pWidth, pHeight);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_CreateDashboardOverlay, 20)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_CreateDashboardOverlay(winIVROverlay_IVROverlay_025 *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_CreateDashboardOverlay(_this->linux_side, pchOverlayKey, pchOverlayFriendlyName, pMainHandle, pThumbnailHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_IsDashboardVisible, 4)
bool __thiscall winIVROverlay_IVROverlay_025_IsDashboardVisible(winIVROverlay_IVROverlay_025 *_this)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_IsDashboardVisible(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_IsActiveDashboardOverlay, 12)
bool __thiscall winIVROverlay_IVROverlay_025_IsActiveDashboardOverlay(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_IsActiveDashboardOverlay(_this->linux_side, ulOverlayHandle);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetDashboardOverlaySceneProcess, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetDashboardOverlaySceneProcess(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_SetDashboardOverlaySceneProcess(_this->linux_side, ulOverlayHandle, unProcessId);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetDashboardOverlaySceneProcess, 16)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetDashboardOverlaySceneProcess(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetDashboardOverlaySceneProcess(_this->linux_side, ulOverlayHandle, punProcessId);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ShowDashboard, 8)
void __thiscall winIVROverlay_IVROverlay_025_ShowDashboard(winIVROverlay_IVROverlay_025 *_this, const char * pchOverlayToShow)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_025_ShowDashboard(_this->linux_side, pchOverlayToShow);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetPrimaryDashboardDevice, 4)
TrackedDeviceIndex_t __thiscall winIVROverlay_IVROverlay_025_GetPrimaryDashboardDevice(winIVROverlay_IVROverlay_025 *_this)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetPrimaryDashboardDevice(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ShowKeyboard, 36)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_ShowKeyboard(winIVROverlay_IVROverlay_025 *_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_025_ShowKeyboard(_this->linux_side, eInputMode, eLineInputMode, unFlags, pchDescription, unCharMax, pchExistingText, uUserValue);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ShowKeyboardForOverlay, 44)
EVROverlayError __thiscall winIVROverlay_IVROverlay_025_ShowKeyboardForOverlay(winIVROverlay_IVROverlay_025 *_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_025_ShowKeyboardForOverlay(_this->linux_side, ulOverlayHandle, eInputMode, eLineInputMode, unFlags, pchDescription, unCharMax, pchExistingText, uUserValue);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetKeyboardText, 12)
uint32_t __thiscall winIVROverlay_IVROverlay_025_GetKeyboardText(winIVROverlay_IVROverlay_025 *_this, char * pchText, uint32_t cchText)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_025_GetKeyboardText(_this->linux_side, pchText, cchText);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_HideKeyboard, 4)
void __thiscall winIVROverlay_IVROverlay_025_HideKeyboard(winIVROverlay_IVROverlay_025 *_this)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_025_HideKeyboard(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetKeyboardTransformAbsolute, 12)
void __thiscall winIVROverlay_IVROverlay_025_SetKeyboardTransformAbsolute(winIVROverlay_IVROverlay_025 *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_025_SetKeyboardTransformAbsolute(_this->linux_side, eTrackingOrigin, pmatTrackingOriginToKeyboardTransform);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetKeyboardPositionForOverlay, 28)
void __thiscall winIVROverlay_IVROverlay_025_SetKeyboardPositionForOverlay(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_025_SetKeyboardPositionForOverlay(_this->linux_side, ulOverlayHandle, avoidRect);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ShowMessageOverlay, 28)
VRMessageOverlayResponse __thiscall winIVROverlay_IVROverlay_025_ShowMessageOverlay(winIVROverlay_IVROverlay_025 *_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_025_ShowMessageOverlay(_this->linux_side, pchText, pchCaption, pchButton0Text, pchButton1Text, pchButton2Text, pchButton3Text);
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_CloseMessageOverlay, 4)
void __thiscall winIVROverlay_IVROverlay_025_CloseMessageOverlay(winIVROverlay_IVROverlay_025 *_this)
{
TRACE("%p\n", _this);
cppIVROverlay_IVROverlay_025_CloseMessageOverlay(_this->linux_side);
}
extern vtable_ptr winIVROverlay_IVROverlay_025_vtable;
#ifndef __GNUC__
void __asm_dummy_vtables(void) {
#endif
__ASM_VTABLE(winIVROverlay_IVROverlay_025,
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_FindOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_CreateOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_DestroyOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayKey)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayName)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayName)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayImageData)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayErrorNameFromEnum)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayRenderingPid)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayRenderingPid)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayFlag)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayFlag)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayFlags)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayColor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayColor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayAlpha)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayAlpha)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTexelAspect)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTexelAspect)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlaySortOrder)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlaySortOrder)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayWidthInMeters)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayWidthInMeters)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayCurvature)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayCurvature)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTextureColorSpace)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTextureColorSpace)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTextureBounds)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTextureBounds)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTransformType)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTransformAbsolute)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTransformAbsolute)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTransformOverlayRelative)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTransformOverlayRelative)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTransformCursor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTransformCursor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTransformProjection)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ShowOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_HideOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_IsOverlayVisible)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinates)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_PollNextOverlayEvent)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayInputMethod)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayInputMethod)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayMouseScale)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayMouseScale)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ComputeOverlayIntersection)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_IsHoverTargetOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayIntersectionMask)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_TriggerLaserMouseHapticVibration)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayCursor)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayCursorPositionOverride)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ClearOverlayCursorPositionOverride)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTexture)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ClearOverlayTexture)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayRaw)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayFromFile)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTexture)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ReleaseNativeOverlayHandle)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTextureSize)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_CreateDashboardOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_IsDashboardVisible)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_IsActiveDashboardOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetDashboardOverlaySceneProcess)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetDashboardOverlaySceneProcess)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ShowDashboard)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetPrimaryDashboardDevice)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ShowKeyboard)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ShowKeyboardForOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetKeyboardText)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_HideKeyboard)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetKeyboardTransformAbsolute)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetKeyboardPositionForOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ShowMessageOverlay)
VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_CloseMessageOverlay)
);
#ifndef __GNUC__
}
#endif
winIVROverlay_IVROverlay_025 *create_winIVROverlay_IVROverlay_025(void *linux_side)
{
winIVROverlay_IVROverlay_025 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_025));
TRACE("-> %p\n", r);
r->vtable = &winIVROverlay_IVROverlay_025_vtable;
r->linux_side = linux_side;
return r;
}
void destroy_winIVROverlay_IVROverlay_025(void *object)
{
TRACE("%p\n", object);
HeapFree(GetProcessHeap(), 0, object);
}
winIVROverlay_IVROverlay_025 *create_winIVROverlay_IVROverlay_025_FnTable(void *linux_side)
{
winIVROverlay_IVROverlay_025 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_025));
struct thunk *thunks = alloc_thunks(79);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 79 * sizeof(*vtable));
int i;
TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_025_FindOverlay, 2, FALSE, FALSE);
init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_025_CreateOverlay, 3, FALSE, FALSE);
init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_025_DestroyOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_025_GetOverlayKey, 4, FALSE, FALSE);
init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_025_GetOverlayName, 4, FALSE, FALSE);
init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_025_SetOverlayName, 2, FALSE, FALSE);
init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_025_GetOverlayImageData, 5, FALSE, FALSE);
init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_025_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_025_SetOverlayRenderingPid, 2, FALSE, FALSE);
init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_025_GetOverlayRenderingPid, 1, FALSE, FALSE);
init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_025_SetOverlayFlag, 3, FALSE, FALSE);
init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_025_GetOverlayFlag, 3, FALSE, FALSE);
init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_025_GetOverlayFlags, 2, FALSE, FALSE);
init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_025_SetOverlayColor, 4, TRUE, TRUE);
init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_025_GetOverlayColor, 4, FALSE, FALSE);
init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_025_SetOverlayAlpha, 2, TRUE, FALSE);
init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_025_GetOverlayAlpha, 2, FALSE, FALSE);
init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_025_SetOverlayTexelAspect, 2, TRUE, FALSE);
init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_025_GetOverlayTexelAspect, 2, FALSE, FALSE);
init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_025_SetOverlaySortOrder, 2, FALSE, FALSE);
init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_025_GetOverlaySortOrder, 2, FALSE, FALSE);
init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_025_SetOverlayWidthInMeters, 2, TRUE, FALSE);
init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_025_GetOverlayWidthInMeters, 2, FALSE, FALSE);
init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_025_SetOverlayCurvature, 2, TRUE, FALSE);
init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_025_GetOverlayCurvature, 2, FALSE, FALSE);
init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_025_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_025_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_025_SetOverlayTextureBounds, 2, FALSE, FALSE);
init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_025_GetOverlayTextureBounds, 2, FALSE, FALSE);
init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_025_GetOverlayTransformType, 2, FALSE, FALSE);
init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_025_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_025_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_025_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_025_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_025_SetOverlayTransformCursor, 2, FALSE, FALSE);
init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_025_GetOverlayTransformCursor, 2, FALSE, FALSE);
init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_025_SetOverlayTransformProjection, 5, FALSE, FALSE);
init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_025_ShowOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_025_HideOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_025_IsOverlayVisible, 1, FALSE, FALSE);
init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_025_PollNextOverlayEvent, 3, FALSE, FALSE);
init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_025_GetOverlayInputMethod, 2, FALSE, FALSE);
init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_025_SetOverlayInputMethod, 2, FALSE, FALSE);
init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_025_GetOverlayMouseScale, 2, FALSE, FALSE);
init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_025_SetOverlayMouseScale, 2, FALSE, FALSE);
init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_025_ComputeOverlayIntersection, 3, FALSE, FALSE);
init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_025_IsHoverTargetOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_025_SetOverlayIntersectionMask, 4, FALSE, FALSE);
init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_025_TriggerLaserMouseHapticVibration, 4, TRUE, TRUE);
init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_025_SetOverlayCursor, 2, FALSE, FALSE);
init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_025_SetOverlayCursorPositionOverride, 2, FALSE, FALSE);
init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_025_ClearOverlayCursorPositionOverride, 1, FALSE, FALSE);
init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_025_SetOverlayTexture, 2, FALSE, FALSE);
init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_025_ClearOverlayTexture, 1, FALSE, FALSE);
init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_025_SetOverlayRaw, 5, FALSE, FALSE);
init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_025_SetOverlayFromFile, 2, FALSE, FALSE);
init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_025_GetOverlayTexture, 9, FALSE, FALSE);
init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_025_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
init_thunk(&thunks[63], r, winIVROverlay_IVROverlay_025_GetOverlayTextureSize, 3, FALSE, FALSE);
init_thunk(&thunks[64], r, winIVROverlay_IVROverlay_025_CreateDashboardOverlay, 4, FALSE, FALSE);
init_thunk(&thunks[65], r, winIVROverlay_IVROverlay_025_IsDashboardVisible, 0, FALSE, FALSE);
init_thunk(&thunks[66], r, winIVROverlay_IVROverlay_025_IsActiveDashboardOverlay, 1, FALSE, FALSE);
init_thunk(&thunks[67], r, winIVROverlay_IVROverlay_025_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
init_thunk(&thunks[68], r, winIVROverlay_IVROverlay_025_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
init_thunk(&thunks[69], r, winIVROverlay_IVROverlay_025_ShowDashboard, 1, FALSE, FALSE);
init_thunk(&thunks[70], r, winIVROverlay_IVROverlay_025_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
init_thunk(&thunks[71], r, winIVROverlay_IVROverlay_025_ShowKeyboard, 7, FALSE, FALSE);
init_thunk(&thunks[72], r, winIVROverlay_IVROverlay_025_ShowKeyboardForOverlay, 8, FALSE, FALSE);
init_thunk(&thunks[73], r, winIVROverlay_IVROverlay_025_GetKeyboardText, 2, FALSE, FALSE);
init_thunk(&thunks[74], r, winIVROverlay_IVROverlay_025_HideKeyboard, 0, FALSE, FALSE);
init_thunk(&thunks[75], r, winIVROverlay_IVROverlay_025_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
init_thunk(&thunks[76], r, winIVROverlay_IVROverlay_025_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
init_thunk(&thunks[77], r, winIVROverlay_IVROverlay_025_ShowMessageOverlay, 6, FALSE, FALSE);
init_thunk(&thunks[78], r, winIVROverlay_IVROverlay_025_CloseMessageOverlay, 0, FALSE, FALSE);
for (i = 0; i < 79; i++)
vtable[i] = &thunks[i];
r->linux_side = linux_side;
r->vtable = (void *)vtable;
return r;
}
void destroy_winIVROverlay_IVROverlay_025_FnTable(void *object)
{
winIVROverlay_IVROverlay_025 *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_024.h"
typedef struct __winIVROverlay_IVROverlay_024 {

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_11415 ** ppRenderModel)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, winRenderModel_t_1168 ** 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_11415 * pRenderModel)
void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeRenderModel(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_t_1168 * 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_11415 ** ppTexture)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_1168 ** 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_11415 * pTexture)
void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeTexture(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_TextureMap_t_1168 * 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_11415 * pEvent, uint32_t uncbVREvent)
bool __thiscall winIVRSystem_IVRSystem_022_PollNextEvent(winIVRSystem_IVRSystem_022 *_this, winVREvent_t_1168 * 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_11415 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
bool __thiscall winIVRSystem_IVRSystem_022_PollNextEventWithPose(winIVRSystem_IVRSystem_022 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1168 * 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_11415 * pControllerState, uint32_t unControllerStateSize)
bool __thiscall winIVRSystem_IVRSystem_022_GetControllerState(winIVRSystem_IVRSystem_022 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1168 * 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_11415 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
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)
{
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_11415 * 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_1168 * 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_11415 * 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_1168 * 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_11415 * pFrameHeader, uint32_t nFrameHeaderSize)
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)
{
TRACE("%p\n", _this);
return cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(_this->linux_side, hTrackedCamera, eFrameType, pglTextureId, pFrameHeader, nFrameHeaderSize);

12
vrclient_x64/vrclient_x64/win_constructors.h
View File

@ -8,14 +8,14 @@ extern void *create_winIVRChaperone_IVRChaperone_004(void *);
extern void *create_winIVRChaperone_IVRChaperone_004_FnTable(void *);
extern void *create_winIVRChaperoneSetup_IVRChaperoneSetup_006(void *);
extern void *create_winIVRChaperoneSetup_IVRChaperoneSetup_006_FnTable(void *);
extern void *create_winIVRCompositor_IVRCompositor_026(void *);
extern void *create_winIVRCompositor_IVRCompositor_026_FnTable(void *);
extern void *create_winIVRCompositor_IVRCompositor_027(void *);
extern void *create_winIVRCompositor_IVRCompositor_027_FnTable(void *);
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_024(void *);
extern void *create_winIVROverlay_IVROverlay_024_FnTable(void *);
extern void *create_winIVROverlay_IVROverlay_025(void *);
extern void *create_winIVROverlay_IVROverlay_025_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,10 @@ 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_winIVRCompositor_IVRCompositor_026(void *);
extern void *create_winIVRCompositor_IVRCompositor_026_FnTable(void *);
extern void *create_winIVROverlay_IVROverlay_024(void *);
extern void *create_winIVROverlay_IVROverlay_024_FnTable(void *);
extern void *create_winIVRSystem_IVRSystem_021(void *);
extern void *create_winIVRSystem_IVRSystem_021_FnTable(void *);
extern void *create_winIVRChaperone_IVRChaperone_003(void *);

12
vrclient_x64/vrclient_x64/win_constructors_table.dat
View File

@ -8,14 +8,14 @@
{"FnTable:IVRChaperone_004", &create_winIVRChaperone_IVRChaperone_004_FnTable, &destroy_winIVRChaperone_IVRChaperone_004_FnTable},
{"IVRChaperoneSetup_006", &create_winIVRChaperoneSetup_IVRChaperoneSetup_006, &destroy_winIVRChaperoneSetup_IVRChaperoneSetup_006},
{"FnTable:IVRChaperoneSetup_006", &create_winIVRChaperoneSetup_IVRChaperoneSetup_006_FnTable, &destroy_winIVRChaperoneSetup_IVRChaperoneSetup_006_FnTable},
{"IVRCompositor_026", &create_winIVRCompositor_IVRCompositor_026, &destroy_winIVRCompositor_IVRCompositor_026},
{"FnTable:IVRCompositor_026", &create_winIVRCompositor_IVRCompositor_026_FnTable, &destroy_winIVRCompositor_IVRCompositor_026_FnTable},
{"IVRCompositor_027", &create_winIVRCompositor_IVRCompositor_027, &destroy_winIVRCompositor_IVRCompositor_027},
{"FnTable:IVRCompositor_027", &create_winIVRCompositor_IVRCompositor_027_FnTable, &destroy_winIVRCompositor_IVRCompositor_027_FnTable},
{"IVRHeadsetView_001", &create_winIVRHeadsetView_IVRHeadsetView_001, &destroy_winIVRHeadsetView_IVRHeadsetView_001},
{"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_024", &create_winIVROverlay_IVROverlay_024, &destroy_winIVROverlay_IVROverlay_024},
{"FnTable:IVROverlay_024", &create_winIVROverlay_IVROverlay_024_FnTable, &destroy_winIVROverlay_IVROverlay_024_FnTable},
{"IVROverlay_025", &create_winIVROverlay_IVROverlay_025, &destroy_winIVROverlay_IVROverlay_025},
{"FnTable:IVROverlay_025", &create_winIVROverlay_IVROverlay_025_FnTable, &destroy_winIVROverlay_IVROverlay_025_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,10 @@
{"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},
{"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},
{"FnTable:IVROverlay_024", &create_winIVROverlay_IVROverlay_024_FnTable, &destroy_winIVROverlay_IVROverlay_024_FnTable},
{"IVRSystem_021", &create_winIVRSystem_IVRSystem_021, &destroy_winIVRSystem_IVRSystem_021},
{"FnTable:IVRSystem_021", &create_winIVRSystem_IVRSystem_021_FnTable, &destroy_winIVRSystem_IVRSystem_021_FnTable},
{"IVRChaperone_003", &create_winIVRChaperone_IVRChaperone_003, &destroy_winIVRChaperone_IVRChaperone_003},

12
vrclient_x64/vrclient_x64/win_destructors.h
View File

@ -8,14 +8,14 @@ extern void destroy_winIVRChaperone_IVRChaperone_004(void *);
extern void destroy_winIVRChaperone_IVRChaperone_004_FnTable(void *);
extern void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_006(void *);
extern void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_006_FnTable(void *);
extern void destroy_winIVRCompositor_IVRCompositor_026(void *);
extern void destroy_winIVRCompositor_IVRCompositor_026_FnTable(void *);
extern void destroy_winIVRCompositor_IVRCompositor_027(void *);
extern void destroy_winIVRCompositor_IVRCompositor_027_FnTable(void *);
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_024(void *);
extern void destroy_winIVROverlay_IVROverlay_024_FnTable(void *);
extern void destroy_winIVROverlay_IVROverlay_025(void *);
extern void destroy_winIVROverlay_IVROverlay_025_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,10 @@ 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_winIVRCompositor_IVRCompositor_026(void *);
extern void destroy_winIVRCompositor_IVRCompositor_026_FnTable(void *);
extern void destroy_winIVROverlay_IVROverlay_024(void *);
extern void destroy_winIVROverlay_IVROverlay_024_FnTable(void *);
extern void destroy_winIVRSystem_IVRSystem_021(void *);
extern void destroy_winIVRSystem_IVRSystem_021_FnTable(void *);
extern void destroy_winIVRChaperone_IVRChaperone_003(void *);