vrclient: Support v1.16.8.

Signed-off-by: Paul Gofman <pgofman@codeweavers.com>

vrclient_x64/gen_wrapper.py

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

vrclient_x64/openvr_v1.16.8/ivrclientcore.h

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

vrclient_x64/tests/main_autogen.c

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

vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_007.cpp

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

vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.cpp

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

vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_004.cpp

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

vrclient_x64/vrclient_x64/cppIVRClientCore_IVRClientCore_003.cpp

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

vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_027.cpp

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

vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_027.h

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

vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRExtendedDisplay_IVRExtendedDisplay_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRHeadsetView_IVRHeadsetView_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_002.cpp

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

vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
@@ -34,63 +34,63 @@ vr::EVRInputError cppIVRInput_IVRInput_010_UpdateActionState(void *linux_side, V
     return ((IVRInput*)linux_side)->UpdateActionState((vr::VRActiveActionSet_t *)pSets, (uint32_t)unSizeOfVRSelectedActionSet_t, (uint32_t)unSetCount);
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputDigitalActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputDigitalActionData_t_11415_win_to_lin(pActionData, &lin);
+        struct_InputDigitalActionData_t_1168_win_to_lin(pActionData, &lin);
     _ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0, (vr::VRInputValueHandle_t)ulRestrictToDevice);
     if(pActionData)
-        struct_InputDigitalActionData_t_11415_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputDigitalActionData_t_1168_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputAnalogActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputAnalogActionData_t_11415_win_to_lin(pActionData, &lin);
+        struct_InputAnalogActionData_t_1168_win_to_lin(pActionData, &lin);
     _ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0, (vr::VRInputValueHandle_t)ulRestrictToDevice);
     if(pActionData)
-        struct_InputAnalogActionData_t_11415_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputAnalogActionData_t_1168_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputPoseActionData_t_11415_win_to_lin(pActionData, &lin);
+        struct_InputPoseActionData_t_1168_win_to_lin(pActionData, &lin);
     _ret = ((IVRInput*)linux_side)->GetPoseActionDataRelativeToNow((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0, (vr::VRInputValueHandle_t)ulRestrictToDevice);
     if(pActionData)
-        struct_InputPoseActionData_t_11415_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputPoseActionData_t_1168_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputPoseActionData_t_11415_win_to_lin(pActionData, &lin);
+        struct_InputPoseActionData_t_1168_win_to_lin(pActionData, &lin);
     _ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0, (vr::VRInputValueHandle_t)ulRestrictToDevice);
     if(pActionData)
-        struct_InputPoseActionData_t_11415_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputPoseActionData_t_1168_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_11415 * pActionData, uint32_t unActionDataSize)
+vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1168 * pActionData, uint32_t unActionDataSize)
 {
     InputSkeletalActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputSkeletalActionData_t_11415_win_to_lin(pActionData, &lin);
+        struct_InputSkeletalActionData_t_1168_win_to_lin(pActionData, &lin);
     _ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0);
     if(pActionData)
-        struct_InputSkeletalActionData_t_11415_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputSkeletalActionData_t_1168_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 

vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.h

@@ -6,11 +6,11 @@ extern EVRInputError cppIVRInput_IVRInput_010_GetActionSetHandle(void *, const c
 extern EVRInputError cppIVRInput_IVRInput_010_GetActionHandle(void *, const char *, VRActionHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_010_GetInputSourceHandle(void *, const char *, VRInputValueHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_010_UpdateActionState(void *, VRActiveActionSet_t *, uint32_t, uint32_t);
-extern EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *, VRActionHandle_t, winInputDigitalActionData_t_11415 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_11415 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_11415 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_11415 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_11415 *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *, VRActionHandle_t, winInputDigitalActionData_t_1168 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_1168 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_1168 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_1168 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_1168 *, uint32_t);
 extern EVRInputError cppIVRInput_IVRInput_010_GetDominantHand(void *, ETrackedControllerRole *);
 extern EVRInputError cppIVRInput_IVRInput_010_SetDominantHand(void *, ETrackedControllerRole);
 extern EVRInputError cppIVRInput_IVRInput_010_GetBoneCount(void *, VRActionHandle_t, uint32_t *);