vrclient: Support intermediate version 1.0.3a

Used by The Lab.

vrclient_x64/gen_wrapper.py

@@ -26,6 +26,7 @@ sdk_versions = [
     "v1.0.6",
     "v1.0.5",
     "v1.0.4",
+    "v1.0.3a", #non-public build used by The Lab, see Proton github PR#2075
     "v1.0.3",
     "v1.0.2",
     "v1.0.1",
@@ -171,7 +172,7 @@ def ivrcompositor_post_present_handoff(cppname, method):
     return "ivrcompositor_post_present_handoff"
 
 def ivrcompositor_wait_get_poses(cppname, method):
-    for version in ["016", "018", "019", "020", "021", "022"]:
+    for version in ["016", "017", "018", "019", "020", "021", "022"]:
         if version in cppname:
             return "ivrcompositor_wait_get_poses"
     return None
@@ -564,7 +565,8 @@ WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
     constructors.write("    {\"FnTable:%s\", &create_%s_FnTable, &destroy_%s_FnTable},\n" % (iface_version, winclassname, winclassname))
     if iface_version in aliases.keys():
         for alias in aliases[iface_version]:
-            constructors.write("    {\"%s\", &create_%s}, /* alias */\n" % (alias, winclassname))
+            constructors.write("    {\"%s\", &create_%s, &destroy_%s}, /* alias */\n" % (alias, winclassname, winclassname))
+            constructors.write("    {\"FnTable:%s\", &create_%s_FnTable, &destroy_%s_FnTable},\n" % (alias, winclassname, winclassname))
 
     generate_c_api_thunk_tests(winclassname, methods, method_names)
 

vrclient_x64/openvr_v1.0.3a/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 ) = 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_002";
+
+
+}

vrclient_x64/tests/capi_thunks_autogen.c

@@ -8181,6 +8181,248 @@ EVROverlayError __thiscall IVROverlay_013_SetOverlayIntersectionMask(void *_this
     return 0;
 }
 
+void __thiscall IVRCompositor_017_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_017_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_017_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_017_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_017_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pOutputGamePose);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_017_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_017_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_017_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_017_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_017_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(nFrames);
+    return 0;
+}
+
+float __thiscall IVRCompositor_017_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_017_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pStats);
+    push_uint32_parameter(nStatsSizeInBytes);
+}
+
+void __thiscall IVRCompositor_017_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+void __thiscall IVRCompositor_017_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+EVRCompositorError __thiscall IVRCompositor_017_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_017_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_017_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_017_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_017_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_017_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_017_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_017_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_017_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_017_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_017_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_017_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_017_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_017_ShouldAppRenderWithLowResources(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_017_ForceInterleavedReprojectionOn(void *_this, bool bOverride)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bOverride);
+}
+
+void __thiscall IVRCompositor_017_ForceReconnectProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_017_SuspendRendering(void *_this, bool bSuspend)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bSuspend);
+}
+
+EVRCompositorError __thiscall IVRCompositor_017_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pD3D11DeviceOrResource);
+    push_ptr_parameter(ppD3D11ShaderResourceView);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_017_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pglTextureId);
+    push_ptr_parameter(pglSharedTextureHandle);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_017_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(glTextureId);
+    push_ptr_parameter(glSharedTextureHandle);
+    return 0;
+}
+
+void __thiscall IVRCompositor_017_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+void __thiscall IVRCompositor_017_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
 void __thiscall IVRSystem_012_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
 {
     push_ptr_parameter(_this);

vrclient_x64/tests/capi_thunks_autogen.h

@@ -2131,6 +2131,80 @@ void __thiscall IVROverlay_013_SetKeyboardPositionForOverlay(void *_this, VROver
 
 EVROverlayError __thiscall IVROverlay_013_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
 
+void test_capi_thunks_IVRCompositor_017(void);
+
+void __thiscall IVRCompositor_017_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_017_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_017_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_017_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_017_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
+
+EVRCompositorError __thiscall IVRCompositor_017_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_017_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_017_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_017_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+uint32_t __thiscall IVRCompositor_017_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames);
+
+float __thiscall IVRCompositor_017_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_017_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
+
+void __thiscall IVRCompositor_017_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+void __thiscall IVRCompositor_017_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+EVRCompositorError __thiscall IVRCompositor_017_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_017_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_017_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_017_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_017_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_017_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_017_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_017_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_017_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_017_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_017_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_017_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_017_CompositorDumpImages(void *_this);
+
+bool __thiscall IVRCompositor_017_ShouldAppRenderWithLowResources(void *_this);
+
+void __thiscall IVRCompositor_017_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
+
+void __thiscall IVRCompositor_017_ForceReconnectProcess(void *_this);
+
+void __thiscall IVRCompositor_017_SuspendRendering(void *_this, bool bSuspend);
+
+EVRCompositorError __thiscall IVRCompositor_017_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
+
+EVRCompositorError __thiscall IVRCompositor_017_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
+
+bool __thiscall IVRCompositor_017_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_017_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_017_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
 void test_capi_thunks_IVRSystem_012(void);
 
 void __thiscall IVRSystem_012_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);

vrclient_x64/tests/capi_thunks_tests_autogen.c

@@ -9605,6 +9605,308 @@ void test_capi_thunks_IVROverlay_013(void)
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
+void test_capi_thunks_IVRCompositor_017(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_017_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_017_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_017_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_017_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_017_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_017_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_017_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_017_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_017_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_017_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_017_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_017_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_017_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_017_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_017_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_017_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_017_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_017_GetLastPoseForTrackedDeviceIndex", 1);
+    check_ptr_parameter("IVRCompositor_017_GetLastPoseForTrackedDeviceIndex", (void *)2);
+    check_ptr_parameter("IVRCompositor_017_GetLastPoseForTrackedDeviceIndex", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_017_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_017_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_017_Submit", 1);
+    check_ptr_parameter("IVRCompositor_017_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_017_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_017_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_017_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_017_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_017_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_017_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_017_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_017_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_GetFrameTimings, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_017_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_GetFrameTimings((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_017_GetFrameTimings", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_017_GetFrameTimings", (void *)1);
+    check_uint32_parameter("IVRCompositor_017_GetFrameTimings", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_017_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_017_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_GetCumulativeStats, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_GetCumulativeStats((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_017_GetCumulativeStats", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_017_GetCumulativeStats", (void *)1);
+    check_uint32_parameter("IVRCompositor_017_GetCumulativeStats", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_017_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_017_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_017_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_017_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_017_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_017_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_017_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_017_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_017_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_017_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_017_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_017_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_017_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_017_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_017_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_017_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_017_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_017_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_017_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_017_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_017_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_017_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_017_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_017_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_017_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_017_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_017_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_017_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_017_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_017_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_017_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_017_CompositorDumpImages", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_017_ShouldAppRenderWithLowResources)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_ShouldAppRenderWithLowResources();
+    check_ptr_parameter("IVRCompositor_017_ShouldAppRenderWithLowResources", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_ForceInterleavedReprojectionOn(1);
+    check_ptr_parameter("IVRCompositor_017_ForceInterleavedReprojectionOn", this_ptr_value);
+    check_bool_parameter("IVRCompositor_017_ForceInterleavedReprojectionOn", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_ForceReconnectProcess, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_ForceReconnectProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_ForceReconnectProcess();
+    check_ptr_parameter("IVRCompositor_017_ForceReconnectProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_SuspendRendering, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_SuspendRendering)(bool bSuspend) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_SuspendRendering(1);
+    check_ptr_parameter("IVRCompositor_017_SuspendRendering", this_ptr_value);
+    check_bool_parameter("IVRCompositor_017_SuspendRendering", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_GetMirrorTextureD3D11, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_017_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_017_GetMirrorTextureD3D11", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_017_GetMirrorTextureD3D11", 1);
+    check_ptr_parameter("IVRCompositor_017_GetMirrorTextureD3D11", (void *)2);
+    check_ptr_parameter("IVRCompositor_017_GetMirrorTextureD3D11", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_GetMirrorTextureGL, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_017_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_GetMirrorTextureGL(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_017_GetMirrorTextureGL", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_017_GetMirrorTextureGL", 1);
+    check_ptr_parameter("IVRCompositor_017_GetMirrorTextureGL", (void *)2);
+    check_ptr_parameter("IVRCompositor_017_GetMirrorTextureGL", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_ReleaseSharedGLTexture, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_017_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_ReleaseSharedGLTexture(1, (void *)2);
+    check_ptr_parameter("IVRCompositor_017_ReleaseSharedGLTexture", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_017_ReleaseSharedGLTexture", 1);
+    check_ptr_parameter("IVRCompositor_017_ReleaseSharedGLTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_LockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_017_LockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_017_LockGLSharedTextureForAccess", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_017_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_017_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_017_UnlockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_017_UnlockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_017_UnlockGLSharedTextureForAccess", (void *)1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
 void test_capi_thunks_IVRSystem_012(void)
 {
     struct thunk *t = alloc_thunks(1);

vrclient_x64/tests/main_autogen.c

@@ -38,6 +38,7 @@ int main(void)
     test_capi_thunks_IVRSystem_014();
     test_capi_thunks_IVRCompositor_018();
     test_capi_thunks_IVROverlay_013();
+    test_capi_thunks_IVRCompositor_017();
     test_capi_thunks_IVRSystem_012();
     test_capi_thunks_IVRCompositor_016();
     test_capi_thunks_IVRSettings_001();

vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_017.cpp

@@ -0,0 +1,194 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.0.3a/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRCompositor_IVRCompositor_017.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+void cppIVRCompositor_IVRCompositor_017_SetTrackingSpace(void *linux_side, ETrackingUniverseOrigin eOrigin)
+{
+    ((IVRCompositor*)linux_side)->SetTrackingSpace((vr::ETrackingUniverseOrigin)eOrigin);
+}
+
+vr::ETrackingUniverseOrigin cppIVRCompositor_IVRCompositor_017_GetTrackingSpace(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->GetTrackingSpace();
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_017_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_017_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_017_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_017_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_017_ClearLastSubmittedFrame(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->ClearLastSubmittedFrame();
+}
+
+void cppIVRCompositor_IVRCompositor_017_PostPresentHandoff(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->PostPresentHandoff();
+}
+
+bool cppIVRCompositor_IVRCompositor_017_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_017_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_017_GetFrameTimeRemaining(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->GetFrameTimeRemaining();
+}
+
+void cppIVRCompositor_IVRCompositor_017_GetCumulativeStats(void *linux_side, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    ((IVRCompositor*)linux_side)->GetCumulativeStats((vr::Compositor_CumulativeStats *)pStats, (uint32_t)nStatsSizeInBytes);
+}
+
+void cppIVRCompositor_IVRCompositor_017_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);
+}
+
+void cppIVRCompositor_IVRCompositor_017_FadeGrid(void *linux_side, float fSeconds, bool bFadeIn)
+{
+    ((IVRCompositor*)linux_side)->FadeGrid((float)fSeconds, (bool)bFadeIn);
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_017_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_017_ClearSkyboxOverride(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->ClearSkyboxOverride();
+}
+
+void cppIVRCompositor_IVRCompositor_017_CompositorBringToFront(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->CompositorBringToFront();
+}
+
+void cppIVRCompositor_IVRCompositor_017_CompositorGoToBack(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->CompositorGoToBack();
+}
+
+void cppIVRCompositor_IVRCompositor_017_CompositorQuit(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->CompositorQuit();
+}
+
+bool cppIVRCompositor_IVRCompositor_017_IsFullscreen(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->IsFullscreen();
+}
+
+uint32_t cppIVRCompositor_IVRCompositor_017_GetCurrentSceneFocusProcess(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->GetCurrentSceneFocusProcess();
+}
+
+uint32_t cppIVRCompositor_IVRCompositor_017_GetLastFrameRenderer(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->GetLastFrameRenderer();
+}
+
+bool cppIVRCompositor_IVRCompositor_017_CanRenderScene(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->CanRenderScene();
+}
+
+void cppIVRCompositor_IVRCompositor_017_ShowMirrorWindow(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->ShowMirrorWindow();
+}
+
+void cppIVRCompositor_IVRCompositor_017_HideMirrorWindow(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->HideMirrorWindow();
+}
+
+bool cppIVRCompositor_IVRCompositor_017_IsMirrorWindowVisible(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->IsMirrorWindowVisible();
+}
+
+void cppIVRCompositor_IVRCompositor_017_CompositorDumpImages(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->CompositorDumpImages();
+}
+
+bool cppIVRCompositor_IVRCompositor_017_ShouldAppRenderWithLowResources(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->ShouldAppRenderWithLowResources();
+}
+
+void cppIVRCompositor_IVRCompositor_017_ForceInterleavedReprojectionOn(void *linux_side, bool bOverride)
+{
+    ((IVRCompositor*)linux_side)->ForceInterleavedReprojectionOn((bool)bOverride);
+}
+
+void cppIVRCompositor_IVRCompositor_017_ForceReconnectProcess(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->ForceReconnectProcess();
+}
+
+void cppIVRCompositor_IVRCompositor_017_SuspendRendering(void *linux_side, bool bSuspend)
+{
+    ((IVRCompositor*)linux_side)->SuspendRendering((bool)bSuspend);
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_017_GetMirrorTextureD3D11(void *linux_side, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+{
+    return ((IVRCompositor*)linux_side)->GetMirrorTextureD3D11((vr::EVREye)eEye, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView);
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_017_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_017_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_017_LockGLSharedTextureForAccess(void *linux_side, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    ((IVRCompositor*)linux_side)->LockGLSharedTextureForAccess((vr::glSharedTextureHandle_t)glSharedTextureHandle);
+}
+
+void cppIVRCompositor_IVRCompositor_017_UnlockGLSharedTextureForAccess(void *linux_side, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    ((IVRCompositor*)linux_side)->UnlockGLSharedTextureForAccess((vr::glSharedTextureHandle_t)glSharedTextureHandle);
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_017.h

@@ -0,0 +1,42 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern void cppIVRCompositor_IVRCompositor_017_SetTrackingSpace(void *, ETrackingUniverseOrigin);
+extern ETrackingUniverseOrigin cppIVRCompositor_IVRCompositor_017_GetTrackingSpace(void *);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_017_WaitGetPoses(void *, TrackedDevicePose_t *, uint32_t, TrackedDevicePose_t *, uint32_t);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_017_GetLastPoses(void *, TrackedDevicePose_t *, uint32_t, TrackedDevicePose_t *, uint32_t);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex(void *, TrackedDeviceIndex_t, TrackedDevicePose_t *, TrackedDevicePose_t *);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_017_Submit(void *, EVREye, Texture_t *, VRTextureBounds_t *, EVRSubmitFlags);
+extern void cppIVRCompositor_IVRCompositor_017_ClearLastSubmittedFrame(void *);
+extern void cppIVRCompositor_IVRCompositor_017_PostPresentHandoff(void *);
+extern bool cppIVRCompositor_IVRCompositor_017_GetFrameTiming(void *, Compositor_FrameTiming *, uint32_t);
+extern uint32_t cppIVRCompositor_IVRCompositor_017_GetFrameTimings(void *, Compositor_FrameTiming *, uint32_t);
+extern float cppIVRCompositor_IVRCompositor_017_GetFrameTimeRemaining(void *);
+extern void cppIVRCompositor_IVRCompositor_017_GetCumulativeStats(void *, Compositor_CumulativeStats *, uint32_t);
+extern void cppIVRCompositor_IVRCompositor_017_FadeToColor(void *, float, float, float, float, float, bool);
+extern void cppIVRCompositor_IVRCompositor_017_FadeGrid(void *, float, bool);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_017_SetSkyboxOverride(void *, Texture_t *, uint32_t);
+extern void cppIVRCompositor_IVRCompositor_017_ClearSkyboxOverride(void *);
+extern void cppIVRCompositor_IVRCompositor_017_CompositorBringToFront(void *);
+extern void cppIVRCompositor_IVRCompositor_017_CompositorGoToBack(void *);
+extern void cppIVRCompositor_IVRCompositor_017_CompositorQuit(void *);
+extern bool cppIVRCompositor_IVRCompositor_017_IsFullscreen(void *);
+extern uint32_t cppIVRCompositor_IVRCompositor_017_GetCurrentSceneFocusProcess(void *);
+extern uint32_t cppIVRCompositor_IVRCompositor_017_GetLastFrameRenderer(void *);
+extern bool cppIVRCompositor_IVRCompositor_017_CanRenderScene(void *);
+extern void cppIVRCompositor_IVRCompositor_017_ShowMirrorWindow(void *);
+extern void cppIVRCompositor_IVRCompositor_017_HideMirrorWindow(void *);
+extern bool cppIVRCompositor_IVRCompositor_017_IsMirrorWindowVisible(void *);
+extern void cppIVRCompositor_IVRCompositor_017_CompositorDumpImages(void *);
+extern bool cppIVRCompositor_IVRCompositor_017_ShouldAppRenderWithLowResources(void *);
+extern void cppIVRCompositor_IVRCompositor_017_ForceInterleavedReprojectionOn(void *, bool);
+extern void cppIVRCompositor_IVRCompositor_017_ForceReconnectProcess(void *);
+extern void cppIVRCompositor_IVRCompositor_017_SuspendRendering(void *, bool);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_017_GetMirrorTextureD3D11(void *, EVREye, void *, void **);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_017_GetMirrorTextureGL(void *, EVREye, glUInt_t *, glSharedTextureHandle_t *);
+extern bool cppIVRCompositor_IVRCompositor_017_ReleaseSharedGLTexture(void *, glUInt_t, glSharedTextureHandle_t);
+extern void cppIVRCompositor_IVRCompositor_017_LockGLSharedTextureForAccess(void *, glSharedTextureHandle_t);
+extern void cppIVRCompositor_IVRCompositor_017_UnlockGLSharedTextureForAccess(void *, glSharedTextureHandle_t);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/struct_converters.h

@@ -138,6 +138,16 @@ extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_104_unwrap(winR
 typedef struct winRenderModel_t_104 winRenderModel_t_104;
 extern struct winRenderModel_t_104 *struct_RenderModel_t_104_wrap(void *l);
 extern RenderModel_t *struct_RenderModel_t_104_unwrap(winRenderModel_t_104 *w);
+typedef struct winVREvent_t_103a winVREvent_t_103a;
+extern void struct_VREvent_t_103a_lin_to_win(void *l, void *w);
+typedef struct winVRControllerState001_t_103a winVRControllerState001_t_103a;
+extern void struct_VRControllerState001_t_103a_lin_to_win(void *l, void *w);
+typedef struct winRenderModel_TextureMap_t_103a winRenderModel_TextureMap_t_103a;
+extern struct winRenderModel_TextureMap_t_103a *struct_RenderModel_TextureMap_t_103a_wrap(void *l);
+extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_103a_unwrap(winRenderModel_TextureMap_t_103a *w);
+typedef struct winRenderModel_t_103a winRenderModel_t_103a;
+extern struct winRenderModel_t_103a *struct_RenderModel_t_103a_wrap(void *l);
+extern RenderModel_t *struct_RenderModel_t_103a_unwrap(winRenderModel_t_103a *w);
 typedef struct winVREvent_t_103 winVREvent_t_103;
 extern void struct_VREvent_t_103_lin_to_win(void *l, void *w);
 typedef struct winVRControllerState001_t_103 winVRControllerState001_t_103;

vrclient_x64/vrclient_x64/struct_converters_103a.cpp

@@ -0,0 +1,100 @@
+#include <stdlib.h>
+#include <string.h>
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.0.3a/openvr.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+struct winVREvent_t_103a {
+    uint32_t eventType;
+    vr::TrackedDeviceIndex_t trackedDeviceIndex;
+    float eventAgeSeconds;
+    vr::VREvent_Data_t data;
+}  __attribute__ ((ms_struct));
+
+void struct_VREvent_t_103a_lin_to_win(void *l, void *w)
+{
+    struct winVREvent_t_103a *win = (struct winVREvent_t_103a *)w;
+    VREvent_t *lin = (VREvent_t *)l;
+    win->eventType = lin->eventType;
+    win->trackedDeviceIndex = lin->trackedDeviceIndex;
+    win->eventAgeSeconds = lin->eventAgeSeconds;
+    win->data = lin->data;
+}
+
+struct winVRControllerState001_t_103a {
+    uint32_t unPacketNum;
+    uint64_t ulButtonPressed;
+    uint64_t ulButtonTouched;
+    vr::VRControllerAxis_t rAxis[5];
+}  __attribute__ ((ms_struct));
+
+void struct_VRControllerState001_t_103a_lin_to_win(void *l, void *w)
+{
+    struct winVRControllerState001_t_103a *win = (struct winVRControllerState001_t_103a *)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));
+}
+
+struct winRenderModel_TextureMap_t_103a {
+    uint16_t unWidth;
+    uint16_t unHeight;
+    const uint8_t * rubTextureMapData;
+
+    RenderModel_TextureMap_t *linux_side;
+}  __attribute__ ((ms_struct));
+
+struct winRenderModel_TextureMap_t_103a *struct_RenderModel_TextureMap_t_103a_wrap(void *l)
+{
+    struct winRenderModel_TextureMap_t_103a *win = (struct winRenderModel_TextureMap_t_103a *)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_103a_unwrap(winRenderModel_TextureMap_t_103a *w)
+{
+    RenderModel_TextureMap_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+struct winRenderModel_t_103a {
+    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));
+
+struct winRenderModel_t_103a *struct_RenderModel_t_103a_wrap(void *l)
+{
+    struct winRenderModel_t_103a *win = (struct winRenderModel_t_103a *)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_103a_unwrap(winRenderModel_t_103a *w)
+{
+    RenderModel_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+
+}

vrclient_x64/vrclient_x64/winIVRCompositor.c

@@ -2173,6 +2173,391 @@ void destroy_winIVRCompositor_IVRCompositor_018_FnTable(void *object)
     HeapFree(GetProcessHeap(), 0, win_object);
 }
 
+#include "cppIVRCompositor_IVRCompositor_017.h"
+
+typedef struct __winIVRCompositor_IVRCompositor_017 {
+    vtable_ptr *vtable;
+    void *linux_side;
+    struct compositor_data user_data;
+} winIVRCompositor_IVRCompositor_017;
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_SetTrackingSpace, 8)
+void __thiscall winIVRCompositor_IVRCompositor_017_SetTrackingSpace(winIVRCompositor_IVRCompositor_017 *_this, ETrackingUniverseOrigin eOrigin)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_SetTrackingSpace(_this->linux_side, eOrigin);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetTrackingSpace, 4)
+ETrackingUniverseOrigin __thiscall winIVRCompositor_IVRCompositor_017_GetTrackingSpace(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_GetTrackingSpace(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_WaitGetPoses, 28)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_017_WaitGetPoses(winIVRCompositor_IVRCompositor_017 *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    TRACE("%p\n", _this);
+    return ivrcompositor_wait_get_poses(cppIVRCompositor_IVRCompositor_017_WaitGetPoses, _this->linux_side, pRenderPoseArray, unRenderPoseArrayCount, pGamePoseArray, unGamePoseArrayCount, 17, &_this->user_data);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetLastPoses, 28)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_017_GetLastPoses(winIVRCompositor_IVRCompositor_017 *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_GetLastPoses(_this->linux_side, pRenderPoseArray, unRenderPoseArrayCount, pGamePoseArray, unGamePoseArrayCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex, 24)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex(winIVRCompositor_IVRCompositor_017 *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex(_this->linux_side, unDeviceIndex, pOutputPose, pOutputGamePose);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_Submit, 28)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_017_Submit(winIVRCompositor_IVRCompositor_017 *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    TRACE("%p\n", _this);
+    return ivrcompositor_submit(cppIVRCompositor_IVRCompositor_017_Submit, _this->linux_side, eEye, pTexture, pBounds, nSubmitFlags, 17, &_this->user_data);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_ClearLastSubmittedFrame, 4)
+void __thiscall winIVRCompositor_IVRCompositor_017_ClearLastSubmittedFrame(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_ClearLastSubmittedFrame(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_PostPresentHandoff, 4)
+void __thiscall winIVRCompositor_IVRCompositor_017_PostPresentHandoff(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    ivrcompositor_post_present_handoff(cppIVRCompositor_IVRCompositor_017_PostPresentHandoff, _this->linux_side, 17, &_this->user_data);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetFrameTiming, 16)
+bool __thiscall winIVRCompositor_IVRCompositor_017_GetFrameTiming(winIVRCompositor_IVRCompositor_017 *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_GetFrameTiming(_this->linux_side, pTiming, unFramesAgo);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetFrameTimings, 16)
+uint32_t __thiscall winIVRCompositor_IVRCompositor_017_GetFrameTimings(winIVRCompositor_IVRCompositor_017 *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_GetFrameTimings(_this->linux_side, pTiming, nFrames);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetFrameTimeRemaining, 4)
+float __thiscall winIVRCompositor_IVRCompositor_017_GetFrameTimeRemaining(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_GetFrameTimeRemaining(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetCumulativeStats, 16)
+void __thiscall winIVRCompositor_IVRCompositor_017_GetCumulativeStats(winIVRCompositor_IVRCompositor_017 *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_GetCumulativeStats(_this->linux_side, pStats, nStatsSizeInBytes);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_FadeToColor, 25)
+void __thiscall winIVRCompositor_IVRCompositor_017_FadeToColor(winIVRCompositor_IVRCompositor_017 *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_FadeToColor(_this->linux_side, fSeconds, fRed, fGreen, fBlue, fAlpha, bBackground);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_FadeGrid, 9)
+void __thiscall winIVRCompositor_IVRCompositor_017_FadeGrid(winIVRCompositor_IVRCompositor_017 *_this, float fSeconds, bool bFadeIn)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_FadeGrid(_this->linux_side, fSeconds, bFadeIn);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_SetSkyboxOverride, 16)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_017_SetSkyboxOverride(winIVRCompositor_IVRCompositor_017 *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_SetSkyboxOverride(_this->linux_side, pTextures, unTextureCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_ClearSkyboxOverride, 4)
+void __thiscall winIVRCompositor_IVRCompositor_017_ClearSkyboxOverride(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_ClearSkyboxOverride(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_CompositorBringToFront, 4)
+void __thiscall winIVRCompositor_IVRCompositor_017_CompositorBringToFront(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_CompositorBringToFront(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_CompositorGoToBack, 4)
+void __thiscall winIVRCompositor_IVRCompositor_017_CompositorGoToBack(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_CompositorGoToBack(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_CompositorQuit, 4)
+void __thiscall winIVRCompositor_IVRCompositor_017_CompositorQuit(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_CompositorQuit(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_IsFullscreen, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_017_IsFullscreen(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_IsFullscreen(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetCurrentSceneFocusProcess, 4)
+uint32_t __thiscall winIVRCompositor_IVRCompositor_017_GetCurrentSceneFocusProcess(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_GetCurrentSceneFocusProcess(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetLastFrameRenderer, 4)
+uint32_t __thiscall winIVRCompositor_IVRCompositor_017_GetLastFrameRenderer(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_GetLastFrameRenderer(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_CanRenderScene, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_017_CanRenderScene(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_CanRenderScene(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_ShowMirrorWindow, 4)
+void __thiscall winIVRCompositor_IVRCompositor_017_ShowMirrorWindow(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_ShowMirrorWindow(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_HideMirrorWindow, 4)
+void __thiscall winIVRCompositor_IVRCompositor_017_HideMirrorWindow(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_HideMirrorWindow(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_IsMirrorWindowVisible, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_017_IsMirrorWindowVisible(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_IsMirrorWindowVisible(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_CompositorDumpImages, 4)
+void __thiscall winIVRCompositor_IVRCompositor_017_CompositorDumpImages(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_CompositorDumpImages(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_ShouldAppRenderWithLowResources, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_017_ShouldAppRenderWithLowResources(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_ShouldAppRenderWithLowResources(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_ForceInterleavedReprojectionOn, 5)
+void __thiscall winIVRCompositor_IVRCompositor_017_ForceInterleavedReprojectionOn(winIVRCompositor_IVRCompositor_017 *_this, bool bOverride)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_ForceInterleavedReprojectionOn(_this->linux_side, bOverride);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_ForceReconnectProcess, 4)
+void __thiscall winIVRCompositor_IVRCompositor_017_ForceReconnectProcess(winIVRCompositor_IVRCompositor_017 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_ForceReconnectProcess(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_SuspendRendering, 5)
+void __thiscall winIVRCompositor_IVRCompositor_017_SuspendRendering(winIVRCompositor_IVRCompositor_017 *_this, bool bSuspend)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_SuspendRendering(_this->linux_side, bSuspend);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetMirrorTextureD3D11, 24)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_017_GetMirrorTextureD3D11(winIVRCompositor_IVRCompositor_017 *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_GetMirrorTextureD3D11(_this->linux_side, eEye, pD3D11DeviceOrResource, ppD3D11ShaderResourceView);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetMirrorTextureGL, 24)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_017_GetMirrorTextureGL(winIVRCompositor_IVRCompositor_017 *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_GetMirrorTextureGL(_this->linux_side, eEye, pglTextureId, pglSharedTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_ReleaseSharedGLTexture, 16)
+bool __thiscall winIVRCompositor_IVRCompositor_017_ReleaseSharedGLTexture(winIVRCompositor_IVRCompositor_017 *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_017_ReleaseSharedGLTexture(_this->linux_side, glTextureId, glSharedTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_LockGLSharedTextureForAccess, 12)
+void __thiscall winIVRCompositor_IVRCompositor_017_LockGLSharedTextureForAccess(winIVRCompositor_IVRCompositor_017 *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_LockGLSharedTextureForAccess(_this->linux_side, glSharedTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_UnlockGLSharedTextureForAccess, 12)
+void __thiscall winIVRCompositor_IVRCompositor_017_UnlockGLSharedTextureForAccess(winIVRCompositor_IVRCompositor_017 *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_017_UnlockGLSharedTextureForAccess(_this->linux_side, glSharedTextureHandle);
+}
+
+extern vtable_ptr winIVRCompositor_IVRCompositor_017_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRCompositor_IVRCompositor_017,
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_SetTrackingSpace)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetTrackingSpace)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_WaitGetPoses)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetLastPoses)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_Submit)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_ClearLastSubmittedFrame)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_PostPresentHandoff)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetFrameTiming)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetFrameTimings)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetFrameTimeRemaining)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetCumulativeStats)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_FadeToColor)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_FadeGrid)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_SetSkyboxOverride)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_ClearSkyboxOverride)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_CompositorBringToFront)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_CompositorGoToBack)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_CompositorQuit)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_IsFullscreen)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetCurrentSceneFocusProcess)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetLastFrameRenderer)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_CanRenderScene)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_ShowMirrorWindow)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_HideMirrorWindow)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_IsMirrorWindowVisible)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_CompositorDumpImages)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_ShouldAppRenderWithLowResources)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_ForceInterleavedReprojectionOn)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_ForceReconnectProcess)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_SuspendRendering)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetMirrorTextureD3D11)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetMirrorTextureGL)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_ReleaseSharedGLTexture)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_LockGLSharedTextureForAccess)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_UnlockGLSharedTextureForAccess)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRCompositor_IVRCompositor_017 *create_winIVRCompositor_IVRCompositor_017(void *linux_side)
+{
+    winIVRCompositor_IVRCompositor_017 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_017));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRCompositor_IVRCompositor_017_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRCompositor_IVRCompositor_017(void *object)
+{
+    TRACE("%p\n", object);
+    struct __winIVRCompositor_IVRCompositor_017 *win_object = object;
+    destroy_compositor_data(&win_object->user_data);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRCompositor_IVRCompositor_017 *create_winIVRCompositor_IVRCompositor_017_FnTable(void *linux_side)
+{
+    winIVRCompositor_IVRCompositor_017 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_017));
+    struct thunk *thunks = alloc_thunks(36);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 36 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_017_SetTrackingSpace, 1, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_017_GetTrackingSpace, 0, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_017_WaitGetPoses, 4, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_017_GetLastPoses, 4, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_017_Submit, 4, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_017_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_017_PostPresentHandoff, 0, FALSE, FALSE);
+    init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_017_GetFrameTiming, 2, FALSE, FALSE);
+    init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_017_GetFrameTimings, 2, FALSE, FALSE);
+    init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_017_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_017_GetCumulativeStats, 2, FALSE, FALSE);
+    init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_017_FadeToColor, 6, TRUE, TRUE);
+    init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_017_FadeGrid, 2, TRUE, FALSE);
+    init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_017_SetSkyboxOverride, 2, FALSE, FALSE);
+    init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_017_ClearSkyboxOverride, 0, FALSE, FALSE);
+    init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_017_CompositorBringToFront, 0, FALSE, FALSE);
+    init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_017_CompositorGoToBack, 0, FALSE, FALSE);
+    init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_017_CompositorQuit, 0, FALSE, FALSE);
+    init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_017_IsFullscreen, 0, FALSE, FALSE);
+    init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_017_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_017_GetLastFrameRenderer, 0, FALSE, FALSE);
+    init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_017_CanRenderScene, 0, FALSE, FALSE);
+    init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_017_ShowMirrorWindow, 0, FALSE, FALSE);
+    init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_017_HideMirrorWindow, 0, FALSE, FALSE);
+    init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_017_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    init_thunk(&thunks[26], r, winIVRCompositor_IVRCompositor_017_CompositorDumpImages, 0, FALSE, FALSE);
+    init_thunk(&thunks[27], r, winIVRCompositor_IVRCompositor_017_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    init_thunk(&thunks[28], r, winIVRCompositor_IVRCompositor_017_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    init_thunk(&thunks[29], r, winIVRCompositor_IVRCompositor_017_ForceReconnectProcess, 0, FALSE, FALSE);
+    init_thunk(&thunks[30], r, winIVRCompositor_IVRCompositor_017_SuspendRendering, 1, FALSE, FALSE);
+    init_thunk(&thunks[31], r, winIVRCompositor_IVRCompositor_017_GetMirrorTextureD3D11, 3, FALSE, FALSE);
+    init_thunk(&thunks[32], r, winIVRCompositor_IVRCompositor_017_GetMirrorTextureGL, 3, FALSE, FALSE);
+    init_thunk(&thunks[33], r, winIVRCompositor_IVRCompositor_017_ReleaseSharedGLTexture, 2, FALSE, FALSE);
+    init_thunk(&thunks[34], r, winIVRCompositor_IVRCompositor_017_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    init_thunk(&thunks[35], r, winIVRCompositor_IVRCompositor_017_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    for (i = 0; i < 36; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVRCompositor_IVRCompositor_017_FnTable(void *object)
+{
+    winIVRCompositor_IVRCompositor_017 *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_016.h"
 
 typedef struct __winIVRCompositor_IVRCompositor_016 {

vrclient_x64/vrclient_x64/win_constructors.h

@@ -64,6 +64,8 @@ extern void *create_winIVRCompositor_IVRCompositor_018(void *);
 extern void *create_winIVRCompositor_IVRCompositor_018_FnTable(void *);
 extern void *create_winIVROverlay_IVROverlay_013(void *);
 extern void *create_winIVROverlay_IVROverlay_013_FnTable(void *);
+extern void *create_winIVRCompositor_IVRCompositor_017(void *);
+extern void *create_winIVRCompositor_IVRCompositor_017_FnTable(void *);
 extern void *create_winIVRSystem_IVRSystem_012(void *);
 extern void *create_winIVRSystem_IVRSystem_012_FnTable(void *);
 extern void *create_winIVRCompositor_IVRCompositor_016(void *);

vrclient_x64/vrclient_x64/win_constructors_table.dat

@@ -64,6 +64,8 @@
     {"FnTable:IVRCompositor_018", &create_winIVRCompositor_IVRCompositor_018_FnTable, &destroy_winIVRCompositor_IVRCompositor_018_FnTable},
     {"IVROverlay_013", &create_winIVROverlay_IVROverlay_013, &destroy_winIVROverlay_IVROverlay_013},
     {"FnTable:IVROverlay_013", &create_winIVROverlay_IVROverlay_013_FnTable, &destroy_winIVROverlay_IVROverlay_013_FnTable},
+    {"IVRCompositor_017", &create_winIVRCompositor_IVRCompositor_017, &destroy_winIVRCompositor_IVRCompositor_017},
+    {"FnTable:IVRCompositor_017", &create_winIVRCompositor_IVRCompositor_017_FnTable, &destroy_winIVRCompositor_IVRCompositor_017_FnTable},
     {"IVRSystem_012", &create_winIVRSystem_IVRSystem_012, &destroy_winIVRSystem_IVRSystem_012},
     {"FnTable:IVRSystem_012", &create_winIVRSystem_IVRSystem_012_FnTable, &destroy_winIVRSystem_IVRSystem_012_FnTable},
     {"IVRCompositor_016", &create_winIVRCompositor_IVRCompositor_016, &destroy_winIVRCompositor_IVRCompositor_016},

vrclient_x64/vrclient_x64/win_destructors.h

@@ -64,6 +64,8 @@ extern void destroy_winIVRCompositor_IVRCompositor_018(void *);
 extern void destroy_winIVRCompositor_IVRCompositor_018_FnTable(void *);
 extern void destroy_winIVROverlay_IVROverlay_013(void *);
 extern void destroy_winIVROverlay_IVROverlay_013_FnTable(void *);
+extern void destroy_winIVRCompositor_IVRCompositor_017(void *);
+extern void destroy_winIVRCompositor_IVRCompositor_017_FnTable(void *);
 extern void destroy_winIVRSystem_IVRSystem_012(void *);
 extern void destroy_winIVRSystem_IVRSystem_012_FnTable(void *);
 extern void destroy_winIVRCompositor_IVRCompositor_016(void *);