vrclient: support openvr v1.10.30

vrclient_x64/gen_wrapper.py

@@ -14,6 +14,7 @@ import os
 import re
 
 sdk_versions = [
+    "v1.10.30",
     "v1.9.16",
     "v1.8.19",
     "v1.7.15",
@@ -72,11 +73,13 @@ files = [
         "IVRChaperone",
         "IVRChaperoneSetup",
         "IVRCompositor",
+        "IVRControlPanel",
         "IVRDriverManager",
         "IVRExtendedDisplay",
         "IVRNotifications",
         "IVRInput",
         "IVRIOBuffer",
+        "IVRMailbox",
         "IVROverlay",
         "IVRRenderModels",
         "IVRResources",
@@ -84,6 +87,8 @@ files = [
         "IVRSettings",
         "IVRSystem",
         "IVRTrackedCamera",
+        "IVRHeadsetView",
+        "IVROverlayView",
         ], [ #vrclient-allocated structs
         "RenderModel_t",
         "RenderModel_TextureMap_t",
@@ -186,6 +191,31 @@ path_conversions = [
         "w2l_arrays": [],
         "return_is_size": True
     },
+    {
+        "parent_name": "undoc23",
+        "l2w_names":[],
+        "l2w_lens":[],
+        "w2l_names": ["a"],
+        "w2l_arrays": [False],
+        "return_is_size": False
+    },
+    {
+        "parent_name": "undoc27",
+        "l2w_names":[],
+        "l2w_lens":[],
+        "w2l_names": ["a"],
+        "w2l_arrays": [False],
+        "return_is_size": False
+    },
+    {
+        "parent_name": "SetStageOverride_Async",
+        "l2w_names":[],
+        "l2w_lens":[],
+        "w2l_names": ["pchRenderModelPath"],
+        "w2l_arrays": [False],
+        "return_is_size": False
+    },
+
 #    {#maybe?
 #        "parent_name": "GetRenderModelOriginalPath",
 #        "l2w_names":[pchOriginalPath],
@@ -460,11 +490,13 @@ def handle_method(cfile, classname, winclassname, cppname, method, cpp, cpp_h, e
             cpp.write("    %s lin;\n" % do_lin_to_win[0])
         else:
             cpp.write("    %s lin;\n" % do_win_to_lin[0])
-        cpp.write("    %s _ret;\n" % method.result_type.spelling)
+        if not method.result_type.kind == clang.cindex.TypeKind.VOID:
+            cpp.write("    %s _ret;\n" % method.result_type.spelling)
 
     if do_wrap:
         cpp.write("    %s *lin;\n" % do_wrap[0])
-        cpp.write("    %s _ret;\n" % method.result_type.spelling)
+        if not method.result_type.kind == clang.cindex.TypeKind.VOID:
+            cpp.write("    %s _ret;\n" % method.result_type.spelling)
 
     cfile.write("    TRACE(\"%p\\n\", _this);\n")
 
@@ -582,11 +614,12 @@ def handle_method(cfile, classname, winclassname, cppname, method, cpp, cpp_h, e
         cpp.write("    if(%s)\n" % do_lin_to_win[1])
         cpp.write("        struct_%s_%s_lin_to_win(&lin, %s%s);\n" % (strip_ns(do_lin_to_win[0]), display_sdkver(sdkver), do_lin_to_win[1], convert_size_param))
     if do_lin_to_win or do_win_to_lin:
-        cpp.write("    return _ret;\n")
+        if not method.result_type.kind == clang.cindex.TypeKind.VOID:
-    if do_wrap:
+            cpp.write("    return _ret;\n")
-        cpp.write("    if(_ret == 0)\n")
+    if do_wrap and not method.result_type.kind == clang.cindex.TypeKind.VOID:
-        cpp.write("        *%s = struct_%s_%s_wrap(lin);\n" % (do_wrap[1], strip_ns(do_wrap[0]), display_sdkver(sdkver)))
+            cpp.write("    if(_ret == 0)\n")
-        cpp.write("    return _ret;\n")
+            cpp.write("        *%s = struct_%s_%s_wrap(lin);\n" % (do_wrap[1], strip_ns(do_wrap[0]), display_sdkver(sdkver)))
+            cpp.write("    return _ret;\n")
     cfile.write("}\n\n")
     cpp.write("}\n\n")
 

vrclient_x64/openvr_0.9.0/openvr.h

@@ -951,6 +951,7 @@ static const char * const IVRCompositor_Version = "IVRCompositor_005";
 namespace vr
 {
 
+#if 0
 class IVRControlPanel
 {
 public:
@@ -1028,6 +1029,7 @@ public:
 };
 
 static const char * const IVRControlPanel_Version = "IVRControlPanel_001";
+#endif
 
 }// End
 

vrclient_x64/openvr_0.9.1/openvr.h

@@ -951,6 +951,7 @@ static const char * const IVRCompositor_Version = "IVRCompositor_005";
 namespace vr
 {
 
+#if 0
 class IVRControlPanel
 {
 public:
@@ -1029,6 +1030,7 @@ public:
 
 static const char * const IVRControlPanel_Version = "IVRControlPanel_001";
 
+#endif
 }// End
 
 #endif // _OPENVR_API

vrclient_x64/openvr_0.9.2/openvr.h

@@ -1251,6 +1251,7 @@ static const char * const IVRRenderModels_Version = "IVRRenderModels_001";
 namespace vr
 {
 
+#if 0
 class IVRControlPanel
 {
 public:
@@ -1328,6 +1329,7 @@ public:
 };
 
 static const char * const IVRControlPanel_Version = "IVRControlPanel_001";
+#endif
 
 }// End
 

vrclient_x64/openvr_0.9.3/openvr.h

@@ -1295,6 +1295,8 @@ static const char * const IVRRenderModels_Version = "IVRRenderModels_001";
 namespace vr
 {
 
+    class IVRControlPanel;
+#if 0
 class IVRControlPanel
 {
 public:
@@ -1381,6 +1383,7 @@ public:
 };
 
 static const char * const IVRControlPanel_Version = "IVRControlPanel_001";
+#endif
 
 }// End
 

vrclient_x64/openvr_v0.9.10/openvr.h

@@ -1938,6 +1938,8 @@ static const char * const IVRRenderModels_Version = "IVRRenderModels_001";
 namespace vr
 {
 
+    class IVRControlPanel;
+#if 0
 class IVRControlPanel
 {
 public:
@@ -2032,6 +2034,7 @@ public:
 };
 
 static const char * const IVRControlPanel_Version = "IVRControlPanel_001";
+#endif
 
 }// End
 

vrclient_x64/openvr_v0.9.11/openvr.h

@@ -2142,6 +2142,8 @@ static const char * const IVRRenderModels_Version = "IVRRenderModels_001";
 namespace vr
 {
 
+    class IVRControlPanel;
+#if 0
 class IVRControlPanel
 {
 public:
@@ -2236,6 +2238,7 @@ public:
 };
 
 static const char * const IVRControlPanel_Version = "IVRControlPanel_001";
+#endif
 
 }
 // ivrtrackedcamera.h

vrclient_x64/openvr_v0.9.12/openvr.h

@@ -2280,6 +2280,8 @@ static const char * const IVRRenderModels_Version = "IVRRenderModels_002";
 namespace vr
 {
 
+    class IVRControlPanel;
+#if 0
 class IVRControlPanel
 {
 public:
@@ -2383,6 +2385,7 @@ public:
 };
 
 static const char * const IVRControlPanel_Version = "IVRControlPanel_001";
+#endif
 
 }
 // ivrtrackedcamera.h

vrclient_x64/openvr_v0.9.4/openvr.h

@@ -1295,6 +1295,8 @@ static const char * const IVRRenderModels_Version = "IVRRenderModels_001";
 namespace vr
 {
 
+    class IVRControlPanel;
+#if 0
 class IVRControlPanel
 {
 public:
@@ -1381,6 +1383,7 @@ public:
 };
 
 static const char * const IVRControlPanel_Version = "IVRControlPanel_001";
+#endif
 
 }// End
 

vrclient_x64/openvr_v0.9.5/openvr.h

@@ -1407,6 +1407,8 @@ static const char * const IVRRenderModels_Version = "IVRRenderModels_001";
 namespace vr
 {
 
+    class IVRControlPanel;
+#if 0
 class IVRControlPanel
 {
 public:
@@ -1493,6 +1495,7 @@ public:
 };
 
 static const char * const IVRControlPanel_Version = "IVRControlPanel_001";
+#endif
 
 }// End
 

vrclient_x64/openvr_v0.9.6/openvr.h

@@ -1407,6 +1407,8 @@ static const char * const IVRRenderModels_Version = "IVRRenderModels_001";
 namespace vr
 {
 
+    class IVRControlPanel;
+#if 0
 class IVRControlPanel
 {
 public:
@@ -1493,6 +1495,7 @@ public:
 };
 
 static const char * const IVRControlPanel_Version = "IVRControlPanel_001";
+#endif
 
 }// End
 

vrclient_x64/openvr_v0.9.7/openvr.h

@@ -1437,6 +1437,8 @@ static const char * const IVRRenderModels_Version = "IVRRenderModels_001";
 namespace vr
 {
 
+    class IVRControlPanel;
+#if 0
 class IVRControlPanel
 {
 public:
@@ -1531,6 +1533,7 @@ public:
 };
 
 static const char * const IVRControlPanel_Version = "IVRControlPanel_001";
+#endif
 
 }// End
 

vrclient_x64/openvr_v0.9.8/openvr.h

@@ -1581,6 +1581,8 @@ static const char * const IVRRenderModels_Version = "IVRRenderModels_001";
 namespace vr
 {
 
+    class IVRControlPanel;
+#if 0
 class IVRControlPanel
 {
 public:
@@ -1675,6 +1677,7 @@ public:
 };
 
 static const char * const IVRControlPanel_Version = "IVRControlPanel_001";
+#endif
 
 }// End
 

vrclient_x64/openvr_v0.9.9/openvr.h

@@ -1804,6 +1804,8 @@ static const char * const IVRRenderModels_Version = "IVRRenderModels_001";
 namespace vr
 {
 
+    class IVRControlPanel;
+#if 0
 class IVRControlPanel
 {
 public:
@@ -1898,6 +1900,7 @@ public:
 };
 
 static const char * const IVRControlPanel_Version = "IVRControlPanel_001";
+#endif
 
 }// End
 

vrclient_x64/openvr_v1.10.30/ivrclientcore.h

@@ -0,0 +1,36 @@
+//========= 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";
+
+
+}

vrclient_x64/tests/capi_thunks_autogen.h

@@ -253,6 +253,578 @@ void __thiscall IVRChaperoneSetup_006_HideWorkingSetPreview(void *_this);
 
 void __thiscall IVRChaperoneSetup_006_RoomSetupStarting(void *_this);
 
+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_IVRHeadsetView_001(void);
+
+void __thiscall IVRHeadsetView_001_SetHeadsetViewSize(void *_this, uint32_t nWidth, uint32_t nHeight);
+
+void __thiscall IVRHeadsetView_001_GetHeadsetViewSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRHeadsetView_001_SetHeadsetViewMode(void *_this, HeadsetViewMode_t eHeadsetViewMode);
+
+HeadsetViewMode_t __thiscall IVRHeadsetView_001_GetHeadsetViewMode(void *_this);
+
+void __thiscall IVRHeadsetView_001_SetHeadsetViewCropped(void *_this, bool bCropped);
+
+bool __thiscall IVRHeadsetView_001_GetHeadsetViewCropped(void *_this);
+
+float __thiscall IVRHeadsetView_001_GetHeadsetViewAspectRatio(void *_this);
+
+void __thiscall IVRHeadsetView_001_SetHeadsetViewBlendRange(void *_this, float flStartPct, float flEndPct);
+
+void __thiscall IVRHeadsetView_001_GetHeadsetViewBlendRange(void *_this, float * pStartPct, float * pEndPct);
+
+void test_capi_thunks_IVRNotifications_002(void);
+
+EVRNotificationError __thiscall IVRNotifications_002_CreateNotification(void *_this, VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char * pchText, EVRNotificationStyle style, NotificationBitmap_t * pImage, VRNotificationId * pNotificationId);
+
+EVRNotificationError __thiscall IVRNotifications_002_RemoveNotification(void *_this, VRNotificationId notificationId);
+
+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_IVROverlayView_003(void);
+
+EVROverlayError __thiscall IVROverlayView_003_AcquireOverlayView(void *_this, VROverlayHandle_t ulOverlayHandle, VRNativeDevice_t * pNativeDevice, VROverlayView_t * pOverlayView, uint32_t unOverlayViewSize);
+
+EVROverlayError __thiscall IVROverlayView_003_ReleaseOverlayView(void *_this, VROverlayView_t * pOverlayView);
+
+void __thiscall IVROverlayView_003_PostOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pvrEvent);
+
+bool __thiscall IVROverlayView_003_IsViewingPermitted(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+void test_capi_thunks_IVRRenderModels_006(void);
+
+EVRRenderModelError __thiscall IVRRenderModels_006_LoadRenderModel_Async(void *_this, const char * pchRenderModelName, RenderModel_t ** ppRenderModel);
+
+void __thiscall IVRRenderModels_006_FreeRenderModel(void *_this, RenderModel_t * pRenderModel);
+
+EVRRenderModelError __thiscall IVRRenderModels_006_LoadTexture_Async(void *_this, TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture);
+
+void __thiscall IVRRenderModels_006_FreeTexture(void *_this, RenderModel_TextureMap_t * pTexture);
+
+EVRRenderModelError __thiscall IVRRenderModels_006_LoadTextureD3D11_Async(void *_this, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D);
+
+EVRRenderModelError __thiscall IVRRenderModels_006_LoadIntoTextureD3D11_Async(void *_this, TextureID_t textureId, void * pDstTexture);
+
+void __thiscall IVRRenderModels_006_FreeTextureD3D11(void *_this, void * pD3D11Texture2D);
+
+uint32_t __thiscall IVRRenderModels_006_GetRenderModelName(void *_this, uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen);
+
+uint32_t __thiscall IVRRenderModels_006_GetRenderModelCount(void *_this);
+
+uint32_t __thiscall IVRRenderModels_006_GetComponentCount(void *_this, const char * pchRenderModelName);
+
+uint32_t __thiscall IVRRenderModels_006_GetComponentName(void *_this, const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen);
+
+uint64_t __thiscall IVRRenderModels_006_GetComponentButtonMask(void *_this, const char * pchRenderModelName, const char * pchComponentName);
+
+uint32_t __thiscall IVRRenderModels_006_GetComponentRenderModelName(void *_this, const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen);
+
+bool __thiscall IVRRenderModels_006_GetComponentStateForDevicePath(void *_this, const char * pchRenderModelName, const char * pchComponentName, VRInputValueHandle_t devicePath, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState);
+
+bool __thiscall IVRRenderModels_006_GetComponentState(void *_this, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState);
+
+bool __thiscall IVRRenderModels_006_RenderModelHasComponent(void *_this, const char * pchRenderModelName, const char * pchComponentName);
+
+uint32_t __thiscall IVRRenderModels_006_GetRenderModelThumbnailURL(void *_this, const char * pchRenderModelName, char * pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError * peError);
+
+uint32_t __thiscall IVRRenderModels_006_GetRenderModelOriginalPath(void *_this, const char * pchRenderModelName, char * pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError * peError);
+
+const char * __thiscall IVRRenderModels_006_GetRenderModelErrorNameFromEnum(void *_this, EVRRenderModelError error);
+
+void test_capi_thunks_IVRExtendedDisplay_001(void);
+
+void __thiscall IVRExtendedDisplay_001_GetWindowBounds(void *_this, int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRExtendedDisplay_001_GetEyeOutputViewport(void *_this, EVREye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRExtendedDisplay_001_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex);
+
+void test_capi_thunks_IVRTrackedCamera_006(void);
+
+const char * __thiscall IVRTrackedCamera_006_GetCameraErrorNameFromEnum(void *_this, EVRTrackedCameraError eCameraError);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_006_HasCamera(void *_this, TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_006_GetCameraFrameSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_006_GetCameraIntrinsics(void *_this, TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_006_GetCameraProjection(void *_this, TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_006_AcquireVideoStreamingService(void *_this, TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_006_ReleaseVideoStreamingService(void *_this, TrackedCameraHandle_t hTrackedCamera);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_006_GetVideoStreamTextureSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_006_GetVideoStreamTextureGL(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_006_ReleaseVideoStreamTextureGL(void *_this, TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId);
+
+void __thiscall IVRTrackedCamera_006_SetCameraTrackingSpace(void *_this, ETrackingUniverseOrigin eUniverse);
+
+ETrackingUniverseOrigin __thiscall IVRTrackedCamera_006_GetCameraTrackingSpace(void *_this);
+
+void test_capi_thunks_IVRScreenshots_001(void);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_RequestScreenshot(void *_this, ScreenshotHandle_t * pOutScreenshotHandle, EVRScreenshotType type, const char * pchPreviewFilename, const char * pchVRFilename);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_HookScreenshot(void *_this, EVRScreenshotType * pSupportedTypes, int numTypes);
+
+EVRScreenshotType __thiscall IVRScreenshots_001_GetScreenshotPropertyType(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotError * pError);
+
+uint32_t __thiscall IVRScreenshots_001_GetScreenshotPropertyFilename(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotPropertyFilenames filenameType, char * pchFilename, uint32_t cchFilename, EVRScreenshotError * pError);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_UpdateScreenshotProgress(void *_this, ScreenshotHandle_t screenshotHandle, float flProgress);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_TakeStereoScreenshot(void *_this, ScreenshotHandle_t * pOutScreenshotHandle, const char * pchPreviewFilename, const char * pchVRFilename);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_SubmitScreenshot(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotType type, const char * pchSourcePreviewFilename, const char * pchSourceVRFilename);
+
+void test_capi_thunks_IVRResources_001(void);
+
+uint32_t __thiscall IVRResources_001_LoadSharedResource(void *_this, const char * pchResourceName, char * pchBuffer, uint32_t unBufferLen);
+
+uint32_t __thiscall IVRResources_001_GetResourceFullPath(void *_this, const char * pchResourceName, const char * pchResourceTypeDirectory, char * pchPathBuffer, uint32_t unBufferLen);
+
+void test_capi_thunks_IVRDriverManager_001(void);
+
+uint32_t __thiscall IVRDriverManager_001_GetDriverCount(void *_this);
+
+uint32_t __thiscall IVRDriverManager_001_GetDriverName(void *_this, DriverId_t nDriver, char * pchValue, uint32_t unBufferSize);
+
+DriverHandle_t __thiscall IVRDriverManager_001_GetDriverHandle(void *_this, const char * pchDriverName);
+
+bool __thiscall IVRDriverManager_001_IsEnabled(void *_this, DriverId_t nDriver);
+
+void test_capi_thunks_IVRInput_010(void);
+
+EVRInputError __thiscall IVRInput_010_SetActionManifestPath(void *_this, const char * pchActionManifestPath);
+
+EVRInputError __thiscall IVRInput_010_GetActionSetHandle(void *_this, const char * pchActionSetName, VRActionSetHandle_t * pHandle);
+
+EVRInputError __thiscall IVRInput_010_GetActionHandle(void *_this, const char * pchActionName, VRActionHandle_t * pHandle);
+
+EVRInputError __thiscall IVRInput_010_GetInputSourceHandle(void *_this, const char * pchInputSourcePath, VRInputValueHandle_t * pHandle);
+
+EVRInputError __thiscall IVRInput_010_UpdateActionState(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount);
+
+EVRInputError __thiscall IVRInput_010_GetDigitalActionData(void *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+
+EVRInputError __thiscall IVRInput_010_GetAnalogActionData(void *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+
+EVRInputError __thiscall IVRInput_010_GetPoseActionDataRelativeToNow(void *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+
+EVRInputError __thiscall IVRInput_010_GetPoseActionDataForNextFrame(void *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+
+EVRInputError __thiscall IVRInput_010_GetSkeletalActionData(void *_this, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize);
+
+EVRInputError __thiscall IVRInput_010_GetDominantHand(void *_this, ETrackedControllerRole * peDominantHand);
+
+EVRInputError __thiscall IVRInput_010_SetDominantHand(void *_this, ETrackedControllerRole eDominantHand);
+
+EVRInputError __thiscall IVRInput_010_GetBoneCount(void *_this, VRActionHandle_t action, uint32_t * pBoneCount);
+
+EVRInputError __thiscall IVRInput_010_GetBoneHierarchy(void *_this, VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount);
+
+EVRInputError __thiscall IVRInput_010_GetBoneName(void *_this, VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize);
+
+EVRInputError __thiscall IVRInput_010_GetSkeletalReferenceTransforms(void *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
+
+EVRInputError __thiscall IVRInput_010_GetSkeletalTrackingLevel(void *_this, VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel);
+
+EVRInputError __thiscall IVRInput_010_GetSkeletalBoneData(void *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
+
+EVRInputError __thiscall IVRInput_010_GetSkeletalSummaryData(void *_this, VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData);
+
+EVRInputError __thiscall IVRInput_010_GetSkeletalBoneDataCompressed(void *_this, VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize);
+
+EVRInputError __thiscall IVRInput_010_DecompressSkeletalBoneData(void *_this, const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
+
+EVRInputError __thiscall IVRInput_010_TriggerHapticVibrationAction(void *_this, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice);
+
+EVRInputError __thiscall IVRInput_010_GetActionOrigins(void *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount);
+
+EVRInputError __thiscall IVRInput_010_GetOriginLocalizedName(void *_this, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude);
+
+EVRInputError __thiscall IVRInput_010_GetOriginTrackedDeviceInfo(void *_this, VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize);
+
+EVRInputError __thiscall IVRInput_010_GetActionBindingInfo(void *_this, VRActionHandle_t action, InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t * punReturnedBindingInfoCount);
+
+EVRInputError __thiscall IVRInput_010_ShowActionOrigins(void *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle);
+
+EVRInputError __thiscall IVRInput_010_ShowBindingsForActionSet(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight);
+
+EVRInputError __thiscall IVRInput_010_GetComponentStateForBinding(void *_this, const char * pchRenderModelName, const char * pchComponentName, InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, RenderModel_ComponentState_t * pComponentState);
+
+bool __thiscall IVRInput_010_IsUsingLegacyInput(void *_this);
+
+EVRInputError __thiscall IVRInput_010_OpenBindingUI(void *_this, const char * pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop);
+
+EVRInputError __thiscall IVRInput_010_GetBindingVariant(void *_this, VRInputValueHandle_t ulDevicePath, char * pchVariantArray, uint32_t unVariantArraySize);
+
+void test_capi_thunks_IVRIOBuffer_002(void);
+
+EIOBufferError __thiscall IVRIOBuffer_002_Open(void *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer);
+
+EIOBufferError __thiscall IVRIOBuffer_002_Close(void *_this, IOBufferHandle_t ulBuffer);
+
+EIOBufferError __thiscall IVRIOBuffer_002_Read(void *_this, IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead);
+
+EIOBufferError __thiscall IVRIOBuffer_002_Write(void *_this, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes);
+
+PropertyContainerHandle_t __thiscall IVRIOBuffer_002_PropertyContainer(void *_this, IOBufferHandle_t ulBuffer);
+
+bool __thiscall IVRIOBuffer_002_HasReaders(void *_this, IOBufferHandle_t ulBuffer);
+
+void test_capi_thunks_IVRControlPanel_006(void);
+
+uint32_t __thiscall IVRControlPanel_006_undoc1(void *_this);
+
+uint32_t __thiscall IVRControlPanel_006_undoc2(void *_this, uint32_t a, char * b, uint32_t c);
+
+EVRInitError __thiscall IVRControlPanel_006_undoc3(void *_this, const char * a);
+
+uint32_t __thiscall IVRControlPanel_006_undoc4(void *_this, const char * a);
+
+uint32_t __thiscall IVRControlPanel_006_undoc5(void *_this, const char * a, uint32_t b, char * c, uint32_t d);
+
+uint32_t __thiscall IVRControlPanel_006_undoc6(void *_this, const char * a, const char * b, char * c, uint32_t d);
+
+uint32_t __thiscall IVRControlPanel_006_undoc7(void *_this, const char * a, const char * b, char * c, uint32_t d);
+
+bool __thiscall IVRControlPanel_006_undoc8(void *_this, uint32_t a);
+
+void __thiscall IVRControlPanel_006_undoc9(void *_this);
+
+void __thiscall IVRControlPanel_006_undoc10(void *_this);
+
+bool __thiscall IVRControlPanel_006_undoc11(void *_this, uint32_t a);
+
+void __thiscall IVRControlPanel_006_undoc12(void *_this);
+
+void __thiscall IVRControlPanel_006_undoc13(void *_this, TrackedDeviceIndex_t a);
+
+void __thiscall IVRControlPanel_006_undoc14(void *_this, EVRState a);
+
+EVRState __thiscall IVRControlPanel_006_undoc15(void *_this);
+
+void __thiscall IVRControlPanel_006_undoc16(void *_this, bool a);
+
+bool __thiscall IVRControlPanel_006_undoc17(void *_this);
+
+EVRApplicationError __thiscall IVRControlPanel_006_undoc18(void *_this);
+
+void __thiscall IVRControlPanel_006_undoc19(void *_this, bool a);
+
+bool __thiscall IVRControlPanel_006_undoc20(void *_this);
+
+EVRInitError __thiscall IVRControlPanel_006_undoc21(void *_this);
+
+void __thiscall IVRControlPanel_006_undoc22(void *_this, WebConsoleHandle_t a, const char * b, uint32_t c, uint32_t d, const char * e);
+
+bool __thiscall IVRControlPanel_006_undoc23(void *_this, const char * a);
+
+bool __thiscall IVRControlPanel_006_undoc24(void *_this);
+
+bool __thiscall IVRControlPanel_006_undoc25(void *_this, bool a);
+
+uint64_t __thiscall IVRControlPanel_006_undoc26(void *_this);
+
+EVRCompositorError __thiscall IVRControlPanel_006_undoc27(void *_this, const char * a);
+
+void __thiscall IVRControlPanel_006_undoc28(void *_this, VROverlayHandle_t a);
+
+void test_capi_thunks_IVRMailbox_001(void);
+
+vrmb_typeb __thiscall IVRMailbox_001_undoc1(void *_this, const char * a, vrmb_typea * b);
+
+vrmb_typeb __thiscall IVRMailbox_001_undoc2(void *_this, vrmb_typea a);
+
+vrmb_typeb __thiscall IVRMailbox_001_undoc3(void *_this, vrmb_typea a, const char * b, const char * c);
+
+vrmb_typeb __thiscall IVRMailbox_001_undoc4(void *_this, vrmb_typea a, char * b, uint32_t c, uint32_t * d);
+
+void test_capi_thunks_IVRClientCore_003(void);
+
+EVRInitError __thiscall IVRClientCore_003_Init(void *_this, EVRApplicationType eApplicationType, const char * pStartupInfo);
+
+void __thiscall IVRClientCore_003_Cleanup(void *_this);
+
+EVRInitError __thiscall IVRClientCore_003_IsInterfaceVersionValid(void *_this, const char * pchInterfaceVersion);
+
+void * __thiscall IVRClientCore_003_GetGenericInterface(void *_this, const char * pchNameAndVersion, EVRInitError * peError);
+
+bool __thiscall IVRClientCore_003_BIsHmdPresent(void *_this);
+
+const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_this, EVRInitError eError);
+
+const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError);
+
 void test_capi_thunks_IVRCompositor_024(void);
 
 void __thiscall IVRCompositor_024_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
@@ -351,12 +923,6 @@ EVRCompositorError __thiscall IVRCompositor_024_SetStageOverride_Async(void *_th
 
 void __thiscall IVRCompositor_024_ClearStageOverride(void *_this);
 
-void test_capi_thunks_IVRNotifications_002(void);
-
-EVRNotificationError __thiscall IVRNotifications_002_CreateNotification(void *_this, VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char * pchText, EVRNotificationStyle style, NotificationBitmap_t * pImage, VRNotificationId * pNotificationId);
-
-EVRNotificationError __thiscall IVRNotifications_002_RemoveNotification(void *_this, VRNotificationId notificationId);
-
 void test_capi_thunks_IVROverlay_022(void);
 
 EVROverlayError __thiscall IVROverlay_022_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
@@ -523,116 +1089,6 @@ VRMessageOverlayResponse __thiscall IVROverlay_022_ShowMessageOverlay(void *_thi
 
 void __thiscall IVROverlay_022_CloseMessageOverlay(void *_this);
 
-void test_capi_thunks_IVRRenderModels_006(void);
-
-EVRRenderModelError __thiscall IVRRenderModels_006_LoadRenderModel_Async(void *_this, const char * pchRenderModelName, RenderModel_t ** ppRenderModel);
-
-void __thiscall IVRRenderModels_006_FreeRenderModel(void *_this, RenderModel_t * pRenderModel);
-
-EVRRenderModelError __thiscall IVRRenderModels_006_LoadTexture_Async(void *_this, TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture);
-
-void __thiscall IVRRenderModels_006_FreeTexture(void *_this, RenderModel_TextureMap_t * pTexture);
-
-EVRRenderModelError __thiscall IVRRenderModels_006_LoadTextureD3D11_Async(void *_this, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D);
-
-EVRRenderModelError __thiscall IVRRenderModels_006_LoadIntoTextureD3D11_Async(void *_this, TextureID_t textureId, void * pDstTexture);
-
-void __thiscall IVRRenderModels_006_FreeTextureD3D11(void *_this, void * pD3D11Texture2D);
-
-uint32_t __thiscall IVRRenderModels_006_GetRenderModelName(void *_this, uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen);
-
-uint32_t __thiscall IVRRenderModels_006_GetRenderModelCount(void *_this);
-
-uint32_t __thiscall IVRRenderModels_006_GetComponentCount(void *_this, const char * pchRenderModelName);
-
-uint32_t __thiscall IVRRenderModels_006_GetComponentName(void *_this, const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen);
-
-uint64_t __thiscall IVRRenderModels_006_GetComponentButtonMask(void *_this, const char * pchRenderModelName, const char * pchComponentName);
-
-uint32_t __thiscall IVRRenderModels_006_GetComponentRenderModelName(void *_this, const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen);
-
-bool __thiscall IVRRenderModels_006_GetComponentStateForDevicePath(void *_this, const char * pchRenderModelName, const char * pchComponentName, VRInputValueHandle_t devicePath, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState);
-
-bool __thiscall IVRRenderModels_006_GetComponentState(void *_this, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState);
-
-bool __thiscall IVRRenderModels_006_RenderModelHasComponent(void *_this, const char * pchRenderModelName, const char * pchComponentName);
-
-uint32_t __thiscall IVRRenderModels_006_GetRenderModelThumbnailURL(void *_this, const char * pchRenderModelName, char * pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError * peError);
-
-uint32_t __thiscall IVRRenderModels_006_GetRenderModelOriginalPath(void *_this, const char * pchRenderModelName, char * pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError * peError);
-
-const char * __thiscall IVRRenderModels_006_GetRenderModelErrorNameFromEnum(void *_this, EVRRenderModelError error);
-
-void test_capi_thunks_IVRExtendedDisplay_001(void);
-
-void __thiscall IVRExtendedDisplay_001_GetWindowBounds(void *_this, int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
-
-void __thiscall IVRExtendedDisplay_001_GetEyeOutputViewport(void *_this, EVREye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
-
-void __thiscall IVRExtendedDisplay_001_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex);
-
-void test_capi_thunks_IVRTrackedCamera_006(void);
-
-const char * __thiscall IVRTrackedCamera_006_GetCameraErrorNameFromEnum(void *_this, EVRTrackedCameraError eCameraError);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_006_HasCamera(void *_this, TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_006_GetCameraFrameSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_006_GetCameraIntrinsics(void *_this, TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_006_GetCameraProjection(void *_this, TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_006_AcquireVideoStreamingService(void *_this, TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_006_ReleaseVideoStreamingService(void *_this, TrackedCameraHandle_t hTrackedCamera);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_006_GetVideoStreamTextureSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_006_GetVideoStreamTextureGL(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_006_ReleaseVideoStreamTextureGL(void *_this, TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId);
-
-void __thiscall IVRTrackedCamera_006_SetCameraTrackingSpace(void *_this, ETrackingUniverseOrigin eUniverse);
-
-ETrackingUniverseOrigin __thiscall IVRTrackedCamera_006_GetCameraTrackingSpace(void *_this);
-
-void test_capi_thunks_IVRScreenshots_001(void);
-
-EVRScreenshotError __thiscall IVRScreenshots_001_RequestScreenshot(void *_this, ScreenshotHandle_t * pOutScreenshotHandle, EVRScreenshotType type, const char * pchPreviewFilename, const char * pchVRFilename);
-
-EVRScreenshotError __thiscall IVRScreenshots_001_HookScreenshot(void *_this, EVRScreenshotType * pSupportedTypes, int numTypes);
-
-EVRScreenshotType __thiscall IVRScreenshots_001_GetScreenshotPropertyType(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotError * pError);
-
-uint32_t __thiscall IVRScreenshots_001_GetScreenshotPropertyFilename(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotPropertyFilenames filenameType, char * pchFilename, uint32_t cchFilename, EVRScreenshotError * pError);
-
-EVRScreenshotError __thiscall IVRScreenshots_001_UpdateScreenshotProgress(void *_this, ScreenshotHandle_t screenshotHandle, float flProgress);
-
-EVRScreenshotError __thiscall IVRScreenshots_001_TakeStereoScreenshot(void *_this, ScreenshotHandle_t * pOutScreenshotHandle, const char * pchPreviewFilename, const char * pchVRFilename);
-
-EVRScreenshotError __thiscall IVRScreenshots_001_SubmitScreenshot(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotType type, const char * pchSourcePreviewFilename, const char * pchSourceVRFilename);
-
-void test_capi_thunks_IVRResources_001(void);
-
-uint32_t __thiscall IVRResources_001_LoadSharedResource(void *_this, const char * pchResourceName, char * pchBuffer, uint32_t unBufferLen);
-
-uint32_t __thiscall IVRResources_001_GetResourceFullPath(void *_this, const char * pchResourceName, const char * pchResourceTypeDirectory, char * pchPathBuffer, uint32_t unBufferLen);
-
-void test_capi_thunks_IVRDriverManager_001(void);
-
-uint32_t __thiscall IVRDriverManager_001_GetDriverCount(void *_this);
-
-uint32_t __thiscall IVRDriverManager_001_GetDriverName(void *_this, DriverId_t nDriver, char * pchValue, uint32_t unBufferSize);
-
-DriverHandle_t __thiscall IVRDriverManager_001_GetDriverHandle(void *_this, const char * pchDriverName);
-
-bool __thiscall IVRDriverManager_001_IsEnabled(void *_this, DriverId_t nDriver);
-
 void test_capi_thunks_IVRInput_007(void);
 
 EVRInputError __thiscall IVRInput_007_SetActionManifestPath(void *_this, const char * pchActionManifestPath);
@@ -691,36 +1147,6 @@ bool __thiscall IVRInput_007_IsUsingLegacyInput(void *_this);
 
 EVRInputError __thiscall IVRInput_007_OpenBindingUI(void *_this, const char * pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop);
 
-void test_capi_thunks_IVRIOBuffer_002(void);
-
-EIOBufferError __thiscall IVRIOBuffer_002_Open(void *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer);
-
-EIOBufferError __thiscall IVRIOBuffer_002_Close(void *_this, IOBufferHandle_t ulBuffer);
-
-EIOBufferError __thiscall IVRIOBuffer_002_Read(void *_this, IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead);
-
-EIOBufferError __thiscall IVRIOBuffer_002_Write(void *_this, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes);
-
-PropertyContainerHandle_t __thiscall IVRIOBuffer_002_PropertyContainer(void *_this, IOBufferHandle_t ulBuffer);
-
-bool __thiscall IVRIOBuffer_002_HasReaders(void *_this, IOBufferHandle_t ulBuffer);
-
-void test_capi_thunks_IVRClientCore_003(void);
-
-EVRInitError __thiscall IVRClientCore_003_Init(void *_this, EVRApplicationType eApplicationType, const char * pStartupInfo);
-
-void __thiscall IVRClientCore_003_Cleanup(void *_this);
-
-EVRInitError __thiscall IVRClientCore_003_IsInterfaceVersionValid(void *_this, const char * pchInterfaceVersion);
-
-void * __thiscall IVRClientCore_003_GetGenericInterface(void *_this, const char * pchNameAndVersion, EVRInitError * peError);
-
-bool __thiscall IVRClientCore_003_BIsHmdPresent(void *_this);
-
-const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_this, EVRInitError eError);
-
-const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError);
-
 void test_capi_thunks_IVRSettings_002(void);
 
 const char * __thiscall IVRSettings_002_GetSettingsErrorNameFromEnum(void *_this, EVRSettingsError eError);

vrclient_x64/tests/main_autogen.c

@@ -10,18 +10,25 @@ int main(void)
     test_capi_thunks_IVRSettings_003();
     test_capi_thunks_IVRChaperone_003();
     test_capi_thunks_IVRChaperoneSetup_006();
-    test_capi_thunks_IVRCompositor_024();
+    test_capi_thunks_IVRCompositor_026();
+    test_capi_thunks_IVRHeadsetView_001();
     test_capi_thunks_IVRNotifications_002();
-    test_capi_thunks_IVROverlay_022();
+    test_capi_thunks_IVROverlay_024();
+    test_capi_thunks_IVROverlayView_003();
     test_capi_thunks_IVRRenderModels_006();
     test_capi_thunks_IVRExtendedDisplay_001();
     test_capi_thunks_IVRTrackedCamera_006();
     test_capi_thunks_IVRScreenshots_001();
     test_capi_thunks_IVRResources_001();
     test_capi_thunks_IVRDriverManager_001();
-    test_capi_thunks_IVRInput_007();
+    test_capi_thunks_IVRInput_010();
     test_capi_thunks_IVRIOBuffer_002();
+    test_capi_thunks_IVRControlPanel_006();
+    test_capi_thunks_IVRMailbox_001();
     test_capi_thunks_IVRClientCore_003();
+    test_capi_thunks_IVRCompositor_024();
+    test_capi_thunks_IVROverlay_022();
+    test_capi_thunks_IVRInput_007();
     test_capi_thunks_IVRSettings_002();
     test_capi_thunks_IVRCompositor_022();
     test_capi_thunks_IVROverlay_021();

vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_007.cpp

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

vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.cpp

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

vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_003.cpp

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

vrclient_x64/vrclient_x64/cppIVRClientCore_IVRClientCore_003.cpp

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

vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_026.cpp

@@ -0,0 +1,269 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.10.30/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRCompositor_IVRCompositor_026.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+void cppIVRCompositor_IVRCompositor_026_SetTrackingSpace(void *linux_side, ETrackingUniverseOrigin eOrigin)
+{
+    ((IVRCompositor*)linux_side)->SetTrackingSpace((vr::ETrackingUniverseOrigin)eOrigin);
+}
+
+vr::ETrackingUniverseOrigin cppIVRCompositor_IVRCompositor_026_GetTrackingSpace(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->GetTrackingSpace();
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_026_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_026_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_026_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_026_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_026_ClearLastSubmittedFrame(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->ClearLastSubmittedFrame();
+}
+
+void cppIVRCompositor_IVRCompositor_026_PostPresentHandoff(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->PostPresentHandoff();
+}
+
+bool cppIVRCompositor_IVRCompositor_026_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_026_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_026_GetFrameTimeRemaining(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->GetFrameTimeRemaining();
+}
+
+void cppIVRCompositor_IVRCompositor_026_GetCumulativeStats(void *linux_side, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    ((IVRCompositor*)linux_side)->GetCumulativeStats((vr::Compositor_CumulativeStats *)pStats, (uint32_t)nStatsSizeInBytes);
+}
+
+void cppIVRCompositor_IVRCompositor_026_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_026_GetCurrentFadeColor(void *linux_side, bool bBackground)
+{
+    return ((IVRCompositor*)linux_side)->GetCurrentFadeColor((bool)bBackground);
+}
+
+void cppIVRCompositor_IVRCompositor_026_FadeGrid(void *linux_side, float fSeconds, bool bFadeIn)
+{
+    ((IVRCompositor*)linux_side)->FadeGrid((float)fSeconds, (bool)bFadeIn);
+}
+
+float cppIVRCompositor_IVRCompositor_026_GetCurrentGridAlpha(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->GetCurrentGridAlpha();
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_026_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_026_ClearSkyboxOverride(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->ClearSkyboxOverride();
+}
+
+void cppIVRCompositor_IVRCompositor_026_CompositorBringToFront(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->CompositorBringToFront();
+}
+
+void cppIVRCompositor_IVRCompositor_026_CompositorGoToBack(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->CompositorGoToBack();
+}
+
+void cppIVRCompositor_IVRCompositor_026_CompositorQuit(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->CompositorQuit();
+}
+
+bool cppIVRCompositor_IVRCompositor_026_IsFullscreen(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->IsFullscreen();
+}
+
+uint32_t cppIVRCompositor_IVRCompositor_026_GetCurrentSceneFocusProcess(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->GetCurrentSceneFocusProcess();
+}
+
+uint32_t cppIVRCompositor_IVRCompositor_026_GetLastFrameRenderer(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->GetLastFrameRenderer();
+}
+
+bool cppIVRCompositor_IVRCompositor_026_CanRenderScene(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->CanRenderScene();
+}
+
+void cppIVRCompositor_IVRCompositor_026_ShowMirrorWindow(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->ShowMirrorWindow();
+}
+
+void cppIVRCompositor_IVRCompositor_026_HideMirrorWindow(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->HideMirrorWindow();
+}
+
+bool cppIVRCompositor_IVRCompositor_026_IsMirrorWindowVisible(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->IsMirrorWindowVisible();
+}
+
+void cppIVRCompositor_IVRCompositor_026_CompositorDumpImages(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->CompositorDumpImages();
+}
+
+bool cppIVRCompositor_IVRCompositor_026_ShouldAppRenderWithLowResources(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->ShouldAppRenderWithLowResources();
+}
+
+void cppIVRCompositor_IVRCompositor_026_ForceInterleavedReprojectionOn(void *linux_side, bool bOverride)
+{
+    ((IVRCompositor*)linux_side)->ForceInterleavedReprojectionOn((bool)bOverride);
+}
+
+void cppIVRCompositor_IVRCompositor_026_ForceReconnectProcess(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->ForceReconnectProcess();
+}
+
+void cppIVRCompositor_IVRCompositor_026_SuspendRendering(void *linux_side, bool bSuspend)
+{
+    ((IVRCompositor*)linux_side)->SuspendRendering((bool)bSuspend);
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_026_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_026_ReleaseMirrorTextureD3D11(void *linux_side, void * pD3D11ShaderResourceView)
+{
+    ((IVRCompositor*)linux_side)->ReleaseMirrorTextureD3D11((void *)pD3D11ShaderResourceView);
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_026_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_026_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_026_LockGLSharedTextureForAccess(void *linux_side, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    ((IVRCompositor*)linux_side)->LockGLSharedTextureForAccess((vr::glSharedTextureHandle_t)glSharedTextureHandle);
+}
+
+void cppIVRCompositor_IVRCompositor_026_UnlockGLSharedTextureForAccess(void *linux_side, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    ((IVRCompositor*)linux_side)->UnlockGLSharedTextureForAccess((vr::glSharedTextureHandle_t)glSharedTextureHandle);
+}
+
+uint32_t cppIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired(void *linux_side, char * pchValue, uint32_t unBufferSize)
+{
+    return ((IVRCompositor*)linux_side)->GetVulkanInstanceExtensionsRequired((char *)pchValue, (uint32_t)unBufferSize);
+}
+
+uint32_t cppIVRCompositor_IVRCompositor_026_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_026_SetExplicitTimingMode(void *linux_side, EVRCompositorTimingMode eTimingMode)
+{
+    ((IVRCompositor*)linux_side)->SetExplicitTimingMode((vr::EVRCompositorTimingMode)eTimingMode);
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_026_SubmitExplicitTimingData(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->SubmitExplicitTimingData();
+}
+
+bool cppIVRCompositor_IVRCompositor_026_IsMotionSmoothingEnabled(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->IsMotionSmoothingEnabled();
+}
+
+bool cppIVRCompositor_IVRCompositor_026_IsMotionSmoothingSupported(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->IsMotionSmoothingSupported();
+}
+
+bool cppIVRCompositor_IVRCompositor_026_IsCurrentSceneFocusAppLoading(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->IsCurrentSceneFocusAppLoading();
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_026_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_026_ClearStageOverride(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->ClearStageOverride();
+}
+
+bool cppIVRCompositor_IVRCompositor_026_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_026_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_026_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

vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_026.h

@@ -0,0 +1,57 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern void cppIVRCompositor_IVRCompositor_026_SetTrackingSpace(void *, ETrackingUniverseOrigin);
+extern ETrackingUniverseOrigin cppIVRCompositor_IVRCompositor_026_GetTrackingSpace(void *);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_026_WaitGetPoses(void *, TrackedDevicePose_t *, uint32_t, TrackedDevicePose_t *, uint32_t);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_026_GetLastPoses(void *, TrackedDevicePose_t *, uint32_t, TrackedDevicePose_t *, uint32_t);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_026_GetLastPoseForTrackedDeviceIndex(void *, TrackedDeviceIndex_t, TrackedDevicePose_t *, TrackedDevicePose_t *);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_026_Submit(void *, EVREye, Texture_t *, VRTextureBounds_t *, EVRSubmitFlags);
+extern void cppIVRCompositor_IVRCompositor_026_ClearLastSubmittedFrame(void *);
+extern void cppIVRCompositor_IVRCompositor_026_PostPresentHandoff(void *);
+extern bool cppIVRCompositor_IVRCompositor_026_GetFrameTiming(void *, Compositor_FrameTiming *, uint32_t);
+extern uint32_t cppIVRCompositor_IVRCompositor_026_GetFrameTimings(void *, Compositor_FrameTiming *, uint32_t);
+extern float cppIVRCompositor_IVRCompositor_026_GetFrameTimeRemaining(void *);
+extern void cppIVRCompositor_IVRCompositor_026_GetCumulativeStats(void *, Compositor_CumulativeStats *, uint32_t);
+extern void cppIVRCompositor_IVRCompositor_026_FadeToColor(void *, float, float, float, float, float, bool);
+extern HmdColor_t cppIVRCompositor_IVRCompositor_026_GetCurrentFadeColor(void *, bool);
+extern void cppIVRCompositor_IVRCompositor_026_FadeGrid(void *, float, bool);
+extern float cppIVRCompositor_IVRCompositor_026_GetCurrentGridAlpha(void *);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_026_SetSkyboxOverride(void *, Texture_t *, uint32_t);
+extern void cppIVRCompositor_IVRCompositor_026_ClearSkyboxOverride(void *);
+extern void cppIVRCompositor_IVRCompositor_026_CompositorBringToFront(void *);
+extern void cppIVRCompositor_IVRCompositor_026_CompositorGoToBack(void *);
+extern void cppIVRCompositor_IVRCompositor_026_CompositorQuit(void *);
+extern bool cppIVRCompositor_IVRCompositor_026_IsFullscreen(void *);
+extern uint32_t cppIVRCompositor_IVRCompositor_026_GetCurrentSceneFocusProcess(void *);
+extern uint32_t cppIVRCompositor_IVRCompositor_026_GetLastFrameRenderer(void *);
+extern bool cppIVRCompositor_IVRCompositor_026_CanRenderScene(void *);
+extern void cppIVRCompositor_IVRCompositor_026_ShowMirrorWindow(void *);
+extern void cppIVRCompositor_IVRCompositor_026_HideMirrorWindow(void *);
+extern bool cppIVRCompositor_IVRCompositor_026_IsMirrorWindowVisible(void *);
+extern void cppIVRCompositor_IVRCompositor_026_CompositorDumpImages(void *);
+extern bool cppIVRCompositor_IVRCompositor_026_ShouldAppRenderWithLowResources(void *);
+extern void cppIVRCompositor_IVRCompositor_026_ForceInterleavedReprojectionOn(void *, bool);
+extern void cppIVRCompositor_IVRCompositor_026_ForceReconnectProcess(void *);
+extern void cppIVRCompositor_IVRCompositor_026_SuspendRendering(void *, bool);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_026_GetMirrorTextureD3D11(void *, EVREye, void *, void **);
+extern void cppIVRCompositor_IVRCompositor_026_ReleaseMirrorTextureD3D11(void *, void *);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_026_GetMirrorTextureGL(void *, EVREye, glUInt_t *, glSharedTextureHandle_t *);
+extern bool cppIVRCompositor_IVRCompositor_026_ReleaseSharedGLTexture(void *, glUInt_t, glSharedTextureHandle_t);
+extern void cppIVRCompositor_IVRCompositor_026_LockGLSharedTextureForAccess(void *, glSharedTextureHandle_t);
+extern void cppIVRCompositor_IVRCompositor_026_UnlockGLSharedTextureForAccess(void *, glSharedTextureHandle_t);
+extern uint32_t cppIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired(void *, char *, uint32_t);
+extern uint32_t cppIVRCompositor_IVRCompositor_026_GetVulkanDeviceExtensionsRequired(void *, VkPhysicalDevice_T *, char *, uint32_t);
+extern void cppIVRCompositor_IVRCompositor_026_SetExplicitTimingMode(void *, EVRCompositorTimingMode);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_026_SubmitExplicitTimingData(void *);
+extern bool cppIVRCompositor_IVRCompositor_026_IsMotionSmoothingEnabled(void *);
+extern bool cppIVRCompositor_IVRCompositor_026_IsMotionSmoothingSupported(void *);
+extern bool cppIVRCompositor_IVRCompositor_026_IsCurrentSceneFocusAppLoading(void *);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_026_SetStageOverride_Async(void *, const char *, HmdMatrix34_t *, Compositor_StageRenderSettings *, uint32_t);
+extern void cppIVRCompositor_IVRCompositor_026_ClearStageOverride(void *);
+extern bool cppIVRCompositor_IVRCompositor_026_GetCompositorBenchmarkResults(void *, Compositor_BenchmarkResults *, uint32_t);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_026_GetLastPosePredictionIDs(void *, uint32_t *, uint32_t *);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_026_GetPosesForFrame(void *, uint32_t, TrackedDevicePose_t *, uint32_t);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRControlPanel_IVRControlPanel_006.cpp

@@ -0,0 +1,154 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.10.30/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRControlPanel_IVRControlPanel_006.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+uint32_t cppIVRControlPanel_IVRControlPanel_006_undoc1(void *linux_side)
+{
+    return ((IVRControlPanel*)linux_side)->undoc1();
+}
+
+uint32_t cppIVRControlPanel_IVRControlPanel_006_undoc2(void *linux_side, uint32_t a, char * b, uint32_t c)
+{
+    return ((IVRControlPanel*)linux_side)->undoc2((uint32_t)a, (char *)b, (uint32_t)c);
+}
+
+vr::EVRInitError cppIVRControlPanel_IVRControlPanel_006_undoc3(void *linux_side, const char * a)
+{
+    return ((IVRControlPanel*)linux_side)->undoc3((const char *)a);
+}
+
+uint32_t cppIVRControlPanel_IVRControlPanel_006_undoc4(void *linux_side, const char * a)
+{
+    return ((IVRControlPanel*)linux_side)->undoc4((const char *)a);
+}
+
+uint32_t cppIVRControlPanel_IVRControlPanel_006_undoc5(void *linux_side, const char * a, uint32_t b, char * c, uint32_t d)
+{
+    return ((IVRControlPanel*)linux_side)->undoc5((const char *)a, (uint32_t)b, (char *)c, (uint32_t)d);
+}
+
+uint32_t cppIVRControlPanel_IVRControlPanel_006_undoc6(void *linux_side, const char * a, const char * b, char * c, uint32_t d)
+{
+    return ((IVRControlPanel*)linux_side)->undoc6((const char *)a, (const char *)b, (char *)c, (uint32_t)d);
+}
+
+uint32_t cppIVRControlPanel_IVRControlPanel_006_undoc7(void *linux_side, const char * a, const char * b, char * c, uint32_t d)
+{
+    return ((IVRControlPanel*)linux_side)->undoc7((const char *)a, (const char *)b, (char *)c, (uint32_t)d);
+}
+
+bool cppIVRControlPanel_IVRControlPanel_006_undoc8(void *linux_side, uint32_t a)
+{
+    return ((IVRControlPanel*)linux_side)->undoc8((uint32_t)a);
+}
+
+void cppIVRControlPanel_IVRControlPanel_006_undoc9(void *linux_side)
+{
+    ((IVRControlPanel*)linux_side)->undoc9();
+}
+
+void cppIVRControlPanel_IVRControlPanel_006_undoc10(void *linux_side)
+{
+    ((IVRControlPanel*)linux_side)->undoc10();
+}
+
+bool cppIVRControlPanel_IVRControlPanel_006_undoc11(void *linux_side, uint32_t a)
+{
+    return ((IVRControlPanel*)linux_side)->undoc11((uint32_t)a);
+}
+
+void cppIVRControlPanel_IVRControlPanel_006_undoc12(void *linux_side)
+{
+    ((IVRControlPanel*)linux_side)->undoc12();
+}
+
+void cppIVRControlPanel_IVRControlPanel_006_undoc13(void *linux_side, TrackedDeviceIndex_t a)
+{
+    ((IVRControlPanel*)linux_side)->undoc13((vr::TrackedDeviceIndex_t)a);
+}
+
+void cppIVRControlPanel_IVRControlPanel_006_undoc14(void *linux_side, EVRState a)
+{
+    ((IVRControlPanel*)linux_side)->undoc14((vr::EVRState)a);
+}
+
+vr::EVRState cppIVRControlPanel_IVRControlPanel_006_undoc15(void *linux_side)
+{
+    return ((IVRControlPanel*)linux_side)->undoc15();
+}
+
+void cppIVRControlPanel_IVRControlPanel_006_undoc16(void *linux_side, bool a)
+{
+    ((IVRControlPanel*)linux_side)->undoc16((bool)a);
+}
+
+bool cppIVRControlPanel_IVRControlPanel_006_undoc17(void *linux_side)
+{
+    return ((IVRControlPanel*)linux_side)->undoc17();
+}
+
+vr::EVRApplicationError cppIVRControlPanel_IVRControlPanel_006_undoc18(void *linux_side)
+{
+    return ((IVRControlPanel*)linux_side)->undoc18();
+}
+
+void cppIVRControlPanel_IVRControlPanel_006_undoc19(void *linux_side, bool a)
+{
+    ((IVRControlPanel*)linux_side)->undoc19((bool)a);
+}
+
+bool cppIVRControlPanel_IVRControlPanel_006_undoc20(void *linux_side)
+{
+    return ((IVRControlPanel*)linux_side)->undoc20();
+}
+
+vr::EVRInitError cppIVRControlPanel_IVRControlPanel_006_undoc21(void *linux_side)
+{
+    return ((IVRControlPanel*)linux_side)->undoc21();
+}
+
+void cppIVRControlPanel_IVRControlPanel_006_undoc22(void *linux_side, WebConsoleHandle_t a, const char * b, uint32_t c, uint32_t d, const char * e)
+{
+    ((IVRControlPanel*)linux_side)->undoc22((vr::WebConsoleHandle_t)a, (const char *)b, (uint32_t)c, (uint32_t)d, (const char *)e);
+}
+
+bool cppIVRControlPanel_IVRControlPanel_006_undoc23(void *linux_side, const char * a)
+{
+    return ((IVRControlPanel*)linux_side)->undoc23((const char *)a);
+}
+
+bool cppIVRControlPanel_IVRControlPanel_006_undoc24(void *linux_side)
+{
+    return ((IVRControlPanel*)linux_side)->undoc24();
+}
+
+bool cppIVRControlPanel_IVRControlPanel_006_undoc25(void *linux_side, bool a)
+{
+    return ((IVRControlPanel*)linux_side)->undoc25((bool)a);
+}
+
+uint64_t cppIVRControlPanel_IVRControlPanel_006_undoc26(void *linux_side)
+{
+    return ((IVRControlPanel*)linux_side)->undoc26();
+}
+
+vr::EVRCompositorError cppIVRControlPanel_IVRControlPanel_006_undoc27(void *linux_side, const char * a)
+{
+    return ((IVRControlPanel*)linux_side)->undoc27((const char *)a);
+}
+
+void cppIVRControlPanel_IVRControlPanel_006_undoc28(void *linux_side, VROverlayHandle_t a)
+{
+    ((IVRControlPanel*)linux_side)->undoc28((vr::VROverlayHandle_t)a);
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRControlPanel_IVRControlPanel_006.h

@@ -0,0 +1,34 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern uint32_t cppIVRControlPanel_IVRControlPanel_006_undoc1(void *);
+extern uint32_t cppIVRControlPanel_IVRControlPanel_006_undoc2(void *, uint32_t, char *, uint32_t);
+extern EVRInitError cppIVRControlPanel_IVRControlPanel_006_undoc3(void *, const char *);
+extern uint32_t cppIVRControlPanel_IVRControlPanel_006_undoc4(void *, const char *);
+extern uint32_t cppIVRControlPanel_IVRControlPanel_006_undoc5(void *, const char *, uint32_t, char *, uint32_t);
+extern uint32_t cppIVRControlPanel_IVRControlPanel_006_undoc6(void *, const char *, const char *, char *, uint32_t);
+extern uint32_t cppIVRControlPanel_IVRControlPanel_006_undoc7(void *, const char *, const char *, char *, uint32_t);
+extern bool cppIVRControlPanel_IVRControlPanel_006_undoc8(void *, uint32_t);
+extern void cppIVRControlPanel_IVRControlPanel_006_undoc9(void *);
+extern void cppIVRControlPanel_IVRControlPanel_006_undoc10(void *);
+extern bool cppIVRControlPanel_IVRControlPanel_006_undoc11(void *, uint32_t);
+extern void cppIVRControlPanel_IVRControlPanel_006_undoc12(void *);
+extern void cppIVRControlPanel_IVRControlPanel_006_undoc13(void *, TrackedDeviceIndex_t);
+extern void cppIVRControlPanel_IVRControlPanel_006_undoc14(void *, EVRState);
+extern EVRState cppIVRControlPanel_IVRControlPanel_006_undoc15(void *);
+extern void cppIVRControlPanel_IVRControlPanel_006_undoc16(void *, bool);
+extern bool cppIVRControlPanel_IVRControlPanel_006_undoc17(void *);
+extern EVRApplicationError cppIVRControlPanel_IVRControlPanel_006_undoc18(void *);
+extern void cppIVRControlPanel_IVRControlPanel_006_undoc19(void *, bool);
+extern bool cppIVRControlPanel_IVRControlPanel_006_undoc20(void *);
+extern EVRInitError cppIVRControlPanel_IVRControlPanel_006_undoc21(void *);
+extern void cppIVRControlPanel_IVRControlPanel_006_undoc22(void *, WebConsoleHandle_t, const char *, uint32_t, uint32_t, const char *);
+extern bool cppIVRControlPanel_IVRControlPanel_006_undoc23(void *, const char *);
+extern bool cppIVRControlPanel_IVRControlPanel_006_undoc24(void *);
+extern bool cppIVRControlPanel_IVRControlPanel_006_undoc25(void *, bool);
+extern uint64_t cppIVRControlPanel_IVRControlPanel_006_undoc26(void *);
+extern EVRCompositorError cppIVRControlPanel_IVRControlPanel_006_undoc27(void *, const char *);
+extern void cppIVRControlPanel_IVRControlPanel_006_undoc28(void *, VROverlayHandle_t);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRExtendedDisplay_IVRExtendedDisplay_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRHeadsetView_IVRHeadsetView_001.cpp

@@ -0,0 +1,59 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.10.30/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRHeadsetView_IVRHeadsetView_001.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+void cppIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewSize(void *linux_side, uint32_t nWidth, uint32_t nHeight)
+{
+    ((IVRHeadsetView*)linux_side)->SetHeadsetViewSize((uint32_t)nWidth, (uint32_t)nHeight);
+}
+
+void cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewSize(void *linux_side, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    ((IVRHeadsetView*)linux_side)->GetHeadsetViewSize((uint32_t *)pnWidth, (uint32_t *)pnHeight);
+}
+
+void cppIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewMode(void *linux_side, HeadsetViewMode_t eHeadsetViewMode)
+{
+    ((IVRHeadsetView*)linux_side)->SetHeadsetViewMode((vr::HeadsetViewMode_t)eHeadsetViewMode);
+}
+
+vr::HeadsetViewMode_t cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewMode(void *linux_side)
+{
+    return ((IVRHeadsetView*)linux_side)->GetHeadsetViewMode();
+}
+
+void cppIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewCropped(void *linux_side, bool bCropped)
+{
+    ((IVRHeadsetView*)linux_side)->SetHeadsetViewCropped((bool)bCropped);
+}
+
+bool cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewCropped(void *linux_side)
+{
+    return ((IVRHeadsetView*)linux_side)->GetHeadsetViewCropped();
+}
+
+float cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewAspectRatio(void *linux_side)
+{
+    return ((IVRHeadsetView*)linux_side)->GetHeadsetViewAspectRatio();
+}
+
+void cppIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewBlendRange(void *linux_side, float flStartPct, float flEndPct)
+{
+    ((IVRHeadsetView*)linux_side)->SetHeadsetViewBlendRange((float)flStartPct, (float)flEndPct);
+}
+
+void cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewBlendRange(void *linux_side, float * pStartPct, float * pEndPct)
+{
+    ((IVRHeadsetView*)linux_side)->GetHeadsetViewBlendRange((float *)pStartPct, (float *)pEndPct);
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRHeadsetView_IVRHeadsetView_001.h

@@ -0,0 +1,15 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern void cppIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewSize(void *, uint32_t, uint32_t);
+extern void cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewSize(void *, uint32_t *, uint32_t *);
+extern void cppIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewMode(void *, HeadsetViewMode_t);
+extern HeadsetViewMode_t cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewMode(void *);
+extern void cppIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewCropped(void *, bool);
+extern bool cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewCropped(void *);
+extern float cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewAspectRatio(void *);
+extern void cppIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewBlendRange(void *, float, float);
+extern void cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewBlendRange(void *, float *, float *);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_002.cpp

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

vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.cpp

@@ -0,0 +1,209 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.10.30/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRInput_IVRInput_010.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::EVRInputError cppIVRInput_IVRInput_010_SetActionManifestPath(void *linux_side, const char * pchActionManifestPath)
+{
+    return ((IVRInput*)linux_side)->SetActionManifestPath((const char *)pchActionManifestPath);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetActionSetHandle(void *linux_side, const char * pchActionSetName, VRActionSetHandle_t * pHandle)
+{
+    return ((IVRInput*)linux_side)->GetActionSetHandle((const char *)pchActionSetName, (vr::VRActionSetHandle_t *)pHandle);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetActionHandle(void *linux_side, const char * pchActionName, VRActionHandle_t * pHandle)
+{
+    return ((IVRInput*)linux_side)->GetActionHandle((const char *)pchActionName, (vr::VRActionHandle_t *)pHandle);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetInputSourceHandle(void *linux_side, const char * pchInputSourcePath, VRInputValueHandle_t * pHandle)
+{
+    return ((IVRInput*)linux_side)->GetInputSourceHandle((const char *)pchInputSourcePath, (vr::VRInputValueHandle_t *)pHandle);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_UpdateActionState(void *linux_side, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount)
+{
+    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_11030 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+{
+    InputDigitalActionData_t lin;
+    vr::EVRInputError _ret;
+    if(pActionData)
+        struct_InputDigitalActionData_t_11030_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_11030_lin_to_win(&lin, pActionData, unActionDataSize);
+    return _ret;
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_11030 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+{
+    InputAnalogActionData_t lin;
+    vr::EVRInputError _ret;
+    if(pActionData)
+        struct_InputAnalogActionData_t_11030_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_11030_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_11030 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+{
+    InputPoseActionData_t lin;
+    vr::EVRInputError _ret;
+    if(pActionData)
+        struct_InputPoseActionData_t_11030_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_11030_lin_to_win(&lin, pActionData, unActionDataSize);
+    return _ret;
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_11030 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+{
+    InputPoseActionData_t lin;
+    vr::EVRInputError _ret;
+    if(pActionData)
+        struct_InputPoseActionData_t_11030_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_11030_lin_to_win(&lin, pActionData, unActionDataSize);
+    return _ret;
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_11030 * pActionData, uint32_t unActionDataSize)
+{
+    InputSkeletalActionData_t lin;
+    vr::EVRInputError _ret;
+    if(pActionData)
+        struct_InputSkeletalActionData_t_11030_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_11030_lin_to_win(&lin, pActionData, unActionDataSize);
+    return _ret;
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetDominantHand(void *linux_side, ETrackedControllerRole * peDominantHand)
+{
+    return ((IVRInput*)linux_side)->GetDominantHand((vr::ETrackedControllerRole *)peDominantHand);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_SetDominantHand(void *linux_side, ETrackedControllerRole eDominantHand)
+{
+    return ((IVRInput*)linux_side)->SetDominantHand((vr::ETrackedControllerRole)eDominantHand);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetBoneCount(void *linux_side, VRActionHandle_t action, uint32_t * pBoneCount)
+{
+    return ((IVRInput*)linux_side)->GetBoneCount((vr::VRActionHandle_t)action, (uint32_t *)pBoneCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetBoneHierarchy(void *linux_side, VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount)
+{
+    return ((IVRInput*)linux_side)->GetBoneHierarchy((vr::VRActionHandle_t)action, (vr::BoneIndex_t *)pParentIndices, (uint32_t)unIndexArayCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetBoneName(void *linux_side, VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize)
+{
+    return ((IVRInput*)linux_side)->GetBoneName((vr::VRActionHandle_t)action, (vr::BoneIndex_t)nBoneIndex, (char *)pchBoneName, (uint32_t)unNameBufferSize);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalReferenceTransforms(void *linux_side, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalReferenceTransforms((vr::VRActionHandle_t)action, (vr::EVRSkeletalTransformSpace)eTransformSpace, (vr::EVRSkeletalReferencePose)eReferencePose, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalTrackingLevel(void *linux_side, VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalTrackingLevel((vr::VRActionHandle_t)action, (vr::EVRSkeletalTrackingLevel *)pSkeletalTrackingLevel);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalBoneData(void *linux_side, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalBoneData((vr::VRActionHandle_t)action, (vr::EVRSkeletalTransformSpace)eTransformSpace, (vr::EVRSkeletalMotionRange)eMotionRange, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalSummaryData(void *linux_side, VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalSummaryData((vr::VRActionHandle_t)action, (vr::EVRSummaryType)eSummaryType, (vr::VRSkeletalSummaryData_t *)pSkeletalSummaryData);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalBoneDataCompressed(void *linux_side, VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalBoneDataCompressed((vr::VRActionHandle_t)action, (vr::EVRSkeletalMotionRange)eMotionRange, (void *)pvCompressedData, (uint32_t)unCompressedSize, (uint32_t *)punRequiredCompressedSize);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_DecompressSkeletalBoneData(void *linux_side, const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    return ((IVRInput*)linux_side)->DecompressSkeletalBoneData((const void *)pvCompressedBuffer, (uint32_t)unCompressedBufferSize, (vr::EVRSkeletalTransformSpace)eTransformSpace, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_TriggerHapticVibrationAction(void *linux_side, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice)
+{
+    return ((IVRInput*)linux_side)->TriggerHapticVibrationAction((vr::VRActionHandle_t)action, (float)fStartSecondsFromNow, (float)fDurationSeconds, (float)fFrequency, (float)fAmplitude, (vr::VRInputValueHandle_t)ulRestrictToDevice);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetActionOrigins(void *linux_side, VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount)
+{
+    return ((IVRInput*)linux_side)->GetActionOrigins((vr::VRActionSetHandle_t)actionSetHandle, (vr::VRActionHandle_t)digitalActionHandle, (vr::VRInputValueHandle_t *)originsOut, (uint32_t)originOutCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetOriginLocalizedName(void *linux_side, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude)
+{
+    return ((IVRInput*)linux_side)->GetOriginLocalizedName((vr::VRInputValueHandle_t)origin, (char *)pchNameArray, (uint32_t)unNameArraySize, (int32_t)unStringSectionsToInclude);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetOriginTrackedDeviceInfo(void *linux_side, VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize)
+{
+    return ((IVRInput*)linux_side)->GetOriginTrackedDeviceInfo((vr::VRInputValueHandle_t)origin, (vr::InputOriginInfo_t *)pOriginInfo, (uint32_t)unOriginInfoSize);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetActionBindingInfo(void *linux_side, VRActionHandle_t action, InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t * punReturnedBindingInfoCount)
+{
+    return ((IVRInput*)linux_side)->GetActionBindingInfo((vr::VRActionHandle_t)action, (vr::InputBindingInfo_t *)pOriginInfo, (uint32_t)unBindingInfoSize, (uint32_t)unBindingInfoCount, (uint32_t *)punReturnedBindingInfoCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_ShowActionOrigins(void *linux_side, VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle)
+{
+    return ((IVRInput*)linux_side)->ShowActionOrigins((vr::VRActionSetHandle_t)actionSetHandle, (vr::VRActionHandle_t)ulActionHandle);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_ShowBindingsForActionSet(void *linux_side, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight)
+{
+    return ((IVRInput*)linux_side)->ShowBindingsForActionSet((vr::VRActiveActionSet_t *)pSets, (uint32_t)unSizeOfVRSelectedActionSet_t, (uint32_t)unSetCount, (vr::VRInputValueHandle_t)originToHighlight);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetComponentStateForBinding(void *linux_side, const char * pchRenderModelName, const char * pchComponentName, InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, RenderModel_ComponentState_t * pComponentState)
+{
+    return ((IVRInput*)linux_side)->GetComponentStateForBinding((const char *)pchRenderModelName, (const char *)pchComponentName, (const vr::InputBindingInfo_t *)pOriginInfo, (uint32_t)unBindingInfoSize, (uint32_t)unBindingInfoCount, (vr::RenderModel_ComponentState_t *)pComponentState);
+}
+
+bool cppIVRInput_IVRInput_010_IsUsingLegacyInput(void *linux_side)
+{
+    return ((IVRInput*)linux_side)->IsUsingLegacyInput();
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_OpenBindingUI(void *linux_side, const char * pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop)
+{
+    return ((IVRInput*)linux_side)->OpenBindingUI((const char *)pchAppKey, (vr::VRActionSetHandle_t)ulActionSetHandle, (vr::VRInputValueHandle_t)ulDeviceHandle, (bool)bShowOnDesktop);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_010_GetBindingVariant(void *linux_side, VRInputValueHandle_t ulDevicePath, char * pchVariantArray, uint32_t unVariantArraySize)
+{
+    return ((IVRInput*)linux_side)->GetBindingVariant((vr::VRInputValueHandle_t)ulDevicePath, (char *)pchVariantArray, (uint32_t)unVariantArraySize);
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.h

@@ -0,0 +1,38 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern EVRInputError cppIVRInput_IVRInput_010_SetActionManifestPath(void *, const char *);
+extern EVRInputError cppIVRInput_IVRInput_010_GetActionSetHandle(void *, const char *, VRActionSetHandle_t *);
+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_11030 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_11030 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_11030 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_11030 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_11030 *, 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 *);
+extern EVRInputError cppIVRInput_IVRInput_010_GetBoneHierarchy(void *, VRActionHandle_t, BoneIndex_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetBoneName(void *, VRActionHandle_t, BoneIndex_t, char *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalReferenceTransforms(void *, VRActionHandle_t, EVRSkeletalTransformSpace, EVRSkeletalReferencePose, VRBoneTransform_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalTrackingLevel(void *, VRActionHandle_t, EVRSkeletalTrackingLevel *);
+extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalBoneData(void *, VRActionHandle_t, EVRSkeletalTransformSpace, EVRSkeletalMotionRange, VRBoneTransform_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalSummaryData(void *, VRActionHandle_t, EVRSummaryType, VRSkeletalSummaryData_t *);
+extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalBoneDataCompressed(void *, VRActionHandle_t, EVRSkeletalMotionRange, void *, uint32_t, uint32_t *);
+extern EVRInputError cppIVRInput_IVRInput_010_DecompressSkeletalBoneData(void *, const void *, uint32_t, EVRSkeletalTransformSpace, VRBoneTransform_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_010_TriggerHapticVibrationAction(void *, VRActionHandle_t, float, float, float, float, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetActionOrigins(void *, VRActionSetHandle_t, VRActionHandle_t, VRInputValueHandle_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetOriginLocalizedName(void *, VRInputValueHandle_t, char *, uint32_t, int32_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetOriginTrackedDeviceInfo(void *, VRInputValueHandle_t, InputOriginInfo_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetActionBindingInfo(void *, VRActionHandle_t, InputBindingInfo_t *, uint32_t, uint32_t, uint32_t *);
+extern EVRInputError cppIVRInput_IVRInput_010_ShowActionOrigins(void *, VRActionSetHandle_t, VRActionHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_ShowBindingsForActionSet(void *, VRActiveActionSet_t *, uint32_t, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetComponentStateForBinding(void *, const char *, const char *, InputBindingInfo_t *, uint32_t, uint32_t, RenderModel_ComponentState_t *);
+extern bool cppIVRInput_IVRInput_010_IsUsingLegacyInput(void *);
+extern EVRInputError cppIVRInput_IVRInput_010_OpenBindingUI(void *, const char *, VRActionSetHandle_t, VRInputValueHandle_t, bool);
+extern EVRInputError cppIVRInput_IVRInput_010_GetBindingVariant(void *, VRInputValueHandle_t, char *, uint32_t);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRMailbox_IVRMailbox_001.cpp

@@ -0,0 +1,34 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.10.30/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRMailbox_IVRMailbox_001.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::vrmb_typeb cppIVRMailbox_IVRMailbox_001_undoc1(void *linux_side, const char * a, vrmb_typea * b)
+{
+    return ((IVRMailbox*)linux_side)->undoc1((const char *)a, (vr::vrmb_typea *)b);
+}
+
+vr::vrmb_typeb cppIVRMailbox_IVRMailbox_001_undoc2(void *linux_side, vrmb_typea a)
+{
+    return ((IVRMailbox*)linux_side)->undoc2((vr::vrmb_typea)a);
+}
+
+vr::vrmb_typeb cppIVRMailbox_IVRMailbox_001_undoc3(void *linux_side, vrmb_typea a, const char * b, const char * c)
+{
+    return ((IVRMailbox*)linux_side)->undoc3((vr::vrmb_typea)a, (const char *)b, (const char *)c);
+}
+
+vr::vrmb_typeb cppIVRMailbox_IVRMailbox_001_undoc4(void *linux_side, vrmb_typea a, char * b, uint32_t c, uint32_t * d)
+{
+    return ((IVRMailbox*)linux_side)->undoc4((vr::vrmb_typea)a, (char *)b, (uint32_t)c, (uint32_t *)d);
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRMailbox_IVRMailbox_001.h

@@ -0,0 +1,10 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern vrmb_typeb cppIVRMailbox_IVRMailbox_001_undoc1(void *, const char *, vrmb_typea *);
+extern vrmb_typeb cppIVRMailbox_IVRMailbox_001_undoc2(void *, vrmb_typea);
+extern vrmb_typeb cppIVRMailbox_IVRMailbox_001_undoc3(void *, vrmb_typea, const char *, const char *);
+extern vrmb_typeb cppIVRMailbox_IVRMailbox_001_undoc4(void *, vrmb_typea, char *, uint32_t, uint32_t *);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRNotifications_IVRNotifications_002.cpp

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

vrclient_x64/vrclient_x64/cppIVROverlayView_IVROverlayView_003.cpp

@@ -0,0 +1,37 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.10.30/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVROverlayView_IVROverlayView_003.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::EVROverlayError cppIVROverlayView_IVROverlayView_003_AcquireOverlayView(void *linux_side, VROverlayHandle_t ulOverlayHandle, VRNativeDevice_t * pNativeDevice, VROverlayView_t * pOverlayView, uint32_t unOverlayViewSize)
+{
+    return ((IVROverlayView*)linux_side)->AcquireOverlayView((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VRNativeDevice_t *)pNativeDevice, (vr::VROverlayView_t *)pOverlayView, (uint32_t)unOverlayViewSize);
+}
+
+vr::EVROverlayError cppIVROverlayView_IVROverlayView_003_ReleaseOverlayView(void *linux_side, VROverlayView_t * pOverlayView)
+{
+    return ((IVROverlayView*)linux_side)->ReleaseOverlayView((vr::VROverlayView_t *)pOverlayView);
+}
+
+void cppIVROverlayView_IVROverlayView_003_PostOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, VREvent_t * pvrEvent)
+{
+    VREvent_t lin;
+    if(pvrEvent)
+        struct_VREvent_t_11030_win_to_lin(pvrEvent, &lin);
+    ((IVROverlayView*)linux_side)->PostOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pvrEvent ? &lin : nullptr);
+}
+
+bool cppIVROverlayView_IVROverlayView_003_IsViewingPermitted(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlayView*)linux_side)->IsViewingPermitted((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVROverlayView_IVROverlayView_003.h

@@ -0,0 +1,10 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern EVROverlayError cppIVROverlayView_IVROverlayView_003_AcquireOverlayView(void *, VROverlayHandle_t, VRNativeDevice_t *, VROverlayView_t *, uint32_t);
+extern EVROverlayError cppIVROverlayView_IVROverlayView_003_ReleaseOverlayView(void *, VROverlayView_t *);
+extern void cppIVROverlayView_IVROverlayView_003_PostOverlayEvent(void *, VROverlayHandle_t, VREvent_t *);
+extern bool cppIVROverlayView_IVROverlayView_003_IsViewingPermitted(void *, VROverlayHandle_t);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_024.cpp

@@ -0,0 +1,411 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.10.30/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVROverlay_IVROverlay_024.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_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_024_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_024_DestroyOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->DestroyOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+uint32_t cppIVROverlay_IVROverlay_024_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_024_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_024_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_024_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_024_GetOverlayErrorNameFromEnum(void *linux_side, EVROverlayError error)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayErrorNameFromEnum((vr::EVROverlayError)error);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_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_024_GetOverlayRenderingPid(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayRenderingPid((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_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_024_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_024_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_024_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_024_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_024_SetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float)fAlpha);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfAlpha);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float)fTexelAspect);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfTexelAspect);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_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_024_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_024_SetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float)fWidthInMeters);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfWidthInMeters);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayCurvature(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fCurvature)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayCurvature((vr::VROverlayHandle_t)ulOverlayHandle, (float)fCurvature);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayCurvature(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayCurvature((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfCurvature);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_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_024_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_024_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_024_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_024_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_024_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_024_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_024_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_024_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_024_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_024_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_024_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_024_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_024_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_024_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_024_ShowOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->ShowOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_HideOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->HideOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+bool cppIVROverlay_IVROverlay_024_IsOverlayVisible(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsOverlayVisible((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_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_024_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_11030 * pEvent, uint32_t uncbVREvent)
+{
+    VREvent_t lin;
+    bool _ret;
+    if(pEvent)
+        struct_VREvent_t_11030_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_11030_lin_to_win(&lin, pEvent, uncbVREvent);
+    return _ret;
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_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_024_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_024_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_024_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_024_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_024_IsHoverTargetOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsHoverTargetOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_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_024_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_024_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_024_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_024_ClearOverlayCursorPositionOverride(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->ClearOverlayCursorPositionOverride((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_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_024_ClearOverlayTexture(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->ClearOverlayTexture((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_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_024_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_024_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_024_ReleaseNativeOverlayHandle(void *linux_side, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    return ((IVROverlay*)linux_side)->ReleaseNativeOverlayHandle((vr::VROverlayHandle_t)ulOverlayHandle, (void *)pNativeTextureHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_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_024_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_024_IsDashboardVisible(void *linux_side)
+{
+    return ((IVROverlay*)linux_side)->IsDashboardVisible();
+}
+
+bool cppIVROverlay_IVROverlay_024_IsActiveDashboardOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsActiveDashboardOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_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_024_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_024_ShowDashboard(void *linux_side, const char * pchOverlayToShow)
+{
+    ((IVROverlay*)linux_side)->ShowDashboard((const char *)pchOverlayToShow);
+}
+
+vr::TrackedDeviceIndex_t cppIVROverlay_IVROverlay_024_GetPrimaryDashboardDevice(void *linux_side)
+{
+    return ((IVROverlay*)linux_side)->GetPrimaryDashboardDevice();
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_024_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_024_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_024_GetKeyboardText(void *linux_side, char * pchText, uint32_t cchText)
+{
+    return ((IVROverlay*)linux_side)->GetKeyboardText((char *)pchText, (uint32_t)cchText);
+}
+
+void cppIVROverlay_IVROverlay_024_HideKeyboard(void *linux_side)
+{
+    ((IVROverlay*)linux_side)->HideKeyboard();
+}
+
+void cppIVROverlay_IVROverlay_024_SetKeyboardTransformAbsolute(void *linux_side, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    ((IVROverlay*)linux_side)->SetKeyboardTransformAbsolute((vr::ETrackingUniverseOrigin)eTrackingOrigin, (const vr::HmdMatrix34_t *)pmatTrackingOriginToKeyboardTransform);
+}
+
+void cppIVROverlay_IVROverlay_024_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_024_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_024_CloseMessageOverlay(void *linux_side)
+{
+    ((IVROverlay*)linux_side)->CloseMessageOverlay();
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_024.h

@@ -0,0 +1,84 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern EVROverlayError cppIVROverlay_IVROverlay_024_FindOverlay(void *, const char *, VROverlayHandle_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_CreateOverlay(void *, const char *, const char *, VROverlayHandle_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_DestroyOverlay(void *, VROverlayHandle_t);
+extern uint32_t cppIVROverlay_IVROverlay_024_GetOverlayKey(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
+extern uint32_t cppIVROverlay_IVROverlay_024_GetOverlayName(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayName(void *, VROverlayHandle_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayImageData(void *, VROverlayHandle_t, void *, uint32_t, uint32_t *, uint32_t *);
+extern const char * cppIVROverlay_IVROverlay_024_GetOverlayErrorNameFromEnum(void *, EVROverlayError);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayRenderingPid(void *, VROverlayHandle_t, uint32_t);
+extern uint32_t cppIVROverlay_IVROverlay_024_GetOverlayRenderingPid(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayFlags(void *, VROverlayHandle_t, uint32_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayColor(void *, VROverlayHandle_t, float, float, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayColor(void *, VROverlayHandle_t, float *, float *, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayAlpha(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayAlpha(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayTexelAspect(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayTexelAspect(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayWidthInMeters(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayWidthInMeters(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayCurvature(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayCurvature(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayTransformType(void *, VROverlayHandle_t, VROverlayTransformType *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin *, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, char *, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayTransformOverlayRelative(void *, VROverlayHandle_t, VROverlayHandle_t *, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayTransformOverlayRelative(void *, VROverlayHandle_t, VROverlayHandle_t, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayTransformCursor(void *, VROverlayHandle_t, HmdVector2_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayTransformCursor(void *, VROverlayHandle_t, HmdVector2_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_ShowOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_HideOverlay(void *, VROverlayHandle_t);
+extern bool cppIVROverlay_IVROverlay_024_IsOverlayVisible(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetTransformForOverlayCoordinates(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdVector2_t, HmdMatrix34_t *);
+extern bool cppIVROverlay_IVROverlay_024_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_11030 *, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
+extern bool cppIVROverlay_IVROverlay_024_ComputeOverlayIntersection(void *, VROverlayHandle_t, VROverlayIntersectionParams_t *, VROverlayIntersectionResults_t *);
+extern bool cppIVROverlay_IVROverlay_024_IsHoverTargetOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayIntersectionMask(void *, VROverlayHandle_t, VROverlayIntersectionMaskPrimitive_t *, uint32_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_TriggerLaserMouseHapticVibration(void *, VROverlayHandle_t, float, float, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayCursor(void *, VROverlayHandle_t, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayCursorPositionOverride(void *, VROverlayHandle_t, HmdVector2_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_ClearOverlayCursorPositionOverride(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayTexture(void *, VROverlayHandle_t, Texture_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_ClearOverlayTexture(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayRaw(void *, VROverlayHandle_t, void *, uint32_t, uint32_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetOverlayFromFile(void *, VROverlayHandle_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayTexture(void *, VROverlayHandle_t, void **, void *, uint32_t *, uint32_t *, uint32_t *, ETextureType *, EColorSpace *, VRTextureBounds_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_ReleaseNativeOverlayHandle(void *, VROverlayHandle_t, void *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetOverlayTextureSize(void *, VROverlayHandle_t, uint32_t *, uint32_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_CreateDashboardOverlay(void *, const char *, const char *, VROverlayHandle_t *, VROverlayHandle_t *);
+extern bool cppIVROverlay_IVROverlay_024_IsDashboardVisible(void *);
+extern bool cppIVROverlay_IVROverlay_024_IsActiveDashboardOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_SetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_GetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t *);
+extern void cppIVROverlay_IVROverlay_024_ShowDashboard(void *, const char *);
+extern TrackedDeviceIndex_t cppIVROverlay_IVROverlay_024_GetPrimaryDashboardDevice(void *);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_ShowKeyboard(void *, EGamepadTextInputMode, EGamepadTextInputLineMode, uint32_t, const char *, uint32_t, const char *, uint64_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_024_ShowKeyboardForOverlay(void *, VROverlayHandle_t, EGamepadTextInputMode, EGamepadTextInputLineMode, uint32_t, const char *, uint32_t, const char *, uint64_t);
+extern uint32_t cppIVROverlay_IVROverlay_024_GetKeyboardText(void *, char *, uint32_t);
+extern void cppIVROverlay_IVROverlay_024_HideKeyboard(void *);
+extern void cppIVROverlay_IVROverlay_024_SetKeyboardTransformAbsolute(void *, ETrackingUniverseOrigin, HmdMatrix34_t *);
+extern void cppIVROverlay_IVROverlay_024_SetKeyboardPositionForOverlay(void *, VROverlayHandle_t, HmdRect2_t);
+extern VRMessageOverlayResponse cppIVROverlay_IVROverlay_024_ShowMessageOverlay(void *, const char *, const char *, const char *, const char *, const char *, const char *);
+extern void cppIVROverlay_IVROverlay_024_CloseMessageOverlay(void *);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.9.16/ivrclientcore.h"
+#include "openvr_v1.10.30/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_1916 ** ppRenderModel)
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_11030 ** 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_1916_wrap(lin);
+        *ppRenderModel = struct_RenderModel_t_11030_wrap(lin);
     return _ret;
 }
 
-void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1916 * pRenderModel)
+void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_11030 * pRenderModel)
 {
-    ((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1916_unwrap(pRenderModel));
+    ((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_11030_unwrap(pRenderModel));
 }
 
-vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1916 ** ppTexture)
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_11030 ** 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_1916_wrap(lin);
+        *ppTexture = struct_RenderModel_TextureMap_t_11030_wrap(lin);
     return _ret;
 }
 
-void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1916 * pTexture)
+void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_11030 * pTexture)
 {
-    ((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1916_unwrap(pTexture));
+    ((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_11030_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_1916_win_to_lin(pControllerState, &lin);
+        struct_VRControllerState001_t_11030_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;
 }

vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.h

@@ -1,10 +1,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1916 **);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *, const char *, winRenderModel_t_11030 **);
-extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_1916 *);
+extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_11030 *);
-extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1916 **);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_11030 **);
-extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_1916 *);
+extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_11030 *);
 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 *);

vrclient_x64/vrclient_x64/cppIVRResources_IVRResources_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRScreenshots_IVRScreenshots_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRSettings_IVRSettings_003.cpp

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

vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_021.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.9.16/ivrclientcore.h"
+#include "openvr_v1.10.30/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
@@ -159,27 +159,27 @@ const char * cppIVRSystem_IVRSystem_021_GetPropErrorNameFromEnum(void *linux_sid
     return ((IVRSystem*)linux_side)->GetPropErrorNameFromEnum((vr::ETrackedPropertyError)error);
 }
 
-bool cppIVRSystem_IVRSystem_021_PollNextEvent(void *linux_side, winVREvent_t_1916 * pEvent, uint32_t uncbVREvent)
+bool cppIVRSystem_IVRSystem_021_PollNextEvent(void *linux_side, winVREvent_t_11030 * pEvent, uint32_t uncbVREvent)
 {
     VREvent_t lin;
     bool _ret;
     if(pEvent)
-        struct_VREvent_t_1916_win_to_lin(pEvent, &lin);
+        struct_VREvent_t_11030_win_to_lin(pEvent, &lin);
     _ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, uncbVREvent ? sizeof(lin) : 0);
     if(pEvent)
-        struct_VREvent_t_1916_lin_to_win(&lin, pEvent, uncbVREvent);
+        struct_VREvent_t_11030_lin_to_win(&lin, pEvent, uncbVREvent);
     return _ret;
 }
 
-bool cppIVRSystem_IVRSystem_021_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1916 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+bool cppIVRSystem_IVRSystem_021_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_11030 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
 {
     VREvent_t lin;
     bool _ret;
     if(pEvent)
-        struct_VREvent_t_1916_win_to_lin(pEvent, &lin);
+        struct_VREvent_t_11030_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_1916_lin_to_win(&lin, pEvent, uncbVREvent);
+        struct_VREvent_t_11030_lin_to_win(&lin, pEvent, uncbVREvent);
     return _ret;
 }
 
@@ -193,27 +193,27 @@ vr::HiddenAreaMesh_t cppIVRSystem_IVRSystem_021_GetHiddenAreaMesh(void *linux_si
     return ((IVRSystem*)linux_side)->GetHiddenAreaMesh((vr::EVREye)eEye, (vr::EHiddenAreaMeshType)type);
 }
 
-bool cppIVRSystem_IVRSystem_021_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1916 * pControllerState, uint32_t unControllerStateSize)
+bool cppIVRSystem_IVRSystem_021_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_11030 * pControllerState, uint32_t unControllerStateSize)
 {
     VRControllerState001_t lin;
     bool _ret;
     if(pControllerState)
-        struct_VRControllerState001_t_1916_win_to_lin(pControllerState, &lin);
+        struct_VRControllerState001_t_11030_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_1916_lin_to_win(&lin, pControllerState, unControllerStateSize);
+        struct_VRControllerState001_t_11030_lin_to_win(&lin, pControllerState, unControllerStateSize);
     return _ret;
 }
 
-bool cppIVRSystem_IVRSystem_021_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1916 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+bool cppIVRSystem_IVRSystem_021_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_11030 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
 {
     VRControllerState001_t lin;
     bool _ret;
     if(pControllerState)
-        struct_VRControllerState001_t_1916_win_to_lin(pControllerState, &lin);
+        struct_VRControllerState001_t_11030_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_1916_lin_to_win(&lin, pControllerState, unControllerStateSize);
+        struct_VRControllerState001_t_11030_lin_to_win(&lin, pControllerState, unControllerStateSize);
     return _ret;
 }
 

vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_021.h

@@ -31,12 +31,12 @@ extern HmdMatrix34_t cppIVRSystem_IVRSystem_021_GetMatrix34TrackedDeviceProperty
 extern uint32_t cppIVRSystem_IVRSystem_021_GetArrayTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, PropertyTypeTag_t, void *, uint32_t, ETrackedPropertyError *);
 extern uint32_t cppIVRSystem_IVRSystem_021_GetStringTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, char *, uint32_t, ETrackedPropertyError *);
 extern const char * cppIVRSystem_IVRSystem_021_GetPropErrorNameFromEnum(void *, ETrackedPropertyError);
-extern bool cppIVRSystem_IVRSystem_021_PollNextEvent(void *, winVREvent_t_1916 *, uint32_t);
+extern bool cppIVRSystem_IVRSystem_021_PollNextEvent(void *, winVREvent_t_11030 *, uint32_t);
-extern bool cppIVRSystem_IVRSystem_021_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1916 *, uint32_t, TrackedDevicePose_t *);
+extern bool cppIVRSystem_IVRSystem_021_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_11030 *, uint32_t, TrackedDevicePose_t *);
 extern const char * cppIVRSystem_IVRSystem_021_GetEventTypeNameFromEnum(void *, EVREventType);
 extern HiddenAreaMesh_t cppIVRSystem_IVRSystem_021_GetHiddenAreaMesh(void *, EVREye, EHiddenAreaMeshType);
-extern bool cppIVRSystem_IVRSystem_021_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1916 *, uint32_t);
+extern bool cppIVRSystem_IVRSystem_021_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_11030 *, uint32_t);
-extern bool cppIVRSystem_IVRSystem_021_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1916 *, uint32_t, TrackedDevicePose_t *);
+extern bool cppIVRSystem_IVRSystem_021_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_11030 *, uint32_t, TrackedDevicePose_t *);
 extern void cppIVRSystem_IVRSystem_021_TriggerHapticPulse(void *, TrackedDeviceIndex_t, uint32_t, unsigned short);
 extern const char * cppIVRSystem_IVRSystem_021_GetButtonIdNameFromEnum(void *, EVRButtonId);
 extern const char * cppIVRSystem_IVRSystem_021_GetControllerAxisTypeNameFromEnum(void *, EVRControllerAxisType);

vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.9.16/ivrclientcore.h"
+#include "openvr_v1.10.30/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_1916 * 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_11030 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_1916_win_to_lin(pFrameHeader, &lin);
+        struct_CameraVideoStreamFrameHeader_t_11030_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_1916_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
+        struct_CameraVideoStreamFrameHeader_t_11030_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_1916 * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_11030 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_1916_win_to_lin(pFrameHeader, &lin);
+        struct_CameraVideoStreamFrameHeader_t_11030_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_1916_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
+        struct_CameraVideoStreamFrameHeader_t_11030_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_1916 * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_11030 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_1916_win_to_lin(pFrameHeader, &lin);
+        struct_CameraVideoStreamFrameHeader_t_11030_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_1916_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
+        struct_CameraVideoStreamFrameHeader_t_11030_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
     return _ret;
 }
 

vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.h

@@ -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_1916 *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, uint32_t, winCameraVideoStreamFrameHeader_t_11030 *, 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_1916 *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, void **, winCameraVideoStreamFrameHeader_t_11030 *, uint32_t);
-extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, winCameraVideoStreamFrameHeader_t_1916 *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, winCameraVideoStreamFrameHeader_t_11030 *, 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 *);

vrclient_x64/vrclient_x64/struct_converters.h

@@ -1,3 +1,34 @@
+typedef struct winVREvent_t_11030 winVREvent_t_11030;
+extern void struct_VREvent_t_11030_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_VREvent_t_11030_win_to_lin(void *w, void *l);
+typedef struct winVRControllerState001_t_11030 winVRControllerState001_t_11030;
+extern void struct_VRControllerState001_t_11030_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_VRControllerState001_t_11030_win_to_lin(void *w, void *l);
+typedef struct winCameraVideoStreamFrameHeader_t_11030 winCameraVideoStreamFrameHeader_t_11030;
+extern void struct_CameraVideoStreamFrameHeader_t_11030_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_CameraVideoStreamFrameHeader_t_11030_win_to_lin(void *w, void *l);
+typedef struct winRenderModel_TextureMap_t_11030 winRenderModel_TextureMap_t_11030;
+extern void struct_RenderModel_TextureMap_t_11030_lin_to_win(void *l, void *w);
+extern void struct_RenderModel_TextureMap_t_11030_win_to_lin(void *w, void *l);
+extern struct winRenderModel_TextureMap_t_11030 *struct_RenderModel_TextureMap_t_11030_wrap(void *l);
+extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_11030_unwrap(winRenderModel_TextureMap_t_11030 *w);
+typedef struct winRenderModel_t_11030 winRenderModel_t_11030;
+extern void struct_RenderModel_t_11030_lin_to_win(void *l, void *w);
+extern void struct_RenderModel_t_11030_win_to_lin(void *w, void *l);
+extern struct winRenderModel_t_11030 *struct_RenderModel_t_11030_wrap(void *l);
+extern RenderModel_t *struct_RenderModel_t_11030_unwrap(winRenderModel_t_11030 *w);
+typedef struct winInputAnalogActionData_t_11030 winInputAnalogActionData_t_11030;
+extern void struct_InputAnalogActionData_t_11030_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputAnalogActionData_t_11030_win_to_lin(void *w, void *l);
+typedef struct winInputDigitalActionData_t_11030 winInputDigitalActionData_t_11030;
+extern void struct_InputDigitalActionData_t_11030_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputDigitalActionData_t_11030_win_to_lin(void *w, void *l);
+typedef struct winInputPoseActionData_t_11030 winInputPoseActionData_t_11030;
+extern void struct_InputPoseActionData_t_11030_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputPoseActionData_t_11030_win_to_lin(void *w, void *l);
+typedef struct winInputSkeletalActionData_t_11030 winInputSkeletalActionData_t_11030;
+extern void struct_InputSkeletalActionData_t_11030_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputSkeletalActionData_t_11030_win_to_lin(void *w, void *l);
 typedef struct winVREvent_t_1916 winVREvent_t_1916;
 extern void struct_VREvent_t_1916_lin_to_win(void *l, void *w, uint32_t sz);
 extern void struct_VREvent_t_1916_win_to_lin(void *w, void *l);

vrclient_x64/vrclient_x64/struct_converters_11030.cpp

@@ -0,0 +1,331 @@
+#include <stdlib.h>
+#include <string.h>
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.10.30/openvr.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+#pragma pack(push, 8)
+struct winVREvent_t_11030 {
+    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_11030_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winVREvent_t_11030 *win = (struct winVREvent_t_11030 *)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_11030_win_to_lin(void *w, void *l)
+{
+    struct winVREvent_t_11030 *win = (struct winVREvent_t_11030 *)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_11030 {
+    uint32_t unPacketNum;
+    uint64_t ulButtonPressed;
+    uint64_t ulButtonTouched;
+    vr::VRControllerAxis_t rAxis[5];
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_VRControllerState001_t_11030_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winVRControllerState001_t_11030 *win = (struct winVRControllerState001_t_11030 *)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_11030_win_to_lin(void *w, void *l)
+{
+    struct winVRControllerState001_t_11030 *win = (struct winVRControllerState001_t_11030 *)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_11030 {
+    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_11030_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winCameraVideoStreamFrameHeader_t_11030 *win = (struct winCameraVideoStreamFrameHeader_t_11030 *)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_11030_win_to_lin(void *w, void *l)
+{
+    struct winCameraVideoStreamFrameHeader_t_11030 *win = (struct winCameraVideoStreamFrameHeader_t_11030 *)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_11030 {
+    uint16_t unWidth;
+    uint16_t unHeight;
+    const uint8_t * rubTextureMapData;
+
+    RenderModel_TextureMap_t *linux_side;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_RenderModel_TextureMap_t_11030_lin_to_win(void *l, void *w)
+{
+    struct winRenderModel_TextureMap_t_11030 *win = (struct winRenderModel_TextureMap_t_11030 *)w;
+    RenderModel_TextureMap_t *lin = (RenderModel_TextureMap_t *)l;
+    win->unWidth = lin->unWidth;
+    win->unHeight = lin->unHeight;
+    win->rubTextureMapData = lin->rubTextureMapData;
+}
+
+void struct_RenderModel_TextureMap_t_11030_win_to_lin(void *w, void *l)
+{
+    struct winRenderModel_TextureMap_t_11030 *win = (struct winRenderModel_TextureMap_t_11030 *)w;
+    RenderModel_TextureMap_t *lin = (RenderModel_TextureMap_t *)l;
+    lin->unWidth = win->unWidth;
+    lin->unHeight = win->unHeight;
+    lin->rubTextureMapData = win->rubTextureMapData;
+}
+
+struct winRenderModel_TextureMap_t_11030 *struct_RenderModel_TextureMap_t_11030_wrap(void *l)
+{
+    struct winRenderModel_TextureMap_t_11030 *win = (struct winRenderModel_TextureMap_t_11030 *)malloc(sizeof(*win));
+    RenderModel_TextureMap_t *lin = (RenderModel_TextureMap_t *)l;
+    win->unWidth = lin->unWidth;
+    win->unHeight = lin->unHeight;
+    win->rubTextureMapData = lin->rubTextureMapData;
+    win->linux_side = lin;
+    return win;
+}
+
+struct RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_11030_unwrap(winRenderModel_TextureMap_t_11030 *w)
+{
+    RenderModel_TextureMap_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+#pragma pack(push, 8)
+struct winRenderModel_t_11030 {
+    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_11030_lin_to_win(void *l, void *w)
+{
+    struct winRenderModel_t_11030 *win = (struct winRenderModel_t_11030 *)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_11030_win_to_lin(void *w, void *l)
+{
+    struct winRenderModel_t_11030 *win = (struct winRenderModel_t_11030 *)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_11030 *struct_RenderModel_t_11030_wrap(void *l)
+{
+    struct winRenderModel_t_11030 *win = (struct winRenderModel_t_11030 *)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_11030_unwrap(winRenderModel_t_11030 *w)
+{
+    RenderModel_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+#pragma pack(push, 8)
+struct winInputAnalogActionData_t_11030 {
+    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_11030_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputAnalogActionData_t_11030 *win = (struct winInputAnalogActionData_t_11030 *)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_11030_win_to_lin(void *w, void *l)
+{
+    struct winInputAnalogActionData_t_11030 *win = (struct winInputAnalogActionData_t_11030 *)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_11030 {
+    bool bActive;
+    vr::VRInputValueHandle_t activeOrigin;
+    bool bState;
+    bool bChanged;
+    float fUpdateTime;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_InputDigitalActionData_t_11030_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputDigitalActionData_t_11030 *win = (struct winInputDigitalActionData_t_11030 *)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_11030_win_to_lin(void *w, void *l)
+{
+    struct winInputDigitalActionData_t_11030 *win = (struct winInputDigitalActionData_t_11030 *)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_11030 {
+    bool bActive;
+    vr::VRInputValueHandle_t activeOrigin;
+    vr::TrackedDevicePose_t pose __attribute__((aligned(4)));
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_InputPoseActionData_t_11030_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputPoseActionData_t_11030 *win = (struct winInputPoseActionData_t_11030 *)w;
+    InputPoseActionData_t *lin = (InputPoseActionData_t *)l;
+    win->bActive = lin->bActive;
+    win->activeOrigin = lin->activeOrigin;
+    win->pose = lin->pose;
+}
+
+void struct_InputPoseActionData_t_11030_win_to_lin(void *w, void *l)
+{
+    struct winInputPoseActionData_t_11030 *win = (struct winInputPoseActionData_t_11030 *)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_11030 {
+    bool bActive;
+    vr::VRInputValueHandle_t activeOrigin;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_InputSkeletalActionData_t_11030_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputSkeletalActionData_t_11030 *win = (struct winInputSkeletalActionData_t_11030 *)w;
+    InputSkeletalActionData_t *lin = (InputSkeletalActionData_t *)l;
+    win->bActive = lin->bActive;
+    win->activeOrigin = lin->activeOrigin;
+}
+
+void struct_InputSkeletalActionData_t_11030_win_to_lin(void *w, void *l)
+{
+    struct winInputSkeletalActionData_t_11030 *win = (struct winInputSkeletalActionData_t_11030 *)w;
+    InputSkeletalActionData_t *lin = (InputSkeletalActionData_t *)l;
+    lin->bActive = win->bActive;
+    lin->activeOrigin = win->activeOrigin;
+}
+
+
+}

vrclient_x64/vrclient_x64/vrclient_defs.h

@@ -66,7 +66,10 @@ typedef int
         EVRSkeletalReferencePose,
         EVRSkeletalTrackingLevel,
         EVRSummaryType,
-        EVRSceneApplicationState;
+        EVRSceneApplicationState,
+        HeadsetViewMode_t,
+        EVRState,
+        vrmb_typeb;
 
 typedef uint32_t DriverId_t;
 typedef uint32_t TrackedDeviceIndex_t;
@@ -86,6 +89,8 @@ typedef uint64_t VRActionHandle_t;
 typedef uint64_t VRActionSetHandle_t;
 typedef uint64_t VRInputValueHandle_t;
 typedef int32_t BoneIndex_t;
+typedef uint64_t WebConsoleHandle_t;
+typedef uint64_t vrmb_typea;
 
 /* never dereferenced */
 typedef struct VROverlayIntersectionParams_t VROverlayIntersectionParams_t;
@@ -99,6 +104,7 @@ typedef struct VREvent_t VREvent_t;
 typedef struct Compositor_FrameTiming Compositor_FrameTiming;
 typedef struct Compositor_CumulativeStats Compositor_CumulativeStats;
 typedef struct Compositor_StageRenderSettings Compositor_StageRenderSettings;
+typedef struct Compositor_BenchmarkResults Compositor_BenchmarkResults;
 typedef struct AppOverrideKeys_t AppOverrideKeys_t;
 typedef struct VROverlayIntersectionMaskPrimitive_t VROverlayIntersectionMaskPrimitive_t;
 typedef struct NotificationBitmap_t NotificationBitmap_t;
@@ -125,6 +131,8 @@ typedef struct InputOriginInfo_t InputOriginInfo_t;
 typedef struct InputSkeletalActionData_t InputSkeletalActionData_t;
 typedef struct VRSkeletalSummaryData_t VRSkeletalSummaryData_t;
 typedef struct InputBindingInfo_t InputBindingInfo_t;
+typedef struct VRNativeDevice_t VRNativeDevice_t;
+typedef struct VROverlayView_t VROverlayView_t;
 
 /* dereferenced structs */
 typedef struct HmdMatrix34_t

vrclient_x64/vrclient_x64/vrclient_main.c

@@ -39,8 +39,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_1916 winRenderModel_t_1916;
+typedef struct winRenderModel_t_11030 winRenderModel_t_11030;
-typedef struct winRenderModel_TextureMap_t_1916 winRenderModel_TextureMap_t_1916;
+typedef struct winRenderModel_TextureMap_t_11030 winRenderModel_TextureMap_t_11030;
 #include "cppIVRRenderModels_IVRRenderModels_006.h"
 
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
@@ -1137,7 +1137,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_1916 **)texture_map);
+        return cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(linux_side, texture_id, (struct winRenderModel_TextureMap_t_11030 **)texture_map);
     }
     FIXME("Unsupported IVRRenderModels version! %u\n", version);
     return VRRenderModelError_NotSupported;
@@ -1154,7 +1154,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_1916 *)texture_map);
+        cppIVRRenderModels_IVRRenderModels_006_FreeTexture(linux_side, (struct winRenderModel_TextureMap_t_11030 *)texture_map);
         break;
     default:
         FIXME("Unsupported IVRRenderModels version! %u\n", version);

vrclient_x64/vrclient_x64/winIVRCompositor.c

@@ -18,6 +18,529 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
 
+#include "cppIVRCompositor_IVRCompositor_026.h"
+
+typedef struct __winIVRCompositor_IVRCompositor_026 {
+    vtable_ptr *vtable;
+    void *linux_side;
+    struct compositor_data user_data;
+} winIVRCompositor_IVRCompositor_026;
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_SetTrackingSpace, 8)
+void __thiscall winIVRCompositor_IVRCompositor_026_SetTrackingSpace(winIVRCompositor_IVRCompositor_026 *_this, ETrackingUniverseOrigin eOrigin)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_SetTrackingSpace(_this->linux_side, eOrigin);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetTrackingSpace, 4)
+ETrackingUniverseOrigin __thiscall winIVRCompositor_IVRCompositor_026_GetTrackingSpace(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetTrackingSpace(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_WaitGetPoses, 20)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_026_WaitGetPoses(winIVRCompositor_IVRCompositor_026 *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_WaitGetPoses(_this->linux_side, pRenderPoseArray, unRenderPoseArrayCount, pGamePoseArray, unGamePoseArrayCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetLastPoses, 20)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_026_GetLastPoses(winIVRCompositor_IVRCompositor_026 *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetLastPoses(_this->linux_side, pRenderPoseArray, unRenderPoseArrayCount, pGamePoseArray, unGamePoseArrayCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetLastPoseForTrackedDeviceIndex, 16)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_026_GetLastPoseForTrackedDeviceIndex(winIVRCompositor_IVRCompositor_026 *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetLastPoseForTrackedDeviceIndex(_this->linux_side, unDeviceIndex, pOutputPose, pOutputGamePose);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_Submit, 20)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_026_Submit(winIVRCompositor_IVRCompositor_026 *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    TRACE("%p\n", _this);
+    return ivrcompositor_submit(cppIVRCompositor_IVRCompositor_026_Submit, _this->linux_side, eEye, pTexture, pBounds, nSubmitFlags, 26, &_this->user_data);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_ClearLastSubmittedFrame, 4)
+void __thiscall winIVRCompositor_IVRCompositor_026_ClearLastSubmittedFrame(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_ClearLastSubmittedFrame(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_PostPresentHandoff, 4)
+void __thiscall winIVRCompositor_IVRCompositor_026_PostPresentHandoff(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    ivrcompositor_post_present_handoff(cppIVRCompositor_IVRCompositor_026_PostPresentHandoff, _this->linux_side, 26, &_this->user_data);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetFrameTiming, 12)
+bool __thiscall winIVRCompositor_IVRCompositor_026_GetFrameTiming(winIVRCompositor_IVRCompositor_026 *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetFrameTiming(_this->linux_side, pTiming, unFramesAgo);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetFrameTimings, 12)
+uint32_t __thiscall winIVRCompositor_IVRCompositor_026_GetFrameTimings(winIVRCompositor_IVRCompositor_026 *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetFrameTimings(_this->linux_side, pTiming, nFrames);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetFrameTimeRemaining, 4)
+float __thiscall winIVRCompositor_IVRCompositor_026_GetFrameTimeRemaining(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetFrameTimeRemaining(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetCumulativeStats, 12)
+void __thiscall winIVRCompositor_IVRCompositor_026_GetCumulativeStats(winIVRCompositor_IVRCompositor_026 *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_GetCumulativeStats(_this->linux_side, pStats, nStatsSizeInBytes);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_FadeToColor, 25)
+void __thiscall winIVRCompositor_IVRCompositor_026_FadeToColor(winIVRCompositor_IVRCompositor_026 *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_FadeToColor(_this->linux_side, fSeconds, fRed, fGreen, fBlue, fAlpha, bBackground);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetCurrentFadeColor, 9)
+HmdColor_t *__thiscall winIVRCompositor_IVRCompositor_026_GetCurrentFadeColor(winIVRCompositor_IVRCompositor_026 *_this, HmdColor_t *_r, bool bBackground)
+{
+    TRACE("%p\n", _this);
+    *_r = cppIVRCompositor_IVRCompositor_026_GetCurrentFadeColor(_this->linux_side, bBackground);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_FadeGrid, 9)
+void __thiscall winIVRCompositor_IVRCompositor_026_FadeGrid(winIVRCompositor_IVRCompositor_026 *_this, float fSeconds, bool bFadeIn)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_FadeGrid(_this->linux_side, fSeconds, bFadeIn);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetCurrentGridAlpha, 4)
+float __thiscall winIVRCompositor_IVRCompositor_026_GetCurrentGridAlpha(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetCurrentGridAlpha(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_SetSkyboxOverride, 12)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_026_SetSkyboxOverride(winIVRCompositor_IVRCompositor_026 *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_SetSkyboxOverride(_this->linux_side, pTextures, unTextureCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_ClearSkyboxOverride, 4)
+void __thiscall winIVRCompositor_IVRCompositor_026_ClearSkyboxOverride(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_ClearSkyboxOverride(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_CompositorBringToFront, 4)
+void __thiscall winIVRCompositor_IVRCompositor_026_CompositorBringToFront(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_CompositorBringToFront(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_CompositorGoToBack, 4)
+void __thiscall winIVRCompositor_IVRCompositor_026_CompositorGoToBack(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_CompositorGoToBack(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_CompositorQuit, 4)
+void __thiscall winIVRCompositor_IVRCompositor_026_CompositorQuit(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_CompositorQuit(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_IsFullscreen, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_026_IsFullscreen(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_IsFullscreen(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetCurrentSceneFocusProcess, 4)
+uint32_t __thiscall winIVRCompositor_IVRCompositor_026_GetCurrentSceneFocusProcess(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetCurrentSceneFocusProcess(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetLastFrameRenderer, 4)
+uint32_t __thiscall winIVRCompositor_IVRCompositor_026_GetLastFrameRenderer(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetLastFrameRenderer(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_CanRenderScene, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_026_CanRenderScene(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_CanRenderScene(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_ShowMirrorWindow, 4)
+void __thiscall winIVRCompositor_IVRCompositor_026_ShowMirrorWindow(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_ShowMirrorWindow(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_HideMirrorWindow, 4)
+void __thiscall winIVRCompositor_IVRCompositor_026_HideMirrorWindow(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_HideMirrorWindow(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_IsMirrorWindowVisible, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_026_IsMirrorWindowVisible(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_IsMirrorWindowVisible(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_CompositorDumpImages, 4)
+void __thiscall winIVRCompositor_IVRCompositor_026_CompositorDumpImages(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_CompositorDumpImages(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_ShouldAppRenderWithLowResources, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_026_ShouldAppRenderWithLowResources(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_ShouldAppRenderWithLowResources(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_ForceInterleavedReprojectionOn, 5)
+void __thiscall winIVRCompositor_IVRCompositor_026_ForceInterleavedReprojectionOn(winIVRCompositor_IVRCompositor_026 *_this, bool bOverride)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_ForceInterleavedReprojectionOn(_this->linux_side, bOverride);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_ForceReconnectProcess, 4)
+void __thiscall winIVRCompositor_IVRCompositor_026_ForceReconnectProcess(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_ForceReconnectProcess(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_SuspendRendering, 5)
+void __thiscall winIVRCompositor_IVRCompositor_026_SuspendRendering(winIVRCompositor_IVRCompositor_026 *_this, bool bSuspend)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_SuspendRendering(_this->linux_side, bSuspend);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetMirrorTextureD3D11, 16)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_026_GetMirrorTextureD3D11(winIVRCompositor_IVRCompositor_026 *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetMirrorTextureD3D11(_this->linux_side, eEye, pD3D11DeviceOrResource, ppD3D11ShaderResourceView);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_ReleaseMirrorTextureD3D11, 8)
+void __thiscall winIVRCompositor_IVRCompositor_026_ReleaseMirrorTextureD3D11(winIVRCompositor_IVRCompositor_026 *_this, void * pD3D11ShaderResourceView)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_ReleaseMirrorTextureD3D11(_this->linux_side, pD3D11ShaderResourceView);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetMirrorTextureGL, 16)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_026_GetMirrorTextureGL(winIVRCompositor_IVRCompositor_026 *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetMirrorTextureGL(_this->linux_side, eEye, pglTextureId, pglSharedTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_ReleaseSharedGLTexture, 12)
+bool __thiscall winIVRCompositor_IVRCompositor_026_ReleaseSharedGLTexture(winIVRCompositor_IVRCompositor_026 *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_ReleaseSharedGLTexture(_this->linux_side, glTextureId, glSharedTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_LockGLSharedTextureForAccess, 8)
+void __thiscall winIVRCompositor_IVRCompositor_026_LockGLSharedTextureForAccess(winIVRCompositor_IVRCompositor_026 *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_LockGLSharedTextureForAccess(_this->linux_side, glSharedTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_UnlockGLSharedTextureForAccess, 8)
+void __thiscall winIVRCompositor_IVRCompositor_026_UnlockGLSharedTextureForAccess(winIVRCompositor_IVRCompositor_026 *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_UnlockGLSharedTextureForAccess(_this->linux_side, glSharedTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired, 12)
+uint32_t __thiscall winIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired(winIVRCompositor_IVRCompositor_026 *_this, char * pchValue, uint32_t unBufferSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired(_this->linux_side, pchValue, unBufferSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetVulkanDeviceExtensionsRequired, 16)
+uint32_t __thiscall winIVRCompositor_IVRCompositor_026_GetVulkanDeviceExtensionsRequired(winIVRCompositor_IVRCompositor_026 *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize)
+{
+    TRACE("%p\n", _this);
+    return ivrcompositor_get_vulkan_device_extensions_required(cppIVRCompositor_IVRCompositor_026_GetVulkanDeviceExtensionsRequired, _this->linux_side, pPhysicalDevice, pchValue, unBufferSize, 26, &_this->user_data);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_SetExplicitTimingMode, 8)
+void __thiscall winIVRCompositor_IVRCompositor_026_SetExplicitTimingMode(winIVRCompositor_IVRCompositor_026 *_this, EVRCompositorTimingMode eTimingMode)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_SetExplicitTimingMode(_this->linux_side, eTimingMode);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_SubmitExplicitTimingData, 4)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_026_SubmitExplicitTimingData(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_SubmitExplicitTimingData(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_IsMotionSmoothingEnabled, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_026_IsMotionSmoothingEnabled(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_IsMotionSmoothingEnabled(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_IsMotionSmoothingSupported, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_026_IsMotionSmoothingSupported(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_IsMotionSmoothingSupported(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_IsCurrentSceneFocusAppLoading, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_026_IsCurrentSceneFocusAppLoading(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_IsCurrentSceneFocusAppLoading(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_SetStageOverride_Async, 20)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_026_SetStageOverride_Async(winIVRCompositor_IVRCompositor_026 *_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_026_SetStageOverride_Async(_this->linux_side, pchRenderModelPath ? lin_pchRenderModelPath : NULL, pTransform, pRenderSettings, nSizeOfRenderSettings);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_ClearStageOverride, 4)
+void __thiscall winIVRCompositor_IVRCompositor_026_ClearStageOverride(winIVRCompositor_IVRCompositor_026 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_026_ClearStageOverride(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetCompositorBenchmarkResults, 12)
+bool __thiscall winIVRCompositor_IVRCompositor_026_GetCompositorBenchmarkResults(winIVRCompositor_IVRCompositor_026 *_this, Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetCompositorBenchmarkResults(_this->linux_side, pBenchmarkResults, nSizeOfBenchmarkResults);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetLastPosePredictionIDs, 12)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_026_GetLastPosePredictionIDs(winIVRCompositor_IVRCompositor_026 *_this, uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetLastPosePredictionIDs(_this->linux_side, pRenderPosePredictionID, pGamePosePredictionID);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetPosesForFrame, 16)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_026_GetPosesForFrame(winIVRCompositor_IVRCompositor_026 *_this, uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_026_GetPosesForFrame(_this->linux_side, unPosePredictionID, pPoseArray, unPoseArrayCount);
+}
+
+extern vtable_ptr winIVRCompositor_IVRCompositor_026_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRCompositor_IVRCompositor_026,
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_SetTrackingSpace)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetTrackingSpace)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_WaitGetPoses)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetLastPoses)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetLastPoseForTrackedDeviceIndex)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_Submit)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_ClearLastSubmittedFrame)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_PostPresentHandoff)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetFrameTiming)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetFrameTimings)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetFrameTimeRemaining)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetCumulativeStats)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_FadeToColor)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetCurrentFadeColor)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_FadeGrid)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetCurrentGridAlpha)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_SetSkyboxOverride)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_ClearSkyboxOverride)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_CompositorBringToFront)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_CompositorGoToBack)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_CompositorQuit)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_IsFullscreen)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetCurrentSceneFocusProcess)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetLastFrameRenderer)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_CanRenderScene)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_ShowMirrorWindow)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_HideMirrorWindow)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_IsMirrorWindowVisible)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_CompositorDumpImages)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_ShouldAppRenderWithLowResources)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_ForceInterleavedReprojectionOn)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_ForceReconnectProcess)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_SuspendRendering)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetMirrorTextureD3D11)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_ReleaseMirrorTextureD3D11)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetMirrorTextureGL)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_ReleaseSharedGLTexture)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_LockGLSharedTextureForAccess)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_UnlockGLSharedTextureForAccess)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetVulkanDeviceExtensionsRequired)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_SetExplicitTimingMode)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_SubmitExplicitTimingData)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_IsMotionSmoothingEnabled)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_IsMotionSmoothingSupported)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_IsCurrentSceneFocusAppLoading)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_SetStageOverride_Async)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_ClearStageOverride)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetCompositorBenchmarkResults)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetLastPosePredictionIDs)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_026_GetPosesForFrame)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRCompositor_IVRCompositor_026 *create_winIVRCompositor_IVRCompositor_026(void *linux_side)
+{
+    winIVRCompositor_IVRCompositor_026 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_026));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRCompositor_IVRCompositor_026_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRCompositor_IVRCompositor_026(void *object)
+{
+    TRACE("%p\n", object);
+    struct __winIVRCompositor_IVRCompositor_026 *win_object = object;
+    destroy_compositor_data(&win_object->user_data);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRCompositor_IVRCompositor_026 *create_winIVRCompositor_IVRCompositor_026_FnTable(void *linux_side)
+{
+    winIVRCompositor_IVRCompositor_026 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_026));
+    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_026_SetTrackingSpace, 1, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_026_GetTrackingSpace, 0, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_026_WaitGetPoses, 4, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_026_GetLastPoses, 4, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_026_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_026_Submit, 4, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_026_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_026_PostPresentHandoff, 0, FALSE, FALSE);
+    init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_026_GetFrameTiming, 2, FALSE, FALSE);
+    init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_026_GetFrameTimings, 2, FALSE, FALSE);
+    init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_026_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_026_GetCumulativeStats, 2, FALSE, FALSE);
+    init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_026_FadeToColor, 6, TRUE, TRUE);
+    init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_026_GetCurrentFadeColor, 2, FALSE, FALSE);
+    init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_026_FadeGrid, 2, TRUE, FALSE);
+    init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_026_GetCurrentGridAlpha, 0, FALSE, FALSE);
+    init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_026_SetSkyboxOverride, 2, FALSE, FALSE);
+    init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_026_ClearSkyboxOverride, 0, FALSE, FALSE);
+    init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_026_CompositorBringToFront, 0, FALSE, FALSE);
+    init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_026_CompositorGoToBack, 0, FALSE, FALSE);
+    init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_026_CompositorQuit, 0, FALSE, FALSE);
+    init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_026_IsFullscreen, 0, FALSE, FALSE);
+    init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_026_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_026_GetLastFrameRenderer, 0, FALSE, FALSE);
+    init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_026_CanRenderScene, 0, FALSE, FALSE);
+    init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_026_ShowMirrorWindow, 0, FALSE, FALSE);
+    init_thunk(&thunks[26], r, winIVRCompositor_IVRCompositor_026_HideMirrorWindow, 0, FALSE, FALSE);
+    init_thunk(&thunks[27], r, winIVRCompositor_IVRCompositor_026_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    init_thunk(&thunks[28], r, winIVRCompositor_IVRCompositor_026_CompositorDumpImages, 0, FALSE, FALSE);
+    init_thunk(&thunks[29], r, winIVRCompositor_IVRCompositor_026_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    init_thunk(&thunks[30], r, winIVRCompositor_IVRCompositor_026_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    init_thunk(&thunks[31], r, winIVRCompositor_IVRCompositor_026_ForceReconnectProcess, 0, FALSE, FALSE);
+    init_thunk(&thunks[32], r, winIVRCompositor_IVRCompositor_026_SuspendRendering, 1, FALSE, FALSE);
+    init_thunk(&thunks[33], r, winIVRCompositor_IVRCompositor_026_GetMirrorTextureD3D11, 3, FALSE, FALSE);
+    init_thunk(&thunks[34], r, winIVRCompositor_IVRCompositor_026_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
+    init_thunk(&thunks[35], r, winIVRCompositor_IVRCompositor_026_GetMirrorTextureGL, 3, FALSE, FALSE);
+    init_thunk(&thunks[36], r, winIVRCompositor_IVRCompositor_026_ReleaseSharedGLTexture, 2, FALSE, FALSE);
+    init_thunk(&thunks[37], r, winIVRCompositor_IVRCompositor_026_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    init_thunk(&thunks[38], r, winIVRCompositor_IVRCompositor_026_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    init_thunk(&thunks[39], r, winIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
+    init_thunk(&thunks[40], r, winIVRCompositor_IVRCompositor_026_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
+    init_thunk(&thunks[41], r, winIVRCompositor_IVRCompositor_026_SetExplicitTimingMode, 1, FALSE, FALSE);
+    init_thunk(&thunks[42], r, winIVRCompositor_IVRCompositor_026_SubmitExplicitTimingData, 0, FALSE, FALSE);
+    init_thunk(&thunks[43], r, winIVRCompositor_IVRCompositor_026_IsMotionSmoothingEnabled, 0, FALSE, FALSE);
+    init_thunk(&thunks[44], r, winIVRCompositor_IVRCompositor_026_IsMotionSmoothingSupported, 0, FALSE, FALSE);
+    init_thunk(&thunks[45], r, winIVRCompositor_IVRCompositor_026_IsCurrentSceneFocusAppLoading, 0, FALSE, FALSE);
+    init_thunk(&thunks[46], r, winIVRCompositor_IVRCompositor_026_SetStageOverride_Async, 4, FALSE, FALSE);
+    init_thunk(&thunks[47], r, winIVRCompositor_IVRCompositor_026_ClearStageOverride, 0, FALSE, FALSE);
+    init_thunk(&thunks[48], r, winIVRCompositor_IVRCompositor_026_GetCompositorBenchmarkResults, 2, FALSE, FALSE);
+    init_thunk(&thunks[49], r, winIVRCompositor_IVRCompositor_026_GetLastPosePredictionIDs, 2, FALSE, FALSE);
+    init_thunk(&thunks[50], r, winIVRCompositor_IVRCompositor_026_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_026_FnTable(void *object)
+{
+    winIVRCompositor_IVRCompositor_026 *win_object = object;
+    TRACE("%p\n", win_object);
+    destroy_compositor_data(&win_object->user_data);
+    VirtualFree(win_object->vtable[0], 0, MEM_RELEASE);
+    HeapFree(GetProcessHeap(), 0, win_object->vtable);
+    HeapFree(GetProcessHeap(), 0, win_object);
+}
+
 #include "cppIVRCompositor_IVRCompositor_024.h"
 
 typedef struct __winIVRCompositor_IVRCompositor_024 {
@@ -352,8 +875,10 @@ bool __thiscall winIVRCompositor_IVRCompositor_024_IsCurrentSceneFocusAppLoading
 DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_024_SetStageOverride_Async, 20)
 EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_024_SetStageOverride_Async(winIVRCompositor_IVRCompositor_024 *_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_024_SetStageOverride_Async(_this->linux_side, pchRenderModelPath, pTransform, pRenderSettings, nSizeOfRenderSettings);
+    return cppIVRCompositor_IVRCompositor_024_SetStageOverride_Async(_this->linux_side, pchRenderModelPath ? lin_pchRenderModelPath : NULL, pTransform, pRenderSettings, nSizeOfRenderSettings);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_024_ClearStageOverride, 4)

vrclient_x64/vrclient_x64/winIVRControlPanel.c

@@ -0,0 +1,333 @@
+/* This file is auto-generated, do not edit. */
+#include <stdarg.h>
+#include <stdint.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wine/debug.h"
+
+#include "cxx.h"
+
+#include "vrclient_defs.h"
+
+#include "vrclient_private.h"
+
+#include "struct_converters.h"
+
+#include "flatapi.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
+
+#include "cppIVRControlPanel_IVRControlPanel_006.h"
+
+typedef struct __winIVRControlPanel_IVRControlPanel_006 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVRControlPanel_IVRControlPanel_006;
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc1, 4)
+uint32_t __thiscall winIVRControlPanel_IVRControlPanel_006_undoc1(winIVRControlPanel_IVRControlPanel_006 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc1(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc2, 16)
+uint32_t __thiscall winIVRControlPanel_IVRControlPanel_006_undoc2(winIVRControlPanel_IVRControlPanel_006 *_this, uint32_t a, char * b, uint32_t c)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc2(_this->linux_side, a, b, c);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc3, 8)
+EVRInitError __thiscall winIVRControlPanel_IVRControlPanel_006_undoc3(winIVRControlPanel_IVRControlPanel_006 *_this, const char * a)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc3(_this->linux_side, a);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc4, 8)
+uint32_t __thiscall winIVRControlPanel_IVRControlPanel_006_undoc4(winIVRControlPanel_IVRControlPanel_006 *_this, const char * a)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc4(_this->linux_side, a);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc5, 20)
+uint32_t __thiscall winIVRControlPanel_IVRControlPanel_006_undoc5(winIVRControlPanel_IVRControlPanel_006 *_this, const char * a, uint32_t b, char * c, uint32_t d)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc5(_this->linux_side, a, b, c, d);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc6, 20)
+uint32_t __thiscall winIVRControlPanel_IVRControlPanel_006_undoc6(winIVRControlPanel_IVRControlPanel_006 *_this, const char * a, const char * b, char * c, uint32_t d)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc6(_this->linux_side, a, b, c, d);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc7, 20)
+uint32_t __thiscall winIVRControlPanel_IVRControlPanel_006_undoc7(winIVRControlPanel_IVRControlPanel_006 *_this, const char * a, const char * b, char * c, uint32_t d)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc7(_this->linux_side, a, b, c, d);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc8, 8)
+bool __thiscall winIVRControlPanel_IVRControlPanel_006_undoc8(winIVRControlPanel_IVRControlPanel_006 *_this, uint32_t a)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc8(_this->linux_side, a);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc9, 4)
+void __thiscall winIVRControlPanel_IVRControlPanel_006_undoc9(winIVRControlPanel_IVRControlPanel_006 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRControlPanel_IVRControlPanel_006_undoc9(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc10, 4)
+void __thiscall winIVRControlPanel_IVRControlPanel_006_undoc10(winIVRControlPanel_IVRControlPanel_006 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRControlPanel_IVRControlPanel_006_undoc10(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc11, 8)
+bool __thiscall winIVRControlPanel_IVRControlPanel_006_undoc11(winIVRControlPanel_IVRControlPanel_006 *_this, uint32_t a)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc11(_this->linux_side, a);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc12, 4)
+void __thiscall winIVRControlPanel_IVRControlPanel_006_undoc12(winIVRControlPanel_IVRControlPanel_006 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRControlPanel_IVRControlPanel_006_undoc12(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc13, 8)
+void __thiscall winIVRControlPanel_IVRControlPanel_006_undoc13(winIVRControlPanel_IVRControlPanel_006 *_this, TrackedDeviceIndex_t a)
+{
+    TRACE("%p\n", _this);
+    cppIVRControlPanel_IVRControlPanel_006_undoc13(_this->linux_side, a);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc14, 8)
+void __thiscall winIVRControlPanel_IVRControlPanel_006_undoc14(winIVRControlPanel_IVRControlPanel_006 *_this, EVRState a)
+{
+    TRACE("%p\n", _this);
+    cppIVRControlPanel_IVRControlPanel_006_undoc14(_this->linux_side, a);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc15, 4)
+EVRState __thiscall winIVRControlPanel_IVRControlPanel_006_undoc15(winIVRControlPanel_IVRControlPanel_006 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc15(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc16, 5)
+void __thiscall winIVRControlPanel_IVRControlPanel_006_undoc16(winIVRControlPanel_IVRControlPanel_006 *_this, bool a)
+{
+    TRACE("%p\n", _this);
+    cppIVRControlPanel_IVRControlPanel_006_undoc16(_this->linux_side, a);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc17, 4)
+bool __thiscall winIVRControlPanel_IVRControlPanel_006_undoc17(winIVRControlPanel_IVRControlPanel_006 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc17(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc18, 4)
+EVRApplicationError __thiscall winIVRControlPanel_IVRControlPanel_006_undoc18(winIVRControlPanel_IVRControlPanel_006 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc18(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc19, 5)
+void __thiscall winIVRControlPanel_IVRControlPanel_006_undoc19(winIVRControlPanel_IVRControlPanel_006 *_this, bool a)
+{
+    TRACE("%p\n", _this);
+    cppIVRControlPanel_IVRControlPanel_006_undoc19(_this->linux_side, a);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc20, 4)
+bool __thiscall winIVRControlPanel_IVRControlPanel_006_undoc20(winIVRControlPanel_IVRControlPanel_006 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc20(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc21, 4)
+EVRInitError __thiscall winIVRControlPanel_IVRControlPanel_006_undoc21(winIVRControlPanel_IVRControlPanel_006 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc21(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc22, 28)
+void __thiscall winIVRControlPanel_IVRControlPanel_006_undoc22(winIVRControlPanel_IVRControlPanel_006 *_this, WebConsoleHandle_t a, const char * b, uint32_t c, uint32_t d, const char * e)
+{
+    TRACE("%p\n", _this);
+    cppIVRControlPanel_IVRControlPanel_006_undoc22(_this->linux_side, a, b, c, d, e);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc23, 8)
+bool __thiscall winIVRControlPanel_IVRControlPanel_006_undoc23(winIVRControlPanel_IVRControlPanel_006 *_this, const char * a)
+{
+    char lin_a[PATH_MAX];
+    vrclient_dos_path_to_unix_path(a, lin_a);
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc23(_this->linux_side, a ? lin_a : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc24, 4)
+bool __thiscall winIVRControlPanel_IVRControlPanel_006_undoc24(winIVRControlPanel_IVRControlPanel_006 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc24(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc25, 5)
+bool __thiscall winIVRControlPanel_IVRControlPanel_006_undoc25(winIVRControlPanel_IVRControlPanel_006 *_this, bool a)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc25(_this->linux_side, a);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc26, 4)
+uint64_t __thiscall winIVRControlPanel_IVRControlPanel_006_undoc26(winIVRControlPanel_IVRControlPanel_006 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc26(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc27, 8)
+EVRCompositorError __thiscall winIVRControlPanel_IVRControlPanel_006_undoc27(winIVRControlPanel_IVRControlPanel_006 *_this, const char * a)
+{
+    char lin_a[PATH_MAX];
+    vrclient_dos_path_to_unix_path(a, lin_a);
+    TRACE("%p\n", _this);
+    return cppIVRControlPanel_IVRControlPanel_006_undoc27(_this->linux_side, a ? lin_a : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRControlPanel_IVRControlPanel_006_undoc28, 12)
+void __thiscall winIVRControlPanel_IVRControlPanel_006_undoc28(winIVRControlPanel_IVRControlPanel_006 *_this, VROverlayHandle_t a)
+{
+    TRACE("%p\n", _this);
+    cppIVRControlPanel_IVRControlPanel_006_undoc28(_this->linux_side, a);
+}
+
+extern vtable_ptr winIVRControlPanel_IVRControlPanel_006_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRControlPanel_IVRControlPanel_006,
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc1)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc2)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc3)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc4)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc5)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc6)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc7)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc8)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc9)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc10)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc11)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc12)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc13)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc14)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc15)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc16)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc17)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc18)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc19)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc20)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc21)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc22)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc23)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc24)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc25)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc26)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc27)
+        VTABLE_ADD_FUNC(winIVRControlPanel_IVRControlPanel_006_undoc28)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRControlPanel_IVRControlPanel_006 *create_winIVRControlPanel_IVRControlPanel_006(void *linux_side)
+{
+    winIVRControlPanel_IVRControlPanel_006 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRControlPanel_IVRControlPanel_006));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRControlPanel_IVRControlPanel_006_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRControlPanel_IVRControlPanel_006(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRControlPanel_IVRControlPanel_006 *create_winIVRControlPanel_IVRControlPanel_006_FnTable(void *linux_side)
+{
+    winIVRControlPanel_IVRControlPanel_006 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRControlPanel_IVRControlPanel_006));
+    struct thunk *thunks = alloc_thunks(28);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 28 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVRControlPanel_IVRControlPanel_006_undoc1, 0, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVRControlPanel_IVRControlPanel_006_undoc2, 3, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVRControlPanel_IVRControlPanel_006_undoc3, 1, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVRControlPanel_IVRControlPanel_006_undoc4, 1, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVRControlPanel_IVRControlPanel_006_undoc5, 4, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVRControlPanel_IVRControlPanel_006_undoc6, 4, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVRControlPanel_IVRControlPanel_006_undoc7, 4, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVRControlPanel_IVRControlPanel_006_undoc8, 1, FALSE, FALSE);
+    init_thunk(&thunks[8], r, winIVRControlPanel_IVRControlPanel_006_undoc9, 0, FALSE, FALSE);
+    init_thunk(&thunks[9], r, winIVRControlPanel_IVRControlPanel_006_undoc10, 0, FALSE, FALSE);
+    init_thunk(&thunks[10], r, winIVRControlPanel_IVRControlPanel_006_undoc11, 1, FALSE, FALSE);
+    init_thunk(&thunks[11], r, winIVRControlPanel_IVRControlPanel_006_undoc12, 0, FALSE, FALSE);
+    init_thunk(&thunks[12], r, winIVRControlPanel_IVRControlPanel_006_undoc13, 1, FALSE, FALSE);
+    init_thunk(&thunks[13], r, winIVRControlPanel_IVRControlPanel_006_undoc14, 1, FALSE, FALSE);
+    init_thunk(&thunks[14], r, winIVRControlPanel_IVRControlPanel_006_undoc15, 0, FALSE, FALSE);
+    init_thunk(&thunks[15], r, winIVRControlPanel_IVRControlPanel_006_undoc16, 1, FALSE, FALSE);
+    init_thunk(&thunks[16], r, winIVRControlPanel_IVRControlPanel_006_undoc17, 0, FALSE, FALSE);
+    init_thunk(&thunks[17], r, winIVRControlPanel_IVRControlPanel_006_undoc18, 0, FALSE, FALSE);
+    init_thunk(&thunks[18], r, winIVRControlPanel_IVRControlPanel_006_undoc19, 1, FALSE, FALSE);
+    init_thunk(&thunks[19], r, winIVRControlPanel_IVRControlPanel_006_undoc20, 0, FALSE, FALSE);
+    init_thunk(&thunks[20], r, winIVRControlPanel_IVRControlPanel_006_undoc21, 0, FALSE, FALSE);
+    init_thunk(&thunks[21], r, winIVRControlPanel_IVRControlPanel_006_undoc22, 5, FALSE, FALSE);
+    init_thunk(&thunks[22], r, winIVRControlPanel_IVRControlPanel_006_undoc23, 1, FALSE, FALSE);
+    init_thunk(&thunks[23], r, winIVRControlPanel_IVRControlPanel_006_undoc24, 0, FALSE, FALSE);
+    init_thunk(&thunks[24], r, winIVRControlPanel_IVRControlPanel_006_undoc25, 1, FALSE, FALSE);
+    init_thunk(&thunks[25], r, winIVRControlPanel_IVRControlPanel_006_undoc26, 0, FALSE, FALSE);
+    init_thunk(&thunks[26], r, winIVRControlPanel_IVRControlPanel_006_undoc27, 1, FALSE, FALSE);
+    init_thunk(&thunks[27], r, winIVRControlPanel_IVRControlPanel_006_undoc28, 1, FALSE, FALSE);
+    for (i = 0; i < 28; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVRControlPanel_IVRControlPanel_006_FnTable(void *object)
+{
+    winIVRControlPanel_IVRControlPanel_006 *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);
+}
+

vrclient_x64/vrclient_x64/winIVRHeadsetView.c

@@ -0,0 +1,158 @@
+/* This file is auto-generated, do not edit. */
+#include <stdarg.h>
+#include <stdint.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wine/debug.h"
+
+#include "cxx.h"
+
+#include "vrclient_defs.h"
+
+#include "vrclient_private.h"
+
+#include "struct_converters.h"
+
+#include "flatapi.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
+
+#include "cppIVRHeadsetView_IVRHeadsetView_001.h"
+
+typedef struct __winIVRHeadsetView_IVRHeadsetView_001 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVRHeadsetView_IVRHeadsetView_001;
+
+DEFINE_THISCALL_WRAPPER(winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewSize, 12)
+void __thiscall winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewSize(winIVRHeadsetView_IVRHeadsetView_001 *_this, uint32_t nWidth, uint32_t nHeight)
+{
+    TRACE("%p\n", _this);
+    cppIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewSize(_this->linux_side, nWidth, nHeight);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewSize, 12)
+void __thiscall winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewSize(winIVRHeadsetView_IVRHeadsetView_001 *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    TRACE("%p\n", _this);
+    cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewSize(_this->linux_side, pnWidth, pnHeight);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewMode, 8)
+void __thiscall winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewMode(winIVRHeadsetView_IVRHeadsetView_001 *_this, HeadsetViewMode_t eHeadsetViewMode)
+{
+    TRACE("%p\n", _this);
+    cppIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewMode(_this->linux_side, eHeadsetViewMode);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewMode, 4)
+HeadsetViewMode_t __thiscall winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewMode(winIVRHeadsetView_IVRHeadsetView_001 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewMode(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewCropped, 5)
+void __thiscall winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewCropped(winIVRHeadsetView_IVRHeadsetView_001 *_this, bool bCropped)
+{
+    TRACE("%p\n", _this);
+    cppIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewCropped(_this->linux_side, bCropped);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewCropped, 4)
+bool __thiscall winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewCropped(winIVRHeadsetView_IVRHeadsetView_001 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewCropped(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewAspectRatio, 4)
+float __thiscall winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewAspectRatio(winIVRHeadsetView_IVRHeadsetView_001 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewAspectRatio(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewBlendRange, 12)
+void __thiscall winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewBlendRange(winIVRHeadsetView_IVRHeadsetView_001 *_this, float flStartPct, float flEndPct)
+{
+    TRACE("%p\n", _this);
+    cppIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewBlendRange(_this->linux_side, flStartPct, flEndPct);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewBlendRange, 12)
+void __thiscall winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewBlendRange(winIVRHeadsetView_IVRHeadsetView_001 *_this, float * pStartPct, float * pEndPct)
+{
+    TRACE("%p\n", _this);
+    cppIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewBlendRange(_this->linux_side, pStartPct, pEndPct);
+}
+
+extern vtable_ptr winIVRHeadsetView_IVRHeadsetView_001_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRHeadsetView_IVRHeadsetView_001,
+        VTABLE_ADD_FUNC(winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewSize)
+        VTABLE_ADD_FUNC(winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewSize)
+        VTABLE_ADD_FUNC(winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewMode)
+        VTABLE_ADD_FUNC(winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewMode)
+        VTABLE_ADD_FUNC(winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewCropped)
+        VTABLE_ADD_FUNC(winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewCropped)
+        VTABLE_ADD_FUNC(winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewAspectRatio)
+        VTABLE_ADD_FUNC(winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewBlendRange)
+        VTABLE_ADD_FUNC(winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewBlendRange)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRHeadsetView_IVRHeadsetView_001 *create_winIVRHeadsetView_IVRHeadsetView_001(void *linux_side)
+{
+    winIVRHeadsetView_IVRHeadsetView_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRHeadsetView_IVRHeadsetView_001));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRHeadsetView_IVRHeadsetView_001_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRHeadsetView_IVRHeadsetView_001(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRHeadsetView_IVRHeadsetView_001 *create_winIVRHeadsetView_IVRHeadsetView_001_FnTable(void *linux_side)
+{
+    winIVRHeadsetView_IVRHeadsetView_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRHeadsetView_IVRHeadsetView_001));
+    struct thunk *thunks = alloc_thunks(9);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 9 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewSize, 2, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewSize, 2, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewMode, 1, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewMode, 0, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewCropped, 1, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewCropped, 0, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewAspectRatio, 0, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVRHeadsetView_IVRHeadsetView_001_SetHeadsetViewBlendRange, 2, TRUE, FALSE);
+    init_thunk(&thunks[8], r, winIVRHeadsetView_IVRHeadsetView_001_GetHeadsetViewBlendRange, 2, FALSE, FALSE);
+    for (i = 0; i < 9; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVRHeadsetView_IVRHeadsetView_001_FnTable(void *object)
+{
+    winIVRHeadsetView_IVRHeadsetView_001 *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);
+}
+

vrclient_x64/vrclient_x64/winIVRInput.c

@@ -18,6 +18,353 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
 
+#include "cppIVRInput_IVRInput_010.h"
+
+typedef struct __winIVRInput_IVRInput_010 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVRInput_IVRInput_010;
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_SetActionManifestPath, 8)
+EVRInputError __thiscall winIVRInput_IVRInput_010_SetActionManifestPath(winIVRInput_IVRInput_010 *_this, const char * pchActionManifestPath)
+{
+    char lin_pchActionManifestPath[PATH_MAX];
+    vrclient_dos_path_to_unix_path(pchActionManifestPath, lin_pchActionManifestPath);
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_SetActionManifestPath(_this->linux_side, pchActionManifestPath ? lin_pchActionManifestPath : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetActionSetHandle, 12)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetActionSetHandle(winIVRInput_IVRInput_010 *_this, const char * pchActionSetName, VRActionSetHandle_t * pHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetActionSetHandle(_this->linux_side, pchActionSetName, pHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetActionHandle, 12)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetActionHandle(winIVRInput_IVRInput_010 *_this, const char * pchActionName, VRActionHandle_t * pHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetActionHandle(_this->linux_side, pchActionName, pHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetInputSourceHandle, 12)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetInputSourceHandle(winIVRInput_IVRInput_010 *_this, const char * pchInputSourcePath, VRInputValueHandle_t * pHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetInputSourceHandle(_this->linux_side, pchInputSourcePath, pHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_UpdateActionState, 16)
+EVRInputError __thiscall winIVRInput_IVRInput_010_UpdateActionState(winIVRInput_IVRInput_010 *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_UpdateActionState(_this->linux_side, pSets, unSizeOfVRSelectedActionSet_t, unSetCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetDigitalActionData, 28)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetDigitalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputDigitalActionData_t_11030 * 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_11030 * 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_11030 * 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_11030 * 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_11030 * pActionData, uint32_t unActionDataSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetSkeletalActionData(_this->linux_side, action, pActionData, unActionDataSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetDominantHand, 8)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetDominantHand(winIVRInput_IVRInput_010 *_this, ETrackedControllerRole * peDominantHand)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetDominantHand(_this->linux_side, peDominantHand);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_SetDominantHand, 8)
+EVRInputError __thiscall winIVRInput_IVRInput_010_SetDominantHand(winIVRInput_IVRInput_010 *_this, ETrackedControllerRole eDominantHand)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_SetDominantHand(_this->linux_side, eDominantHand);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetBoneCount, 16)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetBoneCount(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, uint32_t * pBoneCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetBoneCount(_this->linux_side, action, pBoneCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetBoneHierarchy, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetBoneHierarchy(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetBoneHierarchy(_this->linux_side, action, pParentIndices, unIndexArayCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetBoneName, 24)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetBoneName(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetBoneName(_this->linux_side, action, nBoneIndex, pchBoneName, unNameBufferSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetSkeletalReferenceTransforms, 28)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetSkeletalReferenceTransforms(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetSkeletalReferenceTransforms(_this->linux_side, action, eTransformSpace, eReferencePose, pTransformArray, unTransformArrayCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetSkeletalTrackingLevel, 16)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetSkeletalTrackingLevel(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetSkeletalTrackingLevel(_this->linux_side, action, pSkeletalTrackingLevel);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetSkeletalBoneData, 28)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetSkeletalBoneData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetSkeletalBoneData(_this->linux_side, action, eTransformSpace, eMotionRange, pTransformArray, unTransformArrayCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetSkeletalSummaryData, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetSkeletalSummaryData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetSkeletalSummaryData(_this->linux_side, action, eSummaryType, pSkeletalSummaryData);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetSkeletalBoneDataCompressed, 28)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetSkeletalBoneDataCompressed(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetSkeletalBoneDataCompressed(_this->linux_side, action, eMotionRange, pvCompressedData, unCompressedSize, punRequiredCompressedSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_DecompressSkeletalBoneData, 24)
+EVRInputError __thiscall winIVRInput_IVRInput_010_DecompressSkeletalBoneData(winIVRInput_IVRInput_010 *_this, const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_DecompressSkeletalBoneData(_this->linux_side, pvCompressedBuffer, unCompressedBufferSize, eTransformSpace, pTransformArray, unTransformArrayCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_TriggerHapticVibrationAction, 36)
+EVRInputError __thiscall winIVRInput_IVRInput_010_TriggerHapticVibrationAction(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_TriggerHapticVibrationAction(_this->linux_side, action, fStartSecondsFromNow, fDurationSeconds, fFrequency, fAmplitude, ulRestrictToDevice);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetActionOrigins, 28)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetActionOrigins(winIVRInput_IVRInput_010 *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetActionOrigins(_this->linux_side, actionSetHandle, digitalActionHandle, originsOut, originOutCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetOriginLocalizedName, 24)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetOriginLocalizedName(winIVRInput_IVRInput_010 *_this, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetOriginLocalizedName(_this->linux_side, origin, pchNameArray, unNameArraySize, unStringSectionsToInclude);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetOriginTrackedDeviceInfo, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetOriginTrackedDeviceInfo(winIVRInput_IVRInput_010 *_this, VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetOriginTrackedDeviceInfo(_this->linux_side, origin, pOriginInfo, unOriginInfoSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetActionBindingInfo, 28)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetActionBindingInfo(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t * punReturnedBindingInfoCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetActionBindingInfo(_this->linux_side, action, pOriginInfo, unBindingInfoSize, unBindingInfoCount, punReturnedBindingInfoCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_ShowActionOrigins, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_010_ShowActionOrigins(winIVRInput_IVRInput_010 *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_ShowActionOrigins(_this->linux_side, actionSetHandle, ulActionHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_ShowBindingsForActionSet, 24)
+EVRInputError __thiscall winIVRInput_IVRInput_010_ShowBindingsForActionSet(winIVRInput_IVRInput_010 *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_ShowBindingsForActionSet(_this->linux_side, pSets, unSizeOfVRSelectedActionSet_t, unSetCount, originToHighlight);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetComponentStateForBinding, 28)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetComponentStateForBinding(winIVRInput_IVRInput_010 *_this, const char * pchRenderModelName, const char * pchComponentName, InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, RenderModel_ComponentState_t * pComponentState)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetComponentStateForBinding(_this->linux_side, pchRenderModelName, pchComponentName, pOriginInfo, unBindingInfoSize, unBindingInfoCount, pComponentState);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_IsUsingLegacyInput, 4)
+bool __thiscall winIVRInput_IVRInput_010_IsUsingLegacyInput(winIVRInput_IVRInput_010 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_IsUsingLegacyInput(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_OpenBindingUI, 25)
+EVRInputError __thiscall winIVRInput_IVRInput_010_OpenBindingUI(winIVRInput_IVRInput_010 *_this, const char * pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_OpenBindingUI(_this->linux_side, pchAppKey, ulActionSetHandle, ulDeviceHandle, bShowOnDesktop);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetBindingVariant, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetBindingVariant(winIVRInput_IVRInput_010 *_this, VRInputValueHandle_t ulDevicePath, char * pchVariantArray, uint32_t unVariantArraySize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_010_GetBindingVariant(_this->linux_side, ulDevicePath, pchVariantArray, unVariantArraySize);
+}
+
+extern vtable_ptr winIVRInput_IVRInput_010_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRInput_IVRInput_010,
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_SetActionManifestPath)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetActionSetHandle)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetActionHandle)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetInputSourceHandle)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_UpdateActionState)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetDigitalActionData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetAnalogActionData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetPoseActionDataForNextFrame)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetSkeletalActionData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetDominantHand)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_SetDominantHand)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetBoneCount)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetBoneHierarchy)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetBoneName)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetSkeletalReferenceTransforms)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetSkeletalTrackingLevel)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetSkeletalBoneData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetSkeletalSummaryData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetSkeletalBoneDataCompressed)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_DecompressSkeletalBoneData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_TriggerHapticVibrationAction)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetActionOrigins)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetOriginLocalizedName)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetOriginTrackedDeviceInfo)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetActionBindingInfo)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_ShowActionOrigins)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_ShowBindingsForActionSet)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetComponentStateForBinding)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_IsUsingLegacyInput)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_OpenBindingUI)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_010_GetBindingVariant)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRInput_IVRInput_010 *create_winIVRInput_IVRInput_010(void *linux_side)
+{
+    winIVRInput_IVRInput_010 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRInput_IVRInput_010));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRInput_IVRInput_010_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRInput_IVRInput_010(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRInput_IVRInput_010 *create_winIVRInput_IVRInput_010_FnTable(void *linux_side)
+{
+    winIVRInput_IVRInput_010 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRInput_IVRInput_010));
+    struct thunk *thunks = alloc_thunks(32);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 32 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVRInput_IVRInput_010_SetActionManifestPath, 1, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVRInput_IVRInput_010_GetActionSetHandle, 2, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVRInput_IVRInput_010_GetActionHandle, 2, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVRInput_IVRInput_010_GetInputSourceHandle, 2, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVRInput_IVRInput_010_UpdateActionState, 3, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVRInput_IVRInput_010_GetDigitalActionData, 4, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVRInput_IVRInput_010_GetAnalogActionData, 4, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow, 6, TRUE, FALSE);
+    init_thunk(&thunks[8], r, winIVRInput_IVRInput_010_GetPoseActionDataForNextFrame, 5, FALSE, FALSE);
+    init_thunk(&thunks[9], r, winIVRInput_IVRInput_010_GetSkeletalActionData, 3, FALSE, FALSE);
+    init_thunk(&thunks[10], r, winIVRInput_IVRInput_010_GetDominantHand, 1, FALSE, FALSE);
+    init_thunk(&thunks[11], r, winIVRInput_IVRInput_010_SetDominantHand, 1, FALSE, FALSE);
+    init_thunk(&thunks[12], r, winIVRInput_IVRInput_010_GetBoneCount, 2, FALSE, FALSE);
+    init_thunk(&thunks[13], r, winIVRInput_IVRInput_010_GetBoneHierarchy, 3, FALSE, FALSE);
+    init_thunk(&thunks[14], r, winIVRInput_IVRInput_010_GetBoneName, 4, FALSE, FALSE);
+    init_thunk(&thunks[15], r, winIVRInput_IVRInput_010_GetSkeletalReferenceTransforms, 5, FALSE, FALSE);
+    init_thunk(&thunks[16], r, winIVRInput_IVRInput_010_GetSkeletalTrackingLevel, 2, FALSE, FALSE);
+    init_thunk(&thunks[17], r, winIVRInput_IVRInput_010_GetSkeletalBoneData, 5, FALSE, FALSE);
+    init_thunk(&thunks[18], r, winIVRInput_IVRInput_010_GetSkeletalSummaryData, 3, FALSE, FALSE);
+    init_thunk(&thunks[19], r, winIVRInput_IVRInput_010_GetSkeletalBoneDataCompressed, 5, FALSE, FALSE);
+    init_thunk(&thunks[20], r, winIVRInput_IVRInput_010_DecompressSkeletalBoneData, 5, FALSE, FALSE);
+    init_thunk(&thunks[21], r, winIVRInput_IVRInput_010_TriggerHapticVibrationAction, 6, TRUE, TRUE);
+    init_thunk(&thunks[22], r, winIVRInput_IVRInput_010_GetActionOrigins, 4, FALSE, FALSE);
+    init_thunk(&thunks[23], r, winIVRInput_IVRInput_010_GetOriginLocalizedName, 4, FALSE, FALSE);
+    init_thunk(&thunks[24], r, winIVRInput_IVRInput_010_GetOriginTrackedDeviceInfo, 3, FALSE, FALSE);
+    init_thunk(&thunks[25], r, winIVRInput_IVRInput_010_GetActionBindingInfo, 5, FALSE, FALSE);
+    init_thunk(&thunks[26], r, winIVRInput_IVRInput_010_ShowActionOrigins, 2, FALSE, FALSE);
+    init_thunk(&thunks[27], r, winIVRInput_IVRInput_010_ShowBindingsForActionSet, 4, FALSE, FALSE);
+    init_thunk(&thunks[28], r, winIVRInput_IVRInput_010_GetComponentStateForBinding, 6, FALSE, FALSE);
+    init_thunk(&thunks[29], r, winIVRInput_IVRInput_010_IsUsingLegacyInput, 0, FALSE, FALSE);
+    init_thunk(&thunks[30], r, winIVRInput_IVRInput_010_OpenBindingUI, 4, FALSE, FALSE);
+    init_thunk(&thunks[31], r, winIVRInput_IVRInput_010_GetBindingVariant, 3, FALSE, FALSE);
+    for (i = 0; i < 32; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVRInput_IVRInput_010_FnTable(void *object)
+{
+    winIVRInput_IVRInput_010 *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 "cppIVRInput_IVRInput_007.h"
 
 typedef struct __winIVRInput_IVRInput_007 {

vrclient_x64/vrclient_x64/winIVRMailbox.c

@@ -0,0 +1,113 @@
+/* This file is auto-generated, do not edit. */
+#include <stdarg.h>
+#include <stdint.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wine/debug.h"
+
+#include "cxx.h"
+
+#include "vrclient_defs.h"
+
+#include "vrclient_private.h"
+
+#include "struct_converters.h"
+
+#include "flatapi.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
+
+#include "cppIVRMailbox_IVRMailbox_001.h"
+
+typedef struct __winIVRMailbox_IVRMailbox_001 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVRMailbox_IVRMailbox_001;
+
+DEFINE_THISCALL_WRAPPER(winIVRMailbox_IVRMailbox_001_undoc1, 12)
+vrmb_typeb __thiscall winIVRMailbox_IVRMailbox_001_undoc1(winIVRMailbox_IVRMailbox_001 *_this, const char * a, vrmb_typea * b)
+{
+    TRACE("%p\n", _this);
+    return cppIVRMailbox_IVRMailbox_001_undoc1(_this->linux_side, a, b);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRMailbox_IVRMailbox_001_undoc2, 12)
+vrmb_typeb __thiscall winIVRMailbox_IVRMailbox_001_undoc2(winIVRMailbox_IVRMailbox_001 *_this, vrmb_typea a)
+{
+    TRACE("%p\n", _this);
+    return cppIVRMailbox_IVRMailbox_001_undoc2(_this->linux_side, a);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRMailbox_IVRMailbox_001_undoc3, 20)
+vrmb_typeb __thiscall winIVRMailbox_IVRMailbox_001_undoc3(winIVRMailbox_IVRMailbox_001 *_this, vrmb_typea a, const char * b, const char * c)
+{
+    TRACE("%p\n", _this);
+    return cppIVRMailbox_IVRMailbox_001_undoc3(_this->linux_side, a, b, c);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRMailbox_IVRMailbox_001_undoc4, 24)
+vrmb_typeb __thiscall winIVRMailbox_IVRMailbox_001_undoc4(winIVRMailbox_IVRMailbox_001 *_this, vrmb_typea a, char * b, uint32_t c, uint32_t * d)
+{
+    TRACE("%p\n", _this);
+    return cppIVRMailbox_IVRMailbox_001_undoc4(_this->linux_side, a, b, c, d);
+}
+
+extern vtable_ptr winIVRMailbox_IVRMailbox_001_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRMailbox_IVRMailbox_001,
+        VTABLE_ADD_FUNC(winIVRMailbox_IVRMailbox_001_undoc1)
+        VTABLE_ADD_FUNC(winIVRMailbox_IVRMailbox_001_undoc2)
+        VTABLE_ADD_FUNC(winIVRMailbox_IVRMailbox_001_undoc3)
+        VTABLE_ADD_FUNC(winIVRMailbox_IVRMailbox_001_undoc4)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRMailbox_IVRMailbox_001 *create_winIVRMailbox_IVRMailbox_001(void *linux_side)
+{
+    winIVRMailbox_IVRMailbox_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRMailbox_IVRMailbox_001));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRMailbox_IVRMailbox_001_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRMailbox_IVRMailbox_001(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRMailbox_IVRMailbox_001 *create_winIVRMailbox_IVRMailbox_001_FnTable(void *linux_side)
+{
+    winIVRMailbox_IVRMailbox_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRMailbox_IVRMailbox_001));
+    struct thunk *thunks = alloc_thunks(4);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 4 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVRMailbox_IVRMailbox_001_undoc1, 2, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVRMailbox_IVRMailbox_001_undoc2, 1, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVRMailbox_IVRMailbox_001_undoc3, 3, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVRMailbox_IVRMailbox_001_undoc4, 4, FALSE, FALSE);
+    for (i = 0; i < 4; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVRMailbox_IVRMailbox_001_FnTable(void *object)
+{
+    winIVRMailbox_IVRMailbox_001 *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);
+}
+

vrclient_x64/vrclient_x64/winIVROverlay.c

@@ -18,6 +18,767 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
 
+#include "cppIVROverlay_IVROverlay_024.h"
+
+typedef struct __winIVROverlay_IVROverlay_024 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVROverlay_IVROverlay_024;
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_FindOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_FindOverlay(winIVROverlay_IVROverlay_024 *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_FindOverlay(_this->linux_side, pchOverlayKey, pOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_CreateOverlay, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_CreateOverlay(winIVROverlay_IVROverlay_024 *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_CreateOverlay(_this->linux_side, pchOverlayKey, pchOverlayName, pOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_DestroyOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_DestroyOverlay(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_DestroyOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayKey, 24)
+uint32_t __thiscall winIVROverlay_IVROverlay_024_GetOverlayKey(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayKey(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayName, 24)
+uint32_t __thiscall winIVROverlay_IVROverlay_024_GetOverlayName(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayName(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayName, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayName(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayName(_this->linux_side, ulOverlayHandle, pchName);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayImageData, 28)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayImageData(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayImageData(_this->linux_side, ulOverlayHandle, pvBuffer, unBufferSize, punWidth, punHeight);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayErrorNameFromEnum, 8)
+const char * __thiscall winIVROverlay_IVROverlay_024_GetOverlayErrorNameFromEnum(winIVROverlay_IVROverlay_024 *_this, EVROverlayError error)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayErrorNameFromEnum(_this->linux_side, error);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayRenderingPid, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayRenderingPid(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayRenderingPid(_this->linux_side, ulOverlayHandle, unPID);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayRenderingPid, 12)
+uint32_t __thiscall winIVROverlay_IVROverlay_024_GetOverlayRenderingPid(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayRenderingPid(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayFlag, 17)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayFlag(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayFlag(_this->linux_side, ulOverlayHandle, eOverlayFlag, bEnabled);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayFlag, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayFlag(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayFlag(_this->linux_side, ulOverlayHandle, eOverlayFlag, pbEnabled);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayFlags, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayFlags(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayFlags(_this->linux_side, ulOverlayHandle, pFlags);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayColor, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayColor(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayColor(_this->linux_side, ulOverlayHandle, fRed, fGreen, fBlue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayColor, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayColor(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayColor(_this->linux_side, ulOverlayHandle, pfRed, pfGreen, pfBlue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayAlpha, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayAlpha(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayAlpha(_this->linux_side, ulOverlayHandle, fAlpha);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayAlpha, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayAlpha(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayAlpha(_this->linux_side, ulOverlayHandle, pfAlpha);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayTexelAspect, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayTexelAspect(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayTexelAspect(_this->linux_side, ulOverlayHandle, fTexelAspect);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayTexelAspect, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayTexelAspect(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayTexelAspect(_this->linux_side, ulOverlayHandle, pfTexelAspect);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlaySortOrder, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlaySortOrder(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlaySortOrder(_this->linux_side, ulOverlayHandle, unSortOrder);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlaySortOrder, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlaySortOrder(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlaySortOrder(_this->linux_side, ulOverlayHandle, punSortOrder);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayWidthInMeters, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayWidthInMeters(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayWidthInMeters(_this->linux_side, ulOverlayHandle, fWidthInMeters);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayWidthInMeters, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayWidthInMeters(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayWidthInMeters(_this->linux_side, ulOverlayHandle, pfWidthInMeters);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayCurvature, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayCurvature(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayCurvature(_this->linux_side, ulOverlayHandle, fCurvature);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayCurvature, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayCurvature(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayCurvature(_this->linux_side, ulOverlayHandle, pfCurvature);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayTextureColorSpace, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayTextureColorSpace(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayTextureColorSpace(_this->linux_side, ulOverlayHandle, eTextureColorSpace);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayTextureColorSpace, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayTextureColorSpace(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayTextureColorSpace(_this->linux_side, ulOverlayHandle, peTextureColorSpace);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayTextureBounds, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayTextureBounds(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayTextureBounds(_this->linux_side, ulOverlayHandle, pOverlayTextureBounds);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayTextureBounds, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayTextureBounds(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayTextureBounds(_this->linux_side, ulOverlayHandle, pOverlayTextureBounds);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayTransformType, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayTransformType(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayTransformType(_this->linux_side, ulOverlayHandle, peTransformType);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayTransformAbsolute, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayTransformAbsolute(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayTransformAbsolute(_this->linux_side, ulOverlayHandle, eTrackingOrigin, pmatTrackingOriginToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayTransformAbsolute, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayTransformAbsolute(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayTransformAbsolute(_this->linux_side, ulOverlayHandle, peTrackingOrigin, pmatTrackingOriginToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayTransformTrackedDeviceRelative, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayTransformTrackedDeviceRelative(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayTransformTrackedDeviceRelative(_this->linux_side, ulOverlayHandle, unTrackedDevice, pmatTrackedDeviceToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayTransformTrackedDeviceRelative, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayTransformTrackedDeviceRelative(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayTransformTrackedDeviceRelative(_this->linux_side, ulOverlayHandle, punTrackedDevice, pmatTrackedDeviceToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayTransformTrackedDeviceComponent, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayTransformTrackedDeviceComponent(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayTransformTrackedDeviceComponent(_this->linux_side, ulOverlayHandle, unDeviceIndex, pchComponentName);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayTransformTrackedDeviceComponent, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayTransformTrackedDeviceComponent(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayTransformTrackedDeviceComponent(_this->linux_side, ulOverlayHandle, punDeviceIndex, pchComponentName, unComponentNameSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayTransformOverlayRelative, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayTransformOverlayRelative(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayTransformOverlayRelative(_this->linux_side, ulOverlayHandle, ulOverlayHandleParent, pmatParentOverlayToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayTransformOverlayRelative, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayTransformOverlayRelative(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayTransformOverlayRelative(_this->linux_side, ulOverlayHandle, ulOverlayHandleParent, pmatParentOverlayToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayTransformCursor, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayTransformCursor(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayTransformCursor(_this->linux_side, ulCursorOverlayHandle, pvHotspot);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayTransformCursor, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayTransformCursor(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayTransformCursor(_this->linux_side, ulOverlayHandle, pvHotspot);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_ShowOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_ShowOverlay(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_ShowOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_HideOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_HideOverlay(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_HideOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_IsOverlayVisible, 12)
+bool __thiscall winIVROverlay_IVROverlay_024_IsOverlayVisible(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_IsOverlayVisible(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetTransformForOverlayCoordinates, 28)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetTransformForOverlayCoordinates(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetTransformForOverlayCoordinates(_this->linux_side, ulOverlayHandle, eTrackingOrigin, coordinatesInOverlay, pmatTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_PollNextOverlayEvent, 20)
+bool __thiscall winIVROverlay_IVROverlay_024_PollNextOverlayEvent(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_11030 * pEvent, uint32_t uncbVREvent)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_PollNextOverlayEvent(_this->linux_side, ulOverlayHandle, pEvent, uncbVREvent);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayInputMethod, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayInputMethod(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayInputMethod(_this->linux_side, ulOverlayHandle, peInputMethod);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayInputMethod, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayInputMethod(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayInputMethod(_this->linux_side, ulOverlayHandle, eInputMethod);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayMouseScale, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayMouseScale(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayMouseScale(_this->linux_side, ulOverlayHandle, pvecMouseScale);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayMouseScale, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayMouseScale(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayMouseScale(_this->linux_side, ulOverlayHandle, pvecMouseScale);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_ComputeOverlayIntersection, 20)
+bool __thiscall winIVROverlay_IVROverlay_024_ComputeOverlayIntersection(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_ComputeOverlayIntersection(_this->linux_side, ulOverlayHandle, pParams, pResults);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_IsHoverTargetOverlay, 12)
+bool __thiscall winIVROverlay_IVROverlay_024_IsHoverTargetOverlay(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_IsHoverTargetOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayIntersectionMask, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayIntersectionMask(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayIntersectionMask(_this->linux_side, ulOverlayHandle, pMaskPrimitives, unNumMaskPrimitives, unPrimitiveSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_TriggerLaserMouseHapticVibration, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_TriggerLaserMouseHapticVibration(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_TriggerLaserMouseHapticVibration(_this->linux_side, ulOverlayHandle, fDurationSeconds, fFrequency, fAmplitude);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayCursor, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayCursor(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayCursor(_this->linux_side, ulOverlayHandle, ulCursorHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayCursorPositionOverride, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayCursorPositionOverride(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayCursorPositionOverride(_this->linux_side, ulOverlayHandle, pvCursor);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_ClearOverlayCursorPositionOverride, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_ClearOverlayCursorPositionOverride(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_ClearOverlayCursorPositionOverride(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayTexture, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayTexture(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayTexture(_this->linux_side, ulOverlayHandle, pTexture);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_ClearOverlayTexture, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_ClearOverlayTexture(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_ClearOverlayTexture(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayRaw, 28)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayRaw(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetOverlayRaw(_this->linux_side, ulOverlayHandle, pvBuffer, unWidth, unHeight, unBytesPerPixel);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetOverlayFromFile, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetOverlayFromFile(winIVROverlay_IVROverlay_024 *_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_024_SetOverlayFromFile(_this->linux_side, ulOverlayHandle, pchFilePath ? lin_pchFilePath : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayTexture, 44)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayTexture(winIVROverlay_IVROverlay_024 *_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_024_GetOverlayTexture(_this->linux_side, ulOverlayHandle, pNativeTextureHandle, pNativeTextureRef, pWidth, pHeight, pNativeFormat, pAPIType, pColorSpace, pTextureBounds);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_ReleaseNativeOverlayHandle, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_ReleaseNativeOverlayHandle(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_ReleaseNativeOverlayHandle(_this->linux_side, ulOverlayHandle, pNativeTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetOverlayTextureSize, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetOverlayTextureSize(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetOverlayTextureSize(_this->linux_side, ulOverlayHandle, pWidth, pHeight);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_CreateDashboardOverlay, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_CreateDashboardOverlay(winIVROverlay_IVROverlay_024 *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_CreateDashboardOverlay(_this->linux_side, pchOverlayKey, pchOverlayFriendlyName, pMainHandle, pThumbnailHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_IsDashboardVisible, 4)
+bool __thiscall winIVROverlay_IVROverlay_024_IsDashboardVisible(winIVROverlay_IVROverlay_024 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_IsDashboardVisible(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_IsActiveDashboardOverlay, 12)
+bool __thiscall winIVROverlay_IVROverlay_024_IsActiveDashboardOverlay(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_IsActiveDashboardOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetDashboardOverlaySceneProcess, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_SetDashboardOverlaySceneProcess(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_SetDashboardOverlaySceneProcess(_this->linux_side, ulOverlayHandle, unProcessId);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetDashboardOverlaySceneProcess, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_GetDashboardOverlaySceneProcess(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetDashboardOverlaySceneProcess(_this->linux_side, ulOverlayHandle, punProcessId);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_ShowDashboard, 8)
+void __thiscall winIVROverlay_IVROverlay_024_ShowDashboard(winIVROverlay_IVROverlay_024 *_this, const char * pchOverlayToShow)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_024_ShowDashboard(_this->linux_side, pchOverlayToShow);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetPrimaryDashboardDevice, 4)
+TrackedDeviceIndex_t __thiscall winIVROverlay_IVROverlay_024_GetPrimaryDashboardDevice(winIVROverlay_IVROverlay_024 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetPrimaryDashboardDevice(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_ShowKeyboard, 36)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_ShowKeyboard(winIVROverlay_IVROverlay_024 *_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_024_ShowKeyboard(_this->linux_side, eInputMode, eLineInputMode, unFlags, pchDescription, unCharMax, pchExistingText, uUserValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_ShowKeyboardForOverlay, 44)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_024_ShowKeyboardForOverlay(winIVROverlay_IVROverlay_024 *_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_024_ShowKeyboardForOverlay(_this->linux_side, ulOverlayHandle, eInputMode, eLineInputMode, unFlags, pchDescription, unCharMax, pchExistingText, uUserValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_GetKeyboardText, 12)
+uint32_t __thiscall winIVROverlay_IVROverlay_024_GetKeyboardText(winIVROverlay_IVROverlay_024 *_this, char * pchText, uint32_t cchText)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_024_GetKeyboardText(_this->linux_side, pchText, cchText);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_HideKeyboard, 4)
+void __thiscall winIVROverlay_IVROverlay_024_HideKeyboard(winIVROverlay_IVROverlay_024 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_024_HideKeyboard(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetKeyboardTransformAbsolute, 12)
+void __thiscall winIVROverlay_IVROverlay_024_SetKeyboardTransformAbsolute(winIVROverlay_IVROverlay_024 *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_024_SetKeyboardTransformAbsolute(_this->linux_side, eTrackingOrigin, pmatTrackingOriginToKeyboardTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_SetKeyboardPositionForOverlay, 28)
+void __thiscall winIVROverlay_IVROverlay_024_SetKeyboardPositionForOverlay(winIVROverlay_IVROverlay_024 *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_024_SetKeyboardPositionForOverlay(_this->linux_side, ulOverlayHandle, avoidRect);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_ShowMessageOverlay, 28)
+VRMessageOverlayResponse __thiscall winIVROverlay_IVROverlay_024_ShowMessageOverlay(winIVROverlay_IVROverlay_024 *_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_024_ShowMessageOverlay(_this->linux_side, pchText, pchCaption, pchButton0Text, pchButton1Text, pchButton2Text, pchButton3Text);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_024_CloseMessageOverlay, 4)
+void __thiscall winIVROverlay_IVROverlay_024_CloseMessageOverlay(winIVROverlay_IVROverlay_024 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_024_CloseMessageOverlay(_this->linux_side);
+}
+
+extern vtable_ptr winIVROverlay_IVROverlay_024_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVROverlay_IVROverlay_024,
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_FindOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_CreateOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_DestroyOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayKey)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayName)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayName)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayImageData)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayErrorNameFromEnum)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayRenderingPid)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayRenderingPid)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayFlag)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayFlag)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayFlags)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayColor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayColor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayAlpha)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayAlpha)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayTexelAspect)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayTexelAspect)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlaySortOrder)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlaySortOrder)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayWidthInMeters)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayWidthInMeters)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayCurvature)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayCurvature)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayTextureColorSpace)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayTextureColorSpace)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayTextureBounds)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayTextureBounds)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayTransformType)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayTransformAbsolute)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayTransformAbsolute)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayTransformTrackedDeviceRelative)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayTransformTrackedDeviceRelative)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayTransformTrackedDeviceComponent)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayTransformTrackedDeviceComponent)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayTransformOverlayRelative)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayTransformOverlayRelative)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayTransformCursor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayTransformCursor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_ShowOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_HideOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_IsOverlayVisible)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetTransformForOverlayCoordinates)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_PollNextOverlayEvent)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayInputMethod)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayInputMethod)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayMouseScale)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayMouseScale)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_ComputeOverlayIntersection)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_IsHoverTargetOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayIntersectionMask)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_TriggerLaserMouseHapticVibration)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayCursor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayCursorPositionOverride)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_ClearOverlayCursorPositionOverride)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayTexture)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_ClearOverlayTexture)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayRaw)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetOverlayFromFile)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayTexture)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_ReleaseNativeOverlayHandle)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetOverlayTextureSize)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_CreateDashboardOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_IsDashboardVisible)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_IsActiveDashboardOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetDashboardOverlaySceneProcess)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetDashboardOverlaySceneProcess)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_ShowDashboard)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetPrimaryDashboardDevice)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_ShowKeyboard)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_ShowKeyboardForOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_GetKeyboardText)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_HideKeyboard)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetKeyboardTransformAbsolute)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_SetKeyboardPositionForOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_ShowMessageOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_024_CloseMessageOverlay)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVROverlay_IVROverlay_024 *create_winIVROverlay_IVROverlay_024(void *linux_side)
+{
+    winIVROverlay_IVROverlay_024 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_024));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVROverlay_IVROverlay_024_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVROverlay_IVROverlay_024(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVROverlay_IVROverlay_024 *create_winIVROverlay_IVROverlay_024_FnTable(void *linux_side)
+{
+    winIVROverlay_IVROverlay_024 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_024));
+    struct thunk *thunks = alloc_thunks(78);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 78 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_024_FindOverlay, 2, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_024_CreateOverlay, 3, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_024_DestroyOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_024_GetOverlayKey, 4, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_024_GetOverlayName, 4, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_024_SetOverlayName, 2, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_024_GetOverlayImageData, 5, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_024_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_024_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_024_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_024_SetOverlayFlag, 3, FALSE, FALSE);
+    init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_024_GetOverlayFlag, 3, FALSE, FALSE);
+    init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_024_GetOverlayFlags, 2, FALSE, FALSE);
+    init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_024_SetOverlayColor, 4, TRUE, TRUE);
+    init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_024_GetOverlayColor, 4, FALSE, FALSE);
+    init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_024_SetOverlayAlpha, 2, TRUE, FALSE);
+    init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_024_GetOverlayAlpha, 2, FALSE, FALSE);
+    init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_024_SetOverlayTexelAspect, 2, TRUE, FALSE);
+    init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_024_GetOverlayTexelAspect, 2, FALSE, FALSE);
+    init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_024_SetOverlaySortOrder, 2, FALSE, FALSE);
+    init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_024_GetOverlaySortOrder, 2, FALSE, FALSE);
+    init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_024_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_024_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_024_SetOverlayCurvature, 2, TRUE, FALSE);
+    init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_024_GetOverlayCurvature, 2, FALSE, FALSE);
+    init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_024_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_024_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_024_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_024_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_024_GetOverlayTransformType, 2, FALSE, FALSE);
+    init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_024_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_024_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_024_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_024_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_024_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_024_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_024_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_024_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_024_SetOverlayTransformCursor, 2, FALSE, FALSE);
+    init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_024_GetOverlayTransformCursor, 2, FALSE, FALSE);
+    init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_024_ShowOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_024_HideOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_024_IsOverlayVisible, 1, FALSE, FALSE);
+    init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_024_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_024_PollNextOverlayEvent, 3, FALSE, FALSE);
+    init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_024_GetOverlayInputMethod, 2, FALSE, FALSE);
+    init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_024_SetOverlayInputMethod, 2, FALSE, FALSE);
+    init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_024_GetOverlayMouseScale, 2, FALSE, FALSE);
+    init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_024_SetOverlayMouseScale, 2, FALSE, FALSE);
+    init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_024_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_024_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_024_SetOverlayIntersectionMask, 4, FALSE, FALSE);
+    init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_024_TriggerLaserMouseHapticVibration, 4, TRUE, TRUE);
+    init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_024_SetOverlayCursor, 2, FALSE, FALSE);
+    init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_024_SetOverlayCursorPositionOverride, 2, FALSE, FALSE);
+    init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_024_ClearOverlayCursorPositionOverride, 1, FALSE, FALSE);
+    init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_024_SetOverlayTexture, 2, FALSE, FALSE);
+    init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_024_ClearOverlayTexture, 1, FALSE, FALSE);
+    init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_024_SetOverlayRaw, 5, FALSE, FALSE);
+    init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_024_SetOverlayFromFile, 2, FALSE, FALSE);
+    init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_024_GetOverlayTexture, 9, FALSE, FALSE);
+    init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_024_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_024_GetOverlayTextureSize, 3, FALSE, FALSE);
+    init_thunk(&thunks[63], r, winIVROverlay_IVROverlay_024_CreateDashboardOverlay, 4, FALSE, FALSE);
+    init_thunk(&thunks[64], r, winIVROverlay_IVROverlay_024_IsDashboardVisible, 0, FALSE, FALSE);
+    init_thunk(&thunks[65], r, winIVROverlay_IVROverlay_024_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[66], r, winIVROverlay_IVROverlay_024_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    init_thunk(&thunks[67], r, winIVROverlay_IVROverlay_024_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    init_thunk(&thunks[68], r, winIVROverlay_IVROverlay_024_ShowDashboard, 1, FALSE, FALSE);
+    init_thunk(&thunks[69], r, winIVROverlay_IVROverlay_024_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    init_thunk(&thunks[70], r, winIVROverlay_IVROverlay_024_ShowKeyboard, 7, FALSE, FALSE);
+    init_thunk(&thunks[71], r, winIVROverlay_IVROverlay_024_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    init_thunk(&thunks[72], r, winIVROverlay_IVROverlay_024_GetKeyboardText, 2, FALSE, FALSE);
+    init_thunk(&thunks[73], r, winIVROverlay_IVROverlay_024_HideKeyboard, 0, FALSE, FALSE);
+    init_thunk(&thunks[74], r, winIVROverlay_IVROverlay_024_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    init_thunk(&thunks[75], r, winIVROverlay_IVROverlay_024_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    init_thunk(&thunks[76], r, winIVROverlay_IVROverlay_024_ShowMessageOverlay, 6, FALSE, FALSE);
+    init_thunk(&thunks[77], r, winIVROverlay_IVROverlay_024_CloseMessageOverlay, 0, FALSE, FALSE);
+    for (i = 0; i < 78; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVROverlay_IVROverlay_024_FnTable(void *object)
+{
+    winIVROverlay_IVROverlay_024 *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_022.h"
 
 typedef struct __winIVROverlay_IVROverlay_022 {

vrclient_x64/vrclient_x64/winIVROverlayView.c

@@ -0,0 +1,113 @@
+/* This file is auto-generated, do not edit. */
+#include <stdarg.h>
+#include <stdint.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wine/debug.h"
+
+#include "cxx.h"
+
+#include "vrclient_defs.h"
+
+#include "vrclient_private.h"
+
+#include "struct_converters.h"
+
+#include "flatapi.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
+
+#include "cppIVROverlayView_IVROverlayView_003.h"
+
+typedef struct __winIVROverlayView_IVROverlayView_003 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVROverlayView_IVROverlayView_003;
+
+DEFINE_THISCALL_WRAPPER(winIVROverlayView_IVROverlayView_003_AcquireOverlayView, 24)
+EVROverlayError __thiscall winIVROverlayView_IVROverlayView_003_AcquireOverlayView(winIVROverlayView_IVROverlayView_003 *_this, VROverlayHandle_t ulOverlayHandle, VRNativeDevice_t * pNativeDevice, VROverlayView_t * pOverlayView, uint32_t unOverlayViewSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlayView_IVROverlayView_003_AcquireOverlayView(_this->linux_side, ulOverlayHandle, pNativeDevice, pOverlayView, unOverlayViewSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlayView_IVROverlayView_003_ReleaseOverlayView, 8)
+EVROverlayError __thiscall winIVROverlayView_IVROverlayView_003_ReleaseOverlayView(winIVROverlayView_IVROverlayView_003 *_this, VROverlayView_t * pOverlayView)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlayView_IVROverlayView_003_ReleaseOverlayView(_this->linux_side, pOverlayView);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlayView_IVROverlayView_003_PostOverlayEvent, 16)
+void __thiscall winIVROverlayView_IVROverlayView_003_PostOverlayEvent(winIVROverlayView_IVROverlayView_003 *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pvrEvent)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlayView_IVROverlayView_003_PostOverlayEvent(_this->linux_side, ulOverlayHandle, pvrEvent);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlayView_IVROverlayView_003_IsViewingPermitted, 12)
+bool __thiscall winIVROverlayView_IVROverlayView_003_IsViewingPermitted(winIVROverlayView_IVROverlayView_003 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlayView_IVROverlayView_003_IsViewingPermitted(_this->linux_side, ulOverlayHandle);
+}
+
+extern vtable_ptr winIVROverlayView_IVROverlayView_003_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVROverlayView_IVROverlayView_003,
+        VTABLE_ADD_FUNC(winIVROverlayView_IVROverlayView_003_AcquireOverlayView)
+        VTABLE_ADD_FUNC(winIVROverlayView_IVROverlayView_003_ReleaseOverlayView)
+        VTABLE_ADD_FUNC(winIVROverlayView_IVROverlayView_003_PostOverlayEvent)
+        VTABLE_ADD_FUNC(winIVROverlayView_IVROverlayView_003_IsViewingPermitted)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVROverlayView_IVROverlayView_003 *create_winIVROverlayView_IVROverlayView_003(void *linux_side)
+{
+    winIVROverlayView_IVROverlayView_003 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlayView_IVROverlayView_003));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVROverlayView_IVROverlayView_003_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVROverlayView_IVROverlayView_003(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVROverlayView_IVROverlayView_003 *create_winIVROverlayView_IVROverlayView_003_FnTable(void *linux_side)
+{
+    winIVROverlayView_IVROverlayView_003 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlayView_IVROverlayView_003));
+    struct thunk *thunks = alloc_thunks(4);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 4 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVROverlayView_IVROverlayView_003_AcquireOverlayView, 4, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVROverlayView_IVROverlayView_003_ReleaseOverlayView, 1, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVROverlayView_IVROverlayView_003_PostOverlayEvent, 2, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVROverlayView_IVROverlayView_003_IsViewingPermitted, 1, FALSE, FALSE);
+    for (i = 0; i < 4; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVROverlayView_IVROverlayView_003_FnTable(void *object)
+{
+    winIVROverlayView_IVROverlayView_003 *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);
+}
+

vrclient_x64/vrclient_x64/winIVRRenderModels.c

@@ -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_1916 ** ppRenderModel)
+EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, winRenderModel_t_11030 ** 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_1916 * pRenderModel)
+void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeRenderModel(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_t_11030 * 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_1916 ** ppTexture)
+EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_11030 ** 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_1916 * pTexture)
+void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeTexture(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_TextureMap_t_11030 * pTexture)
 {
     TRACE("%p\n", _this);
     cppIVRRenderModels_IVRRenderModels_006_FreeTexture(_this->linux_side, pTexture);

vrclient_x64/vrclient_x64/winIVRSystem.c

@@ -241,14 +241,14 @@ const char * __thiscall winIVRSystem_IVRSystem_021_GetPropErrorNameFromEnum(winI
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_PollNextEvent, 12)
-bool __thiscall winIVRSystem_IVRSystem_021_PollNextEvent(winIVRSystem_IVRSystem_021 *_this, winVREvent_t_1916 * pEvent, uint32_t uncbVREvent)
+bool __thiscall winIVRSystem_IVRSystem_021_PollNextEvent(winIVRSystem_IVRSystem_021 *_this, winVREvent_t_11030 * pEvent, uint32_t uncbVREvent)
 {
     TRACE("%p\n", _this);
     return cppIVRSystem_IVRSystem_021_PollNextEvent(_this->linux_side, pEvent, uncbVREvent);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_PollNextEventWithPose, 20)
-bool __thiscall winIVRSystem_IVRSystem_021_PollNextEventWithPose(winIVRSystem_IVRSystem_021 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1916 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+bool __thiscall winIVRSystem_IVRSystem_021_PollNextEventWithPose(winIVRSystem_IVRSystem_021 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_11030 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
 {
     TRACE("%p\n", _this);
     return cppIVRSystem_IVRSystem_021_PollNextEventWithPose(_this->linux_side, eOrigin, pEvent, uncbVREvent, pTrackedDevicePose);
@@ -270,14 +270,14 @@ HiddenAreaMesh_t *__thiscall winIVRSystem_IVRSystem_021_GetHiddenAreaMesh(winIVR
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetControllerState, 16)
-bool __thiscall winIVRSystem_IVRSystem_021_GetControllerState(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1916 * pControllerState, uint32_t unControllerStateSize)
+bool __thiscall winIVRSystem_IVRSystem_021_GetControllerState(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_11030 * pControllerState, uint32_t unControllerStateSize)
 {
     TRACE("%p\n", _this);
     return cppIVRSystem_IVRSystem_021_GetControllerState(_this->linux_side, unControllerDeviceIndex, pControllerState, unControllerStateSize);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetControllerStateWithPose, 24)
-bool __thiscall winIVRSystem_IVRSystem_021_GetControllerStateWithPose(winIVRSystem_IVRSystem_021 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1916 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+bool __thiscall winIVRSystem_IVRSystem_021_GetControllerStateWithPose(winIVRSystem_IVRSystem_021 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_11030 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
 {
     TRACE("%p\n", _this);
     return cppIVRSystem_IVRSystem_021_GetControllerStateWithPose(_this->linux_side, eOrigin, unControllerDeviceIndex, pControllerState, unControllerStateSize, pTrackedDevicePose);

vrclient_x64/vrclient_x64/winIVRTrackedCamera.c

@@ -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_1916 * 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_11030 * 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_1916 * 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_11030 * 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_1916 * pFrameHeader, uint32_t nFrameHeaderSize)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_11030 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     TRACE("%p\n", _this);
     return cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(_this->linux_side, hTrackedCamera, eFrameType, pglTextureId, pFrameHeader, nFrameHeaderSize);

vrclient_x64/vrclient_x64/win_constructors.h

@@ -8,12 +8,16 @@ extern void *create_winIVRChaperone_IVRChaperone_003(void *);
 extern void *create_winIVRChaperone_IVRChaperone_003_FnTable(void *);
 extern void *create_winIVRChaperoneSetup_IVRChaperoneSetup_006(void *);
 extern void *create_winIVRChaperoneSetup_IVRChaperoneSetup_006_FnTable(void *);
-extern void *create_winIVRCompositor_IVRCompositor_024(void *);
+extern void *create_winIVRCompositor_IVRCompositor_026(void *);
-extern void *create_winIVRCompositor_IVRCompositor_024_FnTable(void *);
+extern void *create_winIVRCompositor_IVRCompositor_026_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_022(void *);
+extern void *create_winIVROverlay_IVROverlay_024(void *);
-extern void *create_winIVROverlay_IVROverlay_022_FnTable(void *);
+extern void *create_winIVROverlay_IVROverlay_024_FnTable(void *);
+extern void *create_winIVROverlayView_IVROverlayView_003(void *);
+extern void *create_winIVROverlayView_IVROverlayView_003_FnTable(void *);
 extern void *create_winIVRRenderModels_IVRRenderModels_006(void *);
 extern void *create_winIVRRenderModels_IVRRenderModels_006_FnTable(void *);
 extern void *create_winIVRExtendedDisplay_IVRExtendedDisplay_001(void *);
@@ -26,12 +30,22 @@ extern void *create_winIVRResources_IVRResources_001(void *);
 extern void *create_winIVRResources_IVRResources_001_FnTable(void *);
 extern void *create_winIVRDriverManager_IVRDriverManager_001(void *);
 extern void *create_winIVRDriverManager_IVRDriverManager_001_FnTable(void *);
-extern void *create_winIVRInput_IVRInput_007(void *);
+extern void *create_winIVRInput_IVRInput_010(void *);
-extern void *create_winIVRInput_IVRInput_007_FnTable(void *);
+extern void *create_winIVRInput_IVRInput_010_FnTable(void *);
 extern void *create_winIVRIOBuffer_IVRIOBuffer_002(void *);
 extern void *create_winIVRIOBuffer_IVRIOBuffer_002_FnTable(void *);
+extern void *create_winIVRControlPanel_IVRControlPanel_006(void *);
+extern void *create_winIVRControlPanel_IVRControlPanel_006_FnTable(void *);
+extern void *create_winIVRMailbox_IVRMailbox_001(void *);
+extern void *create_winIVRMailbox_IVRMailbox_001_FnTable(void *);
 extern void *create_winIVRClientCore_IVRClientCore_003(void *);
 extern void *create_winIVRClientCore_IVRClientCore_003_FnTable(void *);
+extern void *create_winIVRCompositor_IVRCompositor_024(void *);
+extern void *create_winIVRCompositor_IVRCompositor_024_FnTable(void *);
+extern void *create_winIVROverlay_IVROverlay_022(void *);
+extern void *create_winIVROverlay_IVROverlay_022_FnTable(void *);
+extern void *create_winIVRInput_IVRInput_007(void *);
+extern void *create_winIVRInput_IVRInput_007_FnTable(void *);
 extern void *create_winIVRSettings_IVRSettings_002(void *);
 extern void *create_winIVRSettings_IVRSettings_002_FnTable(void *);
 extern void *create_winIVRCompositor_IVRCompositor_022(void *);

vrclient_x64/vrclient_x64/win_constructors_table.dat

@@ -8,12 +8,16 @@
     {"FnTable:IVRChaperone_003", &create_winIVRChaperone_IVRChaperone_003_FnTable, &destroy_winIVRChaperone_IVRChaperone_003_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_024", &create_winIVRCompositor_IVRCompositor_024, &destroy_winIVRCompositor_IVRCompositor_024},
+    {"IVRCompositor_026", &create_winIVRCompositor_IVRCompositor_026, &destroy_winIVRCompositor_IVRCompositor_026},
-    {"FnTable:IVRCompositor_024", &create_winIVRCompositor_IVRCompositor_024_FnTable, &destroy_winIVRCompositor_IVRCompositor_024_FnTable},
+    {"FnTable:IVRCompositor_026", &create_winIVRCompositor_IVRCompositor_026_FnTable, &destroy_winIVRCompositor_IVRCompositor_026_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_022", &create_winIVROverlay_IVROverlay_022, &destroy_winIVROverlay_IVROverlay_022},
+    {"IVROverlay_024", &create_winIVROverlay_IVROverlay_024, &destroy_winIVROverlay_IVROverlay_024},
-    {"FnTable:IVROverlay_022", &create_winIVROverlay_IVROverlay_022_FnTable, &destroy_winIVROverlay_IVROverlay_022_FnTable},
+    {"FnTable:IVROverlay_024", &create_winIVROverlay_IVROverlay_024_FnTable, &destroy_winIVROverlay_IVROverlay_024_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},
     {"FnTable:IVRRenderModels_006", &create_winIVRRenderModels_IVRRenderModels_006_FnTable, &destroy_winIVRRenderModels_IVRRenderModels_006_FnTable},
     {"IVRExtendedDisplay_001", &create_winIVRExtendedDisplay_IVRExtendedDisplay_001, &destroy_winIVRExtendedDisplay_IVRExtendedDisplay_001},
@@ -26,12 +30,22 @@
     {"FnTable:IVRResources_001", &create_winIVRResources_IVRResources_001_FnTable, &destroy_winIVRResources_IVRResources_001_FnTable},
     {"IVRDriverManager_001", &create_winIVRDriverManager_IVRDriverManager_001, &destroy_winIVRDriverManager_IVRDriverManager_001},
     {"FnTable:IVRDriverManager_001", &create_winIVRDriverManager_IVRDriverManager_001_FnTable, &destroy_winIVRDriverManager_IVRDriverManager_001_FnTable},
-    {"IVRInput_007", &create_winIVRInput_IVRInput_007, &destroy_winIVRInput_IVRInput_007},
+    {"IVRInput_010", &create_winIVRInput_IVRInput_010, &destroy_winIVRInput_IVRInput_010},
-    {"FnTable:IVRInput_007", &create_winIVRInput_IVRInput_007_FnTable, &destroy_winIVRInput_IVRInput_007_FnTable},
+    {"FnTable:IVRInput_010", &create_winIVRInput_IVRInput_010_FnTable, &destroy_winIVRInput_IVRInput_010_FnTable},
     {"IVRIOBuffer_002", &create_winIVRIOBuffer_IVRIOBuffer_002, &destroy_winIVRIOBuffer_IVRIOBuffer_002},
     {"FnTable:IVRIOBuffer_002", &create_winIVRIOBuffer_IVRIOBuffer_002_FnTable, &destroy_winIVRIOBuffer_IVRIOBuffer_002_FnTable},
+    {"IVRControlPanel_006", &create_winIVRControlPanel_IVRControlPanel_006, &destroy_winIVRControlPanel_IVRControlPanel_006},
+    {"FnTable:IVRControlPanel_006", &create_winIVRControlPanel_IVRControlPanel_006_FnTable, &destroy_winIVRControlPanel_IVRControlPanel_006_FnTable},
+    {"IVRMailbox_001", &create_winIVRMailbox_IVRMailbox_001, &destroy_winIVRMailbox_IVRMailbox_001},
+    {"FnTable:IVRMailbox_001", &create_winIVRMailbox_IVRMailbox_001_FnTable, &destroy_winIVRMailbox_IVRMailbox_001_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_024", &create_winIVRCompositor_IVRCompositor_024, &destroy_winIVRCompositor_IVRCompositor_024},
+    {"FnTable:IVRCompositor_024", &create_winIVRCompositor_IVRCompositor_024_FnTable, &destroy_winIVRCompositor_IVRCompositor_024_FnTable},
+    {"IVROverlay_022", &create_winIVROverlay_IVROverlay_022, &destroy_winIVROverlay_IVROverlay_022},
+    {"FnTable:IVROverlay_022", &create_winIVROverlay_IVROverlay_022_FnTable, &destroy_winIVROverlay_IVROverlay_022_FnTable},
+    {"IVRInput_007", &create_winIVRInput_IVRInput_007, &destroy_winIVRInput_IVRInput_007},
+    {"FnTable:IVRInput_007", &create_winIVRInput_IVRInput_007_FnTable, &destroy_winIVRInput_IVRInput_007_FnTable},
     {"IVRSettings_002", &create_winIVRSettings_IVRSettings_002, &destroy_winIVRSettings_IVRSettings_002},
     {"FnTable:IVRSettings_002", &create_winIVRSettings_IVRSettings_002_FnTable, &destroy_winIVRSettings_IVRSettings_002_FnTable},
     {"IVRCompositor_022", &create_winIVRCompositor_IVRCompositor_022, &destroy_winIVRCompositor_IVRCompositor_022},

vrclient_x64/vrclient_x64/win_destructors.h

@@ -8,12 +8,16 @@ extern void destroy_winIVRChaperone_IVRChaperone_003(void *);
 extern void destroy_winIVRChaperone_IVRChaperone_003_FnTable(void *);
 extern void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_006(void *);
 extern void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_006_FnTable(void *);
-extern void destroy_winIVRCompositor_IVRCompositor_024(void *);
+extern void destroy_winIVRCompositor_IVRCompositor_026(void *);
-extern void destroy_winIVRCompositor_IVRCompositor_024_FnTable(void *);
+extern void destroy_winIVRCompositor_IVRCompositor_026_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_022(void *);
+extern void destroy_winIVROverlay_IVROverlay_024(void *);
-extern void destroy_winIVROverlay_IVROverlay_022_FnTable(void *);
+extern void destroy_winIVROverlay_IVROverlay_024_FnTable(void *);
+extern void destroy_winIVROverlayView_IVROverlayView_003(void *);
+extern void destroy_winIVROverlayView_IVROverlayView_003_FnTable(void *);
 extern void destroy_winIVRRenderModels_IVRRenderModels_006(void *);
 extern void destroy_winIVRRenderModels_IVRRenderModels_006_FnTable(void *);
 extern void destroy_winIVRExtendedDisplay_IVRExtendedDisplay_001(void *);
@@ -26,12 +30,22 @@ extern void destroy_winIVRResources_IVRResources_001(void *);
 extern void destroy_winIVRResources_IVRResources_001_FnTable(void *);
 extern void destroy_winIVRDriverManager_IVRDriverManager_001(void *);
 extern void destroy_winIVRDriverManager_IVRDriverManager_001_FnTable(void *);
-extern void destroy_winIVRInput_IVRInput_007(void *);
+extern void destroy_winIVRInput_IVRInput_010(void *);
-extern void destroy_winIVRInput_IVRInput_007_FnTable(void *);
+extern void destroy_winIVRInput_IVRInput_010_FnTable(void *);
 extern void destroy_winIVRIOBuffer_IVRIOBuffer_002(void *);
 extern void destroy_winIVRIOBuffer_IVRIOBuffer_002_FnTable(void *);
+extern void destroy_winIVRControlPanel_IVRControlPanel_006(void *);
+extern void destroy_winIVRControlPanel_IVRControlPanel_006_FnTable(void *);
+extern void destroy_winIVRMailbox_IVRMailbox_001(void *);
+extern void destroy_winIVRMailbox_IVRMailbox_001_FnTable(void *);
 extern void destroy_winIVRClientCore_IVRClientCore_003(void *);
 extern void destroy_winIVRClientCore_IVRClientCore_003_FnTable(void *);
+extern void destroy_winIVRCompositor_IVRCompositor_024(void *);
+extern void destroy_winIVRCompositor_IVRCompositor_024_FnTable(void *);
+extern void destroy_winIVROverlay_IVROverlay_022(void *);
+extern void destroy_winIVROverlay_IVROverlay_022_FnTable(void *);
+extern void destroy_winIVRInput_IVRInput_007(void *);
+extern void destroy_winIVRInput_IVRInput_007_FnTable(void *);
 extern void destroy_winIVRSettings_IVRSettings_002(void *);
 extern void destroy_winIVRSettings_IVRSettings_002_FnTable(void *);
 extern void destroy_winIVRCompositor_IVRCompositor_022(void *);