vrclient: Add openvr v1.0.16 and v1.0.17 support

vrclient_x64/gen_wrapper.py

@@ -12,6 +12,8 @@ import os
 import re
 
 sdk_versions = [
+    "v1.0.17",
+    "v1.0.16",
     "v1.0.15",
     "v1.0.14",
     "v1.0.13",
@@ -178,7 +180,7 @@ def ivrcompositor_get_vulkan_device_extensions_required(cppname, method):
     return "ivrcompositor_get_vulkan_device_extensions_required"
 
 def ivrrendermodels_load_into_texture_d3d11_async(cppname, method):
-    assert "005" in cppname
+    assert "005" in cppname or "006" in cppname
     return "ivrrendermodels_load_into_texture_d3d11_async"
 
 method_overrides = [
@@ -970,7 +972,7 @@ for sdkver in sdk_versions:
         if not os.path.isfile(input_name):
             continue
         index = clang.cindex.Index.create()
-        tu = index.parse(input_name, args=['-x', 'c++', '-std=c++11', '-DGNUC', '-Iopenvr_%s/' % sdkver, '-I/usr/lib/clang/5.0.0/include/'])
+        tu = index.parse(input_name, args=['-x', 'c++', '-std=c++11', '-DGNUC', '-Iopenvr_%s/' % sdkver, '-I/usr/lib/clang/7.0.0/include/'])
 
         diagnostics = list(tu.diagnostics)
         if len(diagnostics) > 0:

vrclient_x64/openvr_v1.0.16/ivrclientcore.h

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

vrclient_x64/openvr_v1.0.17/ivrclientcore.h

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

vrclient_x64/tests/capi_thunks_autogen.h

@@ -517,6 +517,202 @@ VRMessageOverlayResponse __thiscall IVROverlay_018_ShowMessageOverlay(void *_thi
 
 void __thiscall IVROverlay_018_CloseMessageOverlay(void *_this);
 
+void test_capi_thunks_IVRRenderModels_006(void);
+
+EVRRenderModelError __thiscall IVRRenderModels_006_LoadRenderModel_Async(void *_this, const char * pchRenderModelName, RenderModel_t ** ppRenderModel);
+
+void __thiscall IVRRenderModels_006_FreeRenderModel(void *_this, RenderModel_t * pRenderModel);
+
+EVRRenderModelError __thiscall IVRRenderModels_006_LoadTexture_Async(void *_this, TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture);
+
+void __thiscall IVRRenderModels_006_FreeTexture(void *_this, RenderModel_TextureMap_t * pTexture);
+
+EVRRenderModelError __thiscall IVRRenderModels_006_LoadTextureD3D11_Async(void *_this, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D);
+
+EVRRenderModelError __thiscall IVRRenderModels_006_LoadIntoTextureD3D11_Async(void *_this, TextureID_t textureId, void * pDstTexture);
+
+void __thiscall IVRRenderModels_006_FreeTextureD3D11(void *_this, void * pD3D11Texture2D);
+
+uint32_t __thiscall IVRRenderModels_006_GetRenderModelName(void *_this, uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen);
+
+uint32_t __thiscall IVRRenderModels_006_GetRenderModelCount(void *_this);
+
+uint32_t __thiscall IVRRenderModels_006_GetComponentCount(void *_this, const char * pchRenderModelName);
+
+uint32_t __thiscall IVRRenderModels_006_GetComponentName(void *_this, const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen);
+
+uint64_t __thiscall IVRRenderModels_006_GetComponentButtonMask(void *_this, const char * pchRenderModelName, const char * pchComponentName);
+
+uint32_t __thiscall IVRRenderModels_006_GetComponentRenderModelName(void *_this, const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen);
+
+bool __thiscall IVRRenderModels_006_GetComponentStateForDevicePath(void *_this, const char * pchRenderModelName, const char * pchComponentName, VRInputValueHandle_t devicePath, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState);
+
+bool __thiscall IVRRenderModels_006_GetComponentState(void *_this, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState);
+
+bool __thiscall IVRRenderModels_006_RenderModelHasComponent(void *_this, const char * pchRenderModelName, const char * pchComponentName);
+
+uint32_t __thiscall IVRRenderModels_006_GetRenderModelThumbnailURL(void *_this, const char * pchRenderModelName, char * pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError * peError);
+
+uint32_t __thiscall IVRRenderModels_006_GetRenderModelOriginalPath(void *_this, const char * pchRenderModelName, char * pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError * peError);
+
+const char * __thiscall IVRRenderModels_006_GetRenderModelErrorNameFromEnum(void *_this, EVRRenderModelError error);
+
+void test_capi_thunks_IVRExtendedDisplay_001(void);
+
+void __thiscall IVRExtendedDisplay_001_GetWindowBounds(void *_this, int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRExtendedDisplay_001_GetEyeOutputViewport(void *_this, EVREye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+
+void __thiscall IVRExtendedDisplay_001_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex);
+
+void test_capi_thunks_IVRTrackedCamera_004(void);
+
+const char * __thiscall IVRTrackedCamera_004_GetCameraErrorNameFromEnum(void *_this, EVRTrackedCameraError eCameraError);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_004_HasCamera(void *_this, TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_004_GetCameraFrameSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_004_GetCameraIntrinsics(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_004_GetCameraProjection(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_004_AcquireVideoStreamingService(void *_this, TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_004_ReleaseVideoStreamingService(void *_this, TrackedCameraHandle_t hTrackedCamera);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_004_GetVideoStreamFrameBuffer(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_004_GetVideoStreamTextureSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_004_GetVideoStreamTextureD3D11(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_004_GetVideoStreamTextureGL(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_004_ReleaseVideoStreamTextureGL(void *_this, TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId);
+
+void test_capi_thunks_IVRScreenshots_001(void);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_RequestScreenshot(void *_this, ScreenshotHandle_t * pOutScreenshotHandle, EVRScreenshotType type, const char * pchPreviewFilename, const char * pchVRFilename);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_HookScreenshot(void *_this, EVRScreenshotType * pSupportedTypes, int numTypes);
+
+EVRScreenshotType __thiscall IVRScreenshots_001_GetScreenshotPropertyType(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotError * pError);
+
+uint32_t __thiscall IVRScreenshots_001_GetScreenshotPropertyFilename(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotPropertyFilenames filenameType, char * pchFilename, uint32_t cchFilename, EVRScreenshotError * pError);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_UpdateScreenshotProgress(void *_this, ScreenshotHandle_t screenshotHandle, float flProgress);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_TakeStereoScreenshot(void *_this, ScreenshotHandle_t * pOutScreenshotHandle, const char * pchPreviewFilename, const char * pchVRFilename);
+
+EVRScreenshotError __thiscall IVRScreenshots_001_SubmitScreenshot(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotType type, const char * pchSourcePreviewFilename, const char * pchSourceVRFilename);
+
+void test_capi_thunks_IVRResources_001(void);
+
+uint32_t __thiscall IVRResources_001_LoadSharedResource(void *_this, const char * pchResourceName, char * pchBuffer, uint32_t unBufferLen);
+
+uint32_t __thiscall IVRResources_001_GetResourceFullPath(void *_this, const char * pchResourceName, const char * pchResourceTypeDirectory, char * pchPathBuffer, uint32_t unBufferLen);
+
+void test_capi_thunks_IVRDriverManager_001(void);
+
+uint32_t __thiscall IVRDriverManager_001_GetDriverCount(void *_this);
+
+uint32_t __thiscall IVRDriverManager_001_GetDriverName(void *_this, DriverId_t nDriver, char * pchValue, uint32_t unBufferSize);
+
+DriverHandle_t __thiscall IVRDriverManager_001_GetDriverHandle(void *_this, const char * pchDriverName);
+
+void test_capi_thunks_IVRInput_004(void);
+
+EVRInputError __thiscall IVRInput_004_SetActionManifestPath(void *_this, const char * pchActionManifestPath);
+
+EVRInputError __thiscall IVRInput_004_GetActionSetHandle(void *_this, const char * pchActionSetName, VRActionSetHandle_t * pHandle);
+
+EVRInputError __thiscall IVRInput_004_GetActionHandle(void *_this, const char * pchActionName, VRActionHandle_t * pHandle);
+
+EVRInputError __thiscall IVRInput_004_GetInputSourceHandle(void *_this, const char * pchInputSourcePath, VRInputValueHandle_t * pHandle);
+
+EVRInputError __thiscall IVRInput_004_UpdateActionState(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount);
+
+EVRInputError __thiscall IVRInput_004_GetDigitalActionData(void *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+
+EVRInputError __thiscall IVRInput_004_GetAnalogActionData(void *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+
+EVRInputError __thiscall IVRInput_004_GetPoseActionData(void *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+
+EVRInputError __thiscall IVRInput_004_GetSkeletalActionData(void *_this, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+
+EVRInputError __thiscall IVRInput_004_GetSkeletalBoneData(void *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount, VRInputValueHandle_t ulRestrictToDevice);
+
+EVRInputError __thiscall IVRInput_004_GetSkeletalBoneDataCompressed(void *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize, VRInputValueHandle_t ulRestrictToDevice);
+
+EVRInputError __thiscall IVRInput_004_DecompressSkeletalBoneData(void *_this, void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace * peTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
+
+EVRInputError __thiscall IVRInput_004_TriggerHapticVibrationAction(void *_this, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice);
+
+EVRInputError __thiscall IVRInput_004_GetActionOrigins(void *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount);
+
+EVRInputError __thiscall IVRInput_004_GetOriginLocalizedName(void *_this, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize);
+
+EVRInputError __thiscall IVRInput_004_GetOriginTrackedDeviceInfo(void *_this, VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize);
+
+EVRInputError __thiscall IVRInput_004_ShowActionOrigins(void *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle);
+
+EVRInputError __thiscall IVRInput_004_ShowBindingsForActionSet(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight);
+
+void test_capi_thunks_IVRIOBuffer_001(void);
+
+EIOBufferError __thiscall IVRIOBuffer_001_Open(void *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer);
+
+EIOBufferError __thiscall IVRIOBuffer_001_Close(void *_this, IOBufferHandle_t ulBuffer);
+
+EIOBufferError __thiscall IVRIOBuffer_001_Read(void *_this, IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead);
+
+EIOBufferError __thiscall IVRIOBuffer_001_Write(void *_this, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes);
+
+PropertyContainerHandle_t __thiscall IVRIOBuffer_001_PropertyContainer(void *_this, IOBufferHandle_t ulBuffer);
+
+void test_capi_thunks_IVRClientCore_003(void);
+
+EVRInitError __thiscall IVRClientCore_003_Init(void *_this, EVRApplicationType eApplicationType, const char * pStartupInfo);
+
+void __thiscall IVRClientCore_003_Cleanup(void *_this);
+
+EVRInitError __thiscall IVRClientCore_003_IsInterfaceVersionValid(void *_this, const char * pchInterfaceVersion);
+
+void * __thiscall IVRClientCore_003_GetGenericInterface(void *_this, const char * pchNameAndVersion, EVRInitError * peError);
+
+bool __thiscall IVRClientCore_003_BIsHmdPresent(void *_this);
+
+const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_this, EVRInitError eError);
+
+const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError);
+
+void test_capi_thunks_IVRTrackedCamera_003(void);
+
+const char * __thiscall IVRTrackedCamera_003_GetCameraErrorNameFromEnum(void *_this, EVRTrackedCameraError eCameraError);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_HasCamera(void *_this, TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetCameraFrameSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetCameraIntrinsics(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetCameraProjection(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_AcquireVideoStreamingService(void *_this, TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_ReleaseVideoStreamingService(void *_this, TrackedCameraHandle_t hTrackedCamera);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamFrameBuffer(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamTextureSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamTextureD3D11(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamTextureGL(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+
+EVRTrackedCameraError __thiscall IVRTrackedCamera_003_ReleaseVideoStreamTextureGL(void *_this, TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId);
+
 void test_capi_thunks_IVRRenderModels_005(void);
 
 EVRRenderModelError __thiscall IVRRenderModels_005_LoadRenderModel_Async(void *_this, const char * pchRenderModelName, RenderModel_t ** ppRenderModel);
@@ -555,70 +751,6 @@ uint32_t __thiscall IVRRenderModels_005_GetRenderModelOriginalPath(void *_this,
 
 const char * __thiscall IVRRenderModels_005_GetRenderModelErrorNameFromEnum(void *_this, EVRRenderModelError error);
 
-void test_capi_thunks_IVRExtendedDisplay_001(void);
-
-void __thiscall IVRExtendedDisplay_001_GetWindowBounds(void *_this, int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
-
-void __thiscall IVRExtendedDisplay_001_GetEyeOutputViewport(void *_this, EVREye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
-
-void __thiscall IVRExtendedDisplay_001_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex);
-
-void test_capi_thunks_IVRTrackedCamera_003(void);
-
-const char * __thiscall IVRTrackedCamera_003_GetCameraErrorNameFromEnum(void *_this, EVRTrackedCameraError eCameraError);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_003_HasCamera(void *_this, TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetCameraFrameSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetCameraIntrinsics(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetCameraProjection(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_003_AcquireVideoStreamingService(void *_this, TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_003_ReleaseVideoStreamingService(void *_this, TrackedCameraHandle_t hTrackedCamera);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamFrameBuffer(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamTextureSize(void *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamTextureD3D11(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_003_GetVideoStreamTextureGL(void *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
-
-EVRTrackedCameraError __thiscall IVRTrackedCamera_003_ReleaseVideoStreamTextureGL(void *_this, TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId);
-
-void test_capi_thunks_IVRScreenshots_001(void);
-
-EVRScreenshotError __thiscall IVRScreenshots_001_RequestScreenshot(void *_this, ScreenshotHandle_t * pOutScreenshotHandle, EVRScreenshotType type, const char * pchPreviewFilename, const char * pchVRFilename);
-
-EVRScreenshotError __thiscall IVRScreenshots_001_HookScreenshot(void *_this, EVRScreenshotType * pSupportedTypes, int numTypes);
-
-EVRScreenshotType __thiscall IVRScreenshots_001_GetScreenshotPropertyType(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotError * pError);
-
-uint32_t __thiscall IVRScreenshots_001_GetScreenshotPropertyFilename(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotPropertyFilenames filenameType, char * pchFilename, uint32_t cchFilename, EVRScreenshotError * pError);
-
-EVRScreenshotError __thiscall IVRScreenshots_001_UpdateScreenshotProgress(void *_this, ScreenshotHandle_t screenshotHandle, float flProgress);
-
-EVRScreenshotError __thiscall IVRScreenshots_001_TakeStereoScreenshot(void *_this, ScreenshotHandle_t * pOutScreenshotHandle, const char * pchPreviewFilename, const char * pchVRFilename);
-
-EVRScreenshotError __thiscall IVRScreenshots_001_SubmitScreenshot(void *_this, ScreenshotHandle_t screenshotHandle, EVRScreenshotType type, const char * pchSourcePreviewFilename, const char * pchSourceVRFilename);
-
-void test_capi_thunks_IVRResources_001(void);
-
-uint32_t __thiscall IVRResources_001_LoadSharedResource(void *_this, const char * pchResourceName, char * pchBuffer, uint32_t unBufferLen);
-
-uint32_t __thiscall IVRResources_001_GetResourceFullPath(void *_this, const char * pchResourceName, const char * pchResourceTypeDirectory, char * pchPathBuffer, uint32_t unBufferLen);
-
-void test_capi_thunks_IVRDriverManager_001(void);
-
-uint32_t __thiscall IVRDriverManager_001_GetDriverCount(void *_this);
-
-uint32_t __thiscall IVRDriverManager_001_GetDriverName(void *_this, DriverId_t nDriver, char * pchValue, uint32_t unBufferSize);
-
-DriverHandle_t __thiscall IVRDriverManager_001_GetDriverHandle(void *_this, const char * pchDriverName);
-
 void test_capi_thunks_IVRInput_003(void);
 
 EVRInputError __thiscall IVRInput_003_SetActionManifestPath(void *_this, const char * pchActionManifestPath);
@@ -655,34 +787,6 @@ EVRInputError __thiscall IVRInput_003_ShowActionOrigins(void *_this, VRActionSet
 
 EVRInputError __thiscall IVRInput_003_ShowBindingsForActionSet(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight);
 
-void test_capi_thunks_IVRIOBuffer_001(void);
-
-EIOBufferError __thiscall IVRIOBuffer_001_Open(void *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer);
-
-EIOBufferError __thiscall IVRIOBuffer_001_Close(void *_this, IOBufferHandle_t ulBuffer);
-
-EIOBufferError __thiscall IVRIOBuffer_001_Read(void *_this, IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead);
-
-EIOBufferError __thiscall IVRIOBuffer_001_Write(void *_this, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes);
-
-PropertyContainerHandle_t __thiscall IVRIOBuffer_001_PropertyContainer(void *_this, IOBufferHandle_t ulBuffer);
-
-void test_capi_thunks_IVRClientCore_003(void);
-
-EVRInitError __thiscall IVRClientCore_003_Init(void *_this, EVRApplicationType eApplicationType, const char * pStartupInfo);
-
-void __thiscall IVRClientCore_003_Cleanup(void *_this);
-
-EVRInitError __thiscall IVRClientCore_003_IsInterfaceVersionValid(void *_this, const char * pchInterfaceVersion);
-
-void * __thiscall IVRClientCore_003_GetGenericInterface(void *_this, const char * pchNameAndVersion, EVRInitError * peError);
-
-bool __thiscall IVRClientCore_003_BIsHmdPresent(void *_this);
-
-const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_this, EVRInitError eError);
-
-const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError);
-
 void test_capi_thunks_IVRSystem_017(void);
 
 void __thiscall IVRSystem_017_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);

vrclient_x64/tests/main_autogen.c

@@ -13,15 +13,18 @@ int main(void)
     test_capi_thunks_IVRCompositor_022();
     test_capi_thunks_IVRNotifications_002();
     test_capi_thunks_IVROverlay_018();
-    test_capi_thunks_IVRRenderModels_005();
+    test_capi_thunks_IVRRenderModels_006();
     test_capi_thunks_IVRExtendedDisplay_001();
-    test_capi_thunks_IVRTrackedCamera_003();
+    test_capi_thunks_IVRTrackedCamera_004();
     test_capi_thunks_IVRScreenshots_001();
     test_capi_thunks_IVRResources_001();
     test_capi_thunks_IVRDriverManager_001();
-    test_capi_thunks_IVRInput_003();
+    test_capi_thunks_IVRInput_004();
     test_capi_thunks_IVRIOBuffer_001();
     test_capi_thunks_IVRClientCore_003();
+    test_capi_thunks_IVRTrackedCamera_003();
+    test_capi_thunks_IVRRenderModels_005();
+    test_capi_thunks_IVRInput_003();
     test_capi_thunks_IVRSystem_017();
     test_capi_thunks_IVROverlay_017();
     test_capi_thunks_IVRCompositor_021();

vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_006.cpp

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

vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_005.cpp

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

vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_003.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.15/ivrclientcore.h"
+#include "openvr_v1.0.17/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.0.15/ivrclientcore.h"
+#include "openvr_v1.0.17/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"

vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_022.cpp

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

vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.15/ivrclientcore.h"
+#include "openvr_v1.0.17/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.0.15/ivrclientcore.h"
+#include "openvr_v1.0.17/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"

vrclient_x64/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_004.cpp

@@ -0,0 +1,104 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.0.17/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRInput_IVRInput_004.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::EVRInputError cppIVRInput_IVRInput_004_SetActionManifestPath(void *linux_side, const char * pchActionManifestPath)
+{
+    return ((IVRInput*)linux_side)->SetActionManifestPath((const char *)pchActionManifestPath);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_GetActionSetHandle(void *linux_side, const char * pchActionSetName, VRActionSetHandle_t * pHandle)
+{
+    return ((IVRInput*)linux_side)->GetActionSetHandle((const char *)pchActionSetName, (vr::VRActionSetHandle_t *)pHandle);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_GetActionHandle(void *linux_side, const char * pchActionName, VRActionHandle_t * pHandle)
+{
+    return ((IVRInput*)linux_side)->GetActionHandle((const char *)pchActionName, (vr::VRActionHandle_t *)pHandle);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_GetInputSourceHandle(void *linux_side, const char * pchInputSourcePath, VRInputValueHandle_t * pHandle)
+{
+    return ((IVRInput*)linux_side)->GetInputSourceHandle((const char *)pchInputSourcePath, (vr::VRInputValueHandle_t *)pHandle);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_UpdateActionState(void *linux_side, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount)
+{
+    return ((IVRInput*)linux_side)->UpdateActionState((vr::VRActiveActionSet_t *)pSets, (uint32_t)unSizeOfVRSelectedActionSet_t, (uint32_t)unSetCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_GetDigitalActionData(void *linux_side, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+{
+    return ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, (vr::InputDigitalActionData_t *)pActionData, (uint32_t)unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_GetAnalogActionData(void *linux_side, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+{
+    return ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, (vr::InputAnalogActionData_t *)pActionData, (uint32_t)unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+{
+    return ((IVRInput*)linux_side)->GetPoseActionData((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, (vr::InputPoseActionData_t *)pActionData, (uint32_t)unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, (vr::InputSkeletalActionData_t *)pActionData, (uint32_t)unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_GetSkeletalBoneData(void *linux_side, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount, VRInputValueHandle_t ulRestrictToDevice)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalBoneData((vr::VRActionHandle_t)action, (vr::EVRSkeletalTransformSpace)eTransformSpace, (vr::EVRSkeletalMotionRange)eMotionRange, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount, (vr::VRInputValueHandle_t)ulRestrictToDevice);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_GetSkeletalBoneDataCompressed(void *linux_side, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize, VRInputValueHandle_t ulRestrictToDevice)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalBoneDataCompressed((vr::VRActionHandle_t)action, (vr::EVRSkeletalTransformSpace)eTransformSpace, (vr::EVRSkeletalMotionRange)eMotionRange, (void *)pvCompressedData, (uint32_t)unCompressedSize, (uint32_t *)punRequiredCompressedSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_DecompressSkeletalBoneData(void *linux_side, void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace * peTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    return ((IVRInput*)linux_side)->DecompressSkeletalBoneData((void *)pvCompressedBuffer, (uint32_t)unCompressedBufferSize, (vr::EVRSkeletalTransformSpace *)peTransformSpace, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_TriggerHapticVibrationAction(void *linux_side, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice)
+{
+    return ((IVRInput*)linux_side)->TriggerHapticVibrationAction((vr::VRActionHandle_t)action, (float)fStartSecondsFromNow, (float)fDurationSeconds, (float)fFrequency, (float)fAmplitude, (vr::VRInputValueHandle_t)ulRestrictToDevice);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_GetActionOrigins(void *linux_side, VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount)
+{
+    return ((IVRInput*)linux_side)->GetActionOrigins((vr::VRActionSetHandle_t)actionSetHandle, (vr::VRActionHandle_t)digitalActionHandle, (vr::VRInputValueHandle_t *)originsOut, (uint32_t)originOutCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_GetOriginLocalizedName(void *linux_side, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize)
+{
+    return ((IVRInput*)linux_side)->GetOriginLocalizedName((vr::VRInputValueHandle_t)origin, (char *)pchNameArray, (uint32_t)unNameArraySize);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_GetOriginTrackedDeviceInfo(void *linux_side, VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize)
+{
+    return ((IVRInput*)linux_side)->GetOriginTrackedDeviceInfo((vr::VRInputValueHandle_t)origin, (vr::InputOriginInfo_t *)pOriginInfo, (uint32_t)unOriginInfoSize);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_ShowActionOrigins(void *linux_side, VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle)
+{
+    return ((IVRInput*)linux_side)->ShowActionOrigins((vr::VRActionSetHandle_t)actionSetHandle, (vr::VRActionHandle_t)ulActionHandle);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_004_ShowBindingsForActionSet(void *linux_side, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight)
+{
+    return ((IVRInput*)linux_side)->ShowBindingsForActionSet((vr::VRActiveActionSet_t *)pSets, (uint32_t)unSizeOfVRSelectedActionSet_t, (uint32_t)unSetCount, (vr::VRInputValueHandle_t)originToHighlight);
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_004.h

@@ -0,0 +1,24 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern EVRInputError cppIVRInput_IVRInput_004_SetActionManifestPath(void *, const char *);
+extern EVRInputError cppIVRInput_IVRInput_004_GetActionSetHandle(void *, const char *, VRActionSetHandle_t *);
+extern EVRInputError cppIVRInput_IVRInput_004_GetActionHandle(void *, const char *, VRActionHandle_t *);
+extern EVRInputError cppIVRInput_IVRInput_004_GetInputSourceHandle(void *, const char *, VRInputValueHandle_t *);
+extern EVRInputError cppIVRInput_IVRInput_004_UpdateActionState(void *, VRActiveActionSet_t *, uint32_t, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_004_GetDigitalActionData(void *, VRActionHandle_t, InputDigitalActionData_t *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_004_GetAnalogActionData(void *, VRActionHandle_t, InputAnalogActionData_t *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_004_GetPoseActionData(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, InputPoseActionData_t *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_004_GetSkeletalActionData(void *, VRActionHandle_t, InputSkeletalActionData_t *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_004_GetSkeletalBoneData(void *, VRActionHandle_t, EVRSkeletalTransformSpace, EVRSkeletalMotionRange, VRBoneTransform_t *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_004_GetSkeletalBoneDataCompressed(void *, VRActionHandle_t, EVRSkeletalTransformSpace, EVRSkeletalMotionRange, void *, uint32_t, uint32_t *, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_004_DecompressSkeletalBoneData(void *, void *, uint32_t, EVRSkeletalTransformSpace *, VRBoneTransform_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_004_TriggerHapticVibrationAction(void *, VRActionHandle_t, float, float, float, float, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_004_GetActionOrigins(void *, VRActionSetHandle_t, VRActionHandle_t, VRInputValueHandle_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_004_GetOriginLocalizedName(void *, VRInputValueHandle_t, char *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_004_GetOriginTrackedDeviceInfo(void *, VRInputValueHandle_t, InputOriginInfo_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_004_ShowActionOrigins(void *, VRActionSetHandle_t, VRActionHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_004_ShowBindingsForActionSet(void *, VRActiveActionSet_t *, uint32_t, uint32_t, VRInputValueHandle_t);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRNotifications_IVRNotifications_002.cpp

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

vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_018.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.15/ivrclientcore.h"
+#include "openvr_v1.0.17/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
@@ -234,12 +234,12 @@ vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetTransformForOverlayCoordinat
     return ((IVROverlay*)linux_side)->GetTransformForOverlayCoordinates((vr::VROverlayHandle_t)ulOverlayHandle, (vr::ETrackingUniverseOrigin)eTrackingOrigin, (vr::HmdVector2_t)coordinatesInOverlay, (vr::HmdMatrix34_t *)pmatTransform);
 }
 
-bool cppIVROverlay_IVROverlay_018_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1015 * pEvent, uint32_t uncbVREvent)
+bool cppIVROverlay_IVROverlay_018_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1017 * pEvent, uint32_t uncbVREvent)
 {
     VREvent_t lin;
     bool _ret;
     _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, &lin, sizeof(lin));
-    struct_VREvent_t_1015_lin_to_win(&lin, pEvent);
+    struct_VREvent_t_1017_lin_to_win(&lin, pEvent);
     return _ret;
 }
 

vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_018.h

@@ -46,7 +46,7 @@ extern EVROverlayError cppIVROverlay_IVROverlay_018_ShowOverlay(void *, VROverla
 extern EVROverlayError cppIVROverlay_IVROverlay_018_HideOverlay(void *, VROverlayHandle_t);
 extern bool cppIVROverlay_IVROverlay_018_IsOverlayVisible(void *, VROverlayHandle_t);
 extern EVROverlayError cppIVROverlay_IVROverlay_018_GetTransformForOverlayCoordinates(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdVector2_t, HmdMatrix34_t *);
-extern bool cppIVROverlay_IVROverlay_018_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1015 *, uint32_t);
+extern bool cppIVROverlay_IVROverlay_018_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1017 *, uint32_t);
 extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod *);
 extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod);
 extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);

vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp

@@ -0,0 +1,119 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.0.17/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRRenderModels_IVRRenderModels_006.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1017 ** ppRenderModel)
+{
+    RenderModel_t *lin;
+    vr::EVRRenderModelError _ret;
+    _ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, &lin);
+    if(_ret == 0)
+        *ppRenderModel = struct_RenderModel_t_1017_wrap(lin);
+    return _ret;
+}
+
+void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1017 * pRenderModel)
+{
+    ((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1017_unwrap(pRenderModel));
+}
+
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1017 ** ppTexture)
+{
+    RenderModel_TextureMap_t *lin;
+    vr::EVRRenderModelError _ret;
+    _ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, &lin);
+    if(_ret == 0)
+        *ppTexture = struct_RenderModel_TextureMap_t_1017_wrap(lin);
+    return _ret;
+}
+
+void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1017 * pTexture)
+{
+    ((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1017_unwrap(pTexture));
+}
+
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTextureD3D11_Async(void *linux_side, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D)
+{
+    return ((IVRRenderModels*)linux_side)->LoadTextureD3D11_Async((vr::TextureID_t)textureId, (void *)pD3D11Device, (void **)ppD3D11Texture2D);
+}
+
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadIntoTextureD3D11_Async(void *linux_side, TextureID_t textureId, void * pDstTexture)
+{
+    return ((IVRRenderModels*)linux_side)->LoadIntoTextureD3D11_Async((vr::TextureID_t)textureId, (void *)pDstTexture);
+}
+
+void cppIVRRenderModels_IVRRenderModels_006_FreeTextureD3D11(void *linux_side, void * pD3D11Texture2D)
+{
+    ((IVRRenderModels*)linux_side)->FreeTextureD3D11((void *)pD3D11Texture2D);
+}
+
+uint32_t cppIVRRenderModels_IVRRenderModels_006_GetRenderModelName(void *linux_side, uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen)
+{
+    return ((IVRRenderModels*)linux_side)->GetRenderModelName((uint32_t)unRenderModelIndex, (char *)pchRenderModelName, (uint32_t)unRenderModelNameLen);
+}
+
+uint32_t cppIVRRenderModels_IVRRenderModels_006_GetRenderModelCount(void *linux_side)
+{
+    return ((IVRRenderModels*)linux_side)->GetRenderModelCount();
+}
+
+uint32_t cppIVRRenderModels_IVRRenderModels_006_GetComponentCount(void *linux_side, const char * pchRenderModelName)
+{
+    return ((IVRRenderModels*)linux_side)->GetComponentCount((const char *)pchRenderModelName);
+}
+
+uint32_t cppIVRRenderModels_IVRRenderModels_006_GetComponentName(void *linux_side, const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen)
+{
+    return ((IVRRenderModels*)linux_side)->GetComponentName((const char *)pchRenderModelName, (uint32_t)unComponentIndex, (char *)pchComponentName, (uint32_t)unComponentNameLen);
+}
+
+uint64_t cppIVRRenderModels_IVRRenderModels_006_GetComponentButtonMask(void *linux_side, const char * pchRenderModelName, const char * pchComponentName)
+{
+    return ((IVRRenderModels*)linux_side)->GetComponentButtonMask((const char *)pchRenderModelName, (const char *)pchComponentName);
+}
+
+uint32_t cppIVRRenderModels_IVRRenderModels_006_GetComponentRenderModelName(void *linux_side, const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen)
+{
+    return ((IVRRenderModels*)linux_side)->GetComponentRenderModelName((const char *)pchRenderModelName, (const char *)pchComponentName, (char *)pchComponentRenderModelName, (uint32_t)unComponentRenderModelNameLen);
+}
+
+bool cppIVRRenderModels_IVRRenderModels_006_GetComponentStateForDevicePath(void *linux_side, const char * pchRenderModelName, const char * pchComponentName, VRInputValueHandle_t devicePath, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState)
+{
+    return ((IVRRenderModels*)linux_side)->GetComponentStateForDevicePath((const char *)pchRenderModelName, (const char *)pchComponentName, (vr::VRInputValueHandle_t)devicePath, (const vr::RenderModel_ControllerMode_State_t *)pState, (vr::RenderModel_ComponentState_t *)pComponentState);
+}
+
+bool cppIVRRenderModels_IVRRenderModels_006_GetComponentState(void *linux_side, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState)
+{
+    return ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, (const vr::VRControllerState_t *)pControllerState, (const vr::RenderModel_ControllerMode_State_t *)pState, (vr::RenderModel_ComponentState_t *)pComponentState);
+}
+
+bool cppIVRRenderModels_IVRRenderModels_006_RenderModelHasComponent(void *linux_side, const char * pchRenderModelName, const char * pchComponentName)
+{
+    return ((IVRRenderModels*)linux_side)->RenderModelHasComponent((const char *)pchRenderModelName, (const char *)pchComponentName);
+}
+
+uint32_t cppIVRRenderModels_IVRRenderModels_006_GetRenderModelThumbnailURL(void *linux_side, const char * pchRenderModelName, char * pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError * peError)
+{
+    return ((IVRRenderModels*)linux_side)->GetRenderModelThumbnailURL((const char *)pchRenderModelName, (char *)pchThumbnailURL, (uint32_t)unThumbnailURLLen, (vr::EVRRenderModelError *)peError);
+}
+
+uint32_t cppIVRRenderModels_IVRRenderModels_006_GetRenderModelOriginalPath(void *linux_side, const char * pchRenderModelName, char * pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError * peError)
+{
+    return ((IVRRenderModels*)linux_side)->GetRenderModelOriginalPath((const char *)pchRenderModelName, (char *)pchOriginalPath, (uint32_t)unOriginalPathLen, (vr::EVRRenderModelError *)peError);
+}
+
+const char * cppIVRRenderModels_IVRRenderModels_006_GetRenderModelErrorNameFromEnum(void *linux_side, EVRRenderModelError error)
+{
+    return ((IVRRenderModels*)linux_side)->GetRenderModelErrorNameFromEnum((vr::EVRRenderModelError)error);
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.h

@@ -0,0 +1,25 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1017 **);
+extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_1017 *);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1017 **);
+extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_1017 *);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTextureD3D11_Async(void *, TextureID_t, void *, void **);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadIntoTextureD3D11_Async(void *, TextureID_t, void *);
+extern void cppIVRRenderModels_IVRRenderModels_006_FreeTextureD3D11(void *, void *);
+extern uint32_t cppIVRRenderModels_IVRRenderModels_006_GetRenderModelName(void *, uint32_t, char *, uint32_t);
+extern uint32_t cppIVRRenderModels_IVRRenderModels_006_GetRenderModelCount(void *);
+extern uint32_t cppIVRRenderModels_IVRRenderModels_006_GetComponentCount(void *, const char *);
+extern uint32_t cppIVRRenderModels_IVRRenderModels_006_GetComponentName(void *, const char *, uint32_t, char *, uint32_t);
+extern uint64_t cppIVRRenderModels_IVRRenderModels_006_GetComponentButtonMask(void *, const char *, const char *);
+extern uint32_t cppIVRRenderModels_IVRRenderModels_006_GetComponentRenderModelName(void *, const char *, const char *, char *, uint32_t);
+extern bool cppIVRRenderModels_IVRRenderModels_006_GetComponentStateForDevicePath(void *, const char *, const char *, VRInputValueHandle_t, RenderModel_ControllerMode_State_t *, RenderModel_ComponentState_t *);
+extern bool cppIVRRenderModels_IVRRenderModels_006_GetComponentState(void *, const char *, const char *, VRControllerState_t *, RenderModel_ControllerMode_State_t *, RenderModel_ComponentState_t *);
+extern bool cppIVRRenderModels_IVRRenderModels_006_RenderModelHasComponent(void *, const char *, const char *);
+extern uint32_t cppIVRRenderModels_IVRRenderModels_006_GetRenderModelThumbnailURL(void *, const char *, char *, uint32_t, EVRRenderModelError *);
+extern uint32_t cppIVRRenderModels_IVRRenderModels_006_GetRenderModelOriginalPath(void *, const char *, char *, uint32_t, EVRRenderModelError *);
+extern const char * cppIVRRenderModels_IVRRenderModels_006_GetRenderModelErrorNameFromEnum(void *, EVRRenderModelError);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRResources_IVRResources_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRScreenshots_IVRScreenshots_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRSettings_IVRSettings_002.cpp

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

vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_019.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.15/ivrclientcore.h"
+#include "openvr_v1.0.17/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
@@ -159,21 +159,21 @@ const char * cppIVRSystem_IVRSystem_019_GetPropErrorNameFromEnum(void *linux_sid
     return ((IVRSystem*)linux_side)->GetPropErrorNameFromEnum((vr::ETrackedPropertyError)error);
 }
 
-bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *linux_side, winVREvent_t_1015 * pEvent, uint32_t uncbVREvent)
+bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *linux_side, winVREvent_t_1017 * pEvent, uint32_t uncbVREvent)
 {
     VREvent_t lin;
     bool _ret;
     _ret = ((IVRSystem*)linux_side)->PollNextEvent(&lin, sizeof(lin));
-    struct_VREvent_t_1015_lin_to_win(&lin, pEvent);
+    struct_VREvent_t_1017_lin_to_win(&lin, pEvent);
     return _ret;
 }
 
-bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1015 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1017 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
 {
     VREvent_t lin;
     bool _ret;
     _ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, &lin, sizeof(lin), (vr::TrackedDevicePose_t *)pTrackedDevicePose);
-    struct_VREvent_t_1015_lin_to_win(&lin, pEvent);
+    struct_VREvent_t_1017_lin_to_win(&lin, pEvent);
     return _ret;
 }
 
@@ -187,21 +187,21 @@ vr::HiddenAreaMesh_t cppIVRSystem_IVRSystem_019_GetHiddenAreaMesh(void *linux_si
     return ((IVRSystem*)linux_side)->GetHiddenAreaMesh((vr::EVREye)eEye, (vr::EHiddenAreaMeshType)type);
 }
 
-bool cppIVRSystem_IVRSystem_019_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1015 * pControllerState, uint32_t unControllerStateSize)
+bool cppIVRSystem_IVRSystem_019_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1017 * pControllerState, uint32_t unControllerStateSize)
 {
     VRControllerState001_t lin;
     bool _ret;
     _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, &lin, sizeof(lin));
-    struct_VRControllerState001_t_1015_lin_to_win(&lin, pControllerState);
+    struct_VRControllerState001_t_1017_lin_to_win(&lin, pControllerState);
     return _ret;
 }
 
-bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1015 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1017 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
 {
     VRControllerState001_t lin;
     bool _ret;
     _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, &lin, sizeof(lin), (vr::TrackedDevicePose_t *)pTrackedDevicePose);
-    struct_VRControllerState001_t_1015_lin_to_win(&lin, pControllerState);
+    struct_VRControllerState001_t_1017_lin_to_win(&lin, pControllerState);
     return _ret;
 }
 

vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_019.h

@@ -31,12 +31,12 @@ extern HmdMatrix34_t cppIVRSystem_IVRSystem_019_GetMatrix34TrackedDeviceProperty
 extern uint32_t cppIVRSystem_IVRSystem_019_GetArrayTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, PropertyTypeTag_t, void *, uint32_t, ETrackedPropertyError *);
 extern uint32_t cppIVRSystem_IVRSystem_019_GetStringTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, char *, uint32_t, ETrackedPropertyError *);
 extern const char * cppIVRSystem_IVRSystem_019_GetPropErrorNameFromEnum(void *, ETrackedPropertyError);
-extern bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *, winVREvent_t_1015 *, uint32_t);
+extern bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *, winVREvent_t_1017 *, uint32_t);
-extern bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1015 *, uint32_t, TrackedDevicePose_t *);
+extern bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1017 *, uint32_t, TrackedDevicePose_t *);
 extern const char * cppIVRSystem_IVRSystem_019_GetEventTypeNameFromEnum(void *, EVREventType);
 extern HiddenAreaMesh_t cppIVRSystem_IVRSystem_019_GetHiddenAreaMesh(void *, EVREye, EHiddenAreaMeshType);
-extern bool cppIVRSystem_IVRSystem_019_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1015 *, uint32_t);
+extern bool cppIVRSystem_IVRSystem_019_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1017 *, uint32_t);
-extern bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1015 *, uint32_t, TrackedDevicePose_t *);
+extern bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1017 *, uint32_t, TrackedDevicePose_t *);
 extern void cppIVRSystem_IVRSystem_019_TriggerHapticPulse(void *, TrackedDeviceIndex_t, uint32_t, unsigned short);
 extern const char * cppIVRSystem_IVRSystem_019_GetButtonIdNameFromEnum(void *, EVRButtonId);
 extern const char * cppIVRSystem_IVRSystem_019_GetControllerAxisTypeNameFromEnum(void *, EVRControllerAxisType);

vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_003.cpp

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

vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_004.cpp

@@ -0,0 +1,74 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.0.17/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRTrackedCamera_IVRTrackedCamera_004.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+const char * cppIVRTrackedCamera_IVRTrackedCamera_004_GetCameraErrorNameFromEnum(void *linux_side, EVRTrackedCameraError eCameraError)
+{
+    return ((IVRTrackedCamera*)linux_side)->GetCameraErrorNameFromEnum((vr::EVRTrackedCameraError)eCameraError);
+}
+
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_HasCamera(void *linux_side, TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera)
+{
+    return ((IVRTrackedCamera*)linux_side)->HasCamera((vr::TrackedDeviceIndex_t)nDeviceIndex, (bool *)pHasCamera);
+}
+
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetCameraFrameSize(void *linux_side, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize)
+{
+    return ((IVRTrackedCamera*)linux_side)->GetCameraFrameSize((vr::TrackedDeviceIndex_t)nDeviceIndex, (vr::EVRTrackedCameraFrameType)eFrameType, (uint32_t *)pnWidth, (uint32_t *)pnHeight, (uint32_t *)pnFrameBufferSize);
+}
+
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetCameraIntrinsics(void *linux_side, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter)
+{
+    return ((IVRTrackedCamera*)linux_side)->GetCameraIntrinsics((vr::TrackedDeviceIndex_t)nDeviceIndex, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::HmdVector2_t *)pFocalLength, (vr::HmdVector2_t *)pCenter);
+}
+
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetCameraProjection(void *linux_side, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection)
+{
+    return ((IVRTrackedCamera*)linux_side)->GetCameraProjection((vr::TrackedDeviceIndex_t)nDeviceIndex, (vr::EVRTrackedCameraFrameType)eFrameType, (float)flZNear, (float)flZFar, (vr::HmdMatrix44_t *)pProjection);
+}
+
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_AcquireVideoStreamingService(void *linux_side, TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle)
+{
+    return ((IVRTrackedCamera*)linux_side)->AcquireVideoStreamingService((vr::TrackedDeviceIndex_t)nDeviceIndex, (vr::TrackedCameraHandle_t *)pHandle);
+}
+
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamingService(void *linux_side, TrackedCameraHandle_t hTrackedCamera)
+{
+    return ((IVRTrackedCamera*)linux_side)->ReleaseVideoStreamingService((vr::TrackedCameraHandle_t)hTrackedCamera);
+}
+
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+{
+    return ((IVRTrackedCamera*)linux_side)->GetVideoStreamFrameBuffer((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pFrameBuffer, (uint32_t)nFrameBufferSize, (vr::CameraVideoStreamFrameHeader_t *)pFrameHeader, (uint32_t)nFrameHeaderSize);
+}
+
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureSize(void *linux_side, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    return ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureSize((vr::TrackedDeviceIndex_t)nDeviceIndex, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::VRTextureBounds_t *)pTextureBounds, (uint32_t *)pnWidth, (uint32_t *)pnHeight);
+}
+
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+{
+    return ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureD3D11((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView, (vr::CameraVideoStreamFrameHeader_t *)pFrameHeader, (uint32_t)nFrameHeaderSize);
+}
+
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+{
+    return ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureGL((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::glUInt_t *)pglTextureId, (vr::CameraVideoStreamFrameHeader_t *)pFrameHeader, (uint32_t)nFrameHeaderSize);
+}
+
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId)
+{
+    return ((IVRTrackedCamera*)linux_side)->ReleaseVideoStreamTextureGL((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::glUInt_t)glTextureId);
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_004.h

@@ -0,0 +1,18 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern const char * cppIVRTrackedCamera_IVRTrackedCamera_004_GetCameraErrorNameFromEnum(void *, EVRTrackedCameraError);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_HasCamera(void *, TrackedDeviceIndex_t, bool *);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetCameraFrameSize(void *, TrackedDeviceIndex_t, EVRTrackedCameraFrameType, uint32_t *, uint32_t *, uint32_t *);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetCameraIntrinsics(void *, TrackedDeviceIndex_t, EVRTrackedCameraFrameType, HmdVector2_t *, HmdVector2_t *);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetCameraProjection(void *, TrackedDeviceIndex_t, EVRTrackedCameraFrameType, float, float, HmdMatrix44_t *);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_AcquireVideoStreamingService(void *, TrackedDeviceIndex_t, TrackedCameraHandle_t *);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamingService(void *, TrackedCameraHandle_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, uint32_t, CameraVideoStreamFrameHeader_t *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureSize(void *, TrackedDeviceIndex_t, EVRTrackedCameraFrameType, VRTextureBounds_t *, uint32_t *, uint32_t *);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, void **, CameraVideoStreamFrameHeader_t *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, CameraVideoStreamFrameHeader_t *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamTextureGL(void *, TrackedCameraHandle_t, glUInt_t);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/struct_converters.h

@@ -1,3 +1,23 @@
+typedef struct winVREvent_t_1017 winVREvent_t_1017;
+extern void struct_VREvent_t_1017_lin_to_win(void *l, void *w);
+typedef struct winVRControllerState001_t_1017 winVRControllerState001_t_1017;
+extern void struct_VRControllerState001_t_1017_lin_to_win(void *l, void *w);
+typedef struct winRenderModel_TextureMap_t_1017 winRenderModel_TextureMap_t_1017;
+extern struct winRenderModel_TextureMap_t_1017 *struct_RenderModel_TextureMap_t_1017_wrap(void *l);
+extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1017_unwrap(winRenderModel_TextureMap_t_1017 *w);
+typedef struct winRenderModel_t_1017 winRenderModel_t_1017;
+extern struct winRenderModel_t_1017 *struct_RenderModel_t_1017_wrap(void *l);
+extern RenderModel_t *struct_RenderModel_t_1017_unwrap(winRenderModel_t_1017 *w);
+typedef struct winVREvent_t_1016 winVREvent_t_1016;
+extern void struct_VREvent_t_1016_lin_to_win(void *l, void *w);
+typedef struct winVRControllerState001_t_1016 winVRControllerState001_t_1016;
+extern void struct_VRControllerState001_t_1016_lin_to_win(void *l, void *w);
+typedef struct winRenderModel_TextureMap_t_1016 winRenderModel_TextureMap_t_1016;
+extern struct winRenderModel_TextureMap_t_1016 *struct_RenderModel_TextureMap_t_1016_wrap(void *l);
+extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1016_unwrap(winRenderModel_TextureMap_t_1016 *w);
+typedef struct winRenderModel_t_1016 winRenderModel_t_1016;
+extern struct winRenderModel_t_1016 *struct_RenderModel_t_1016_wrap(void *l);
+extern RenderModel_t *struct_RenderModel_t_1016_unwrap(winRenderModel_t_1016 *w);
 typedef struct winVREvent_t_1015 winVREvent_t_1015;
 extern void struct_VREvent_t_1015_lin_to_win(void *l, void *w);
 typedef struct winVRControllerState001_t_1015 winVRControllerState001_t_1015;

vrclient_x64/vrclient_x64/struct_converters_1016.cpp

@@ -0,0 +1,100 @@
+#include <stdlib.h>
+#include <string.h>
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.0.16/openvr.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+struct winVREvent_t_1016 {
+    uint32_t eventType;
+    vr::TrackedDeviceIndex_t trackedDeviceIndex;
+    float eventAgeSeconds;
+    vr::VREvent_Data_t data;
+}  __attribute__ ((ms_struct));
+
+void struct_VREvent_t_1016_lin_to_win(void *l, void *w)
+{
+    struct winVREvent_t_1016 *win = (struct winVREvent_t_1016 *)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_1016 {
+    uint32_t unPacketNum;
+    uint64_t ulButtonPressed;
+    uint64_t ulButtonTouched;
+    vr::VRControllerAxis_t rAxis[5];
+}  __attribute__ ((ms_struct));
+
+void struct_VRControllerState001_t_1016_lin_to_win(void *l, void *w)
+{
+    struct winVRControllerState001_t_1016 *win = (struct winVRControllerState001_t_1016 *)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_1016 {
+    uint16_t unWidth;
+    uint16_t unHeight;
+    const uint8_t * rubTextureMapData;
+
+    RenderModel_TextureMap_t *linux_side;
+}  __attribute__ ((ms_struct));
+
+struct winRenderModel_TextureMap_t_1016 *struct_RenderModel_TextureMap_t_1016_wrap(void *l)
+{
+    struct winRenderModel_TextureMap_t_1016 *win = (struct winRenderModel_TextureMap_t_1016 *)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_1016_unwrap(winRenderModel_TextureMap_t_1016 *w)
+{
+    RenderModel_TextureMap_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+struct winRenderModel_t_1016 {
+    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_1016 *struct_RenderModel_t_1016_wrap(void *l)
+{
+    struct winRenderModel_t_1016 *win = (struct winRenderModel_t_1016 *)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_1016_unwrap(winRenderModel_t_1016 *w)
+{
+    RenderModel_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+
+}

vrclient_x64/vrclient_x64/struct_converters_1017.cpp

@@ -0,0 +1,100 @@
+#include <stdlib.h>
+#include <string.h>
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.0.17/openvr.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+struct winVREvent_t_1017 {
+    uint32_t eventType;
+    vr::TrackedDeviceIndex_t trackedDeviceIndex;
+    float eventAgeSeconds;
+    vr::VREvent_Data_t data;
+}  __attribute__ ((ms_struct));
+
+void struct_VREvent_t_1017_lin_to_win(void *l, void *w)
+{
+    struct winVREvent_t_1017 *win = (struct winVREvent_t_1017 *)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_1017 {
+    uint32_t unPacketNum;
+    uint64_t ulButtonPressed;
+    uint64_t ulButtonTouched;
+    vr::VRControllerAxis_t rAxis[5];
+}  __attribute__ ((ms_struct));
+
+void struct_VRControllerState001_t_1017_lin_to_win(void *l, void *w)
+{
+    struct winVRControllerState001_t_1017 *win = (struct winVRControllerState001_t_1017 *)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_1017 {
+    uint16_t unWidth;
+    uint16_t unHeight;
+    const uint8_t * rubTextureMapData;
+
+    RenderModel_TextureMap_t *linux_side;
+}  __attribute__ ((ms_struct));
+
+struct winRenderModel_TextureMap_t_1017 *struct_RenderModel_TextureMap_t_1017_wrap(void *l)
+{
+    struct winRenderModel_TextureMap_t_1017 *win = (struct winRenderModel_TextureMap_t_1017 *)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_1017_unwrap(winRenderModel_TextureMap_t_1017 *w)
+{
+    RenderModel_TextureMap_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+struct winRenderModel_t_1017 {
+    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_1017 *struct_RenderModel_t_1017_wrap(void *l)
+{
+    struct winRenderModel_t_1017 *win = (struct winRenderModel_t_1017 *)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_1017_unwrap(winRenderModel_t_1017 *w)
+{
+    RenderModel_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+
+}

vrclient_x64/vrclient_x64/vrclient_defs.h

@@ -61,7 +61,8 @@ typedef int
         EVRInputError,
         EIOBufferError,
         EVRSkeletalTransformSpace,
-        EIOBufferMode;
+        EIOBufferMode,
+        EVRSkeletalMotionRange;
 
 typedef uint32_t DriverId_t;
 typedef uint32_t TrackedDeviceIndex_t;
@@ -115,6 +116,7 @@ typedef struct InputAnalogActionData_t InputAnalogActionData_t;
 typedef struct VRActiveActionSet_t VRActiveActionSet_t;
 typedef struct VRBoneTransform_t VRBoneTransform_t;
 typedef struct InputOriginInfo_t InputOriginInfo_t;
+typedef struct InputSkeletalActionData_t InputSkeletalActionData_t;
 
 /* dereferenced structs */
 typedef struct HmdMatrix34_t

vrclient_x64/vrclient_x64/vrclient_main.c

@@ -1007,7 +1007,14 @@ EVRRenderModelError ivrrendermodels_load_into_texture_d3d11_async(
     EVRRenderModelError error;
     ID3D11Texture2D *texture;
 
+    switch(version){
+    case 5:
         error = cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(linux_side, texture_id, &texture_map);
+        break;
+    case 6:
+        error = cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(linux_side, texture_id, &texture_map);
+        break;
+    }
     if (error == VRRenderModelError_Loading)
     {
         TRACE("Loading.\n");

vrclient_x64/vrclient_x64/winIVRInput.c

@@ -18,6 +18,225 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
 
+#include "cppIVRInput_IVRInput_004.h"
+
+typedef struct __winIVRInput_IVRInput_004 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVRInput_IVRInput_004;
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_SetActionManifestPath, 12)
+EVRInputError __thiscall winIVRInput_IVRInput_004_SetActionManifestPath(winIVRInput_IVRInput_004 *_this, const char * pchActionManifestPath)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_SetActionManifestPath(_this->linux_side, pchActionManifestPath);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetActionSetHandle, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetActionSetHandle(winIVRInput_IVRInput_004 *_this, const char * pchActionSetName, VRActionSetHandle_t * pHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_GetActionSetHandle(_this->linux_side, pchActionSetName, pHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetActionHandle, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetActionHandle(winIVRInput_IVRInput_004 *_this, const char * pchActionName, VRActionHandle_t * pHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_GetActionHandle(_this->linux_side, pchActionName, pHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetInputSourceHandle, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetInputSourceHandle(winIVRInput_IVRInput_004 *_this, const char * pchInputSourcePath, VRInputValueHandle_t * pHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_GetInputSourceHandle(_this->linux_side, pchInputSourcePath, pHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_UpdateActionState, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_004_UpdateActionState(winIVRInput_IVRInput_004 *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_UpdateActionState(_this->linux_side, pSets, unSizeOfVRSelectedActionSet_t, unSetCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetDigitalActionData, 32)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetDigitalActionData(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_GetDigitalActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetAnalogActionData, 32)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetAnalogActionData(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_GetAnalogActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetPoseActionData, 40)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetPoseActionData(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_GetPoseActionData(_this->linux_side, action, eOrigin, fPredictedSecondsFromNow, pActionData, unActionDataSize, ulRestrictToDevice);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetSkeletalActionData, 32)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetSkeletalActionData(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_GetSkeletalActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetSkeletalBoneData, 40)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetSkeletalBoneData(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount, VRInputValueHandle_t ulRestrictToDevice)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_GetSkeletalBoneData(_this->linux_side, action, eTransformSpace, eMotionRange, pTransformArray, unTransformArrayCount, ulRestrictToDevice);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetSkeletalBoneDataCompressed, 48)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetSkeletalBoneDataCompressed(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize, VRInputValueHandle_t ulRestrictToDevice)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_GetSkeletalBoneDataCompressed(_this->linux_side, action, eTransformSpace, eMotionRange, pvCompressedData, unCompressedSize, punRequiredCompressedSize, ulRestrictToDevice);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_DecompressSkeletalBoneData, 36)
+EVRInputError __thiscall winIVRInput_IVRInput_004_DecompressSkeletalBoneData(winIVRInput_IVRInput_004 *_this, void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace * peTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_DecompressSkeletalBoneData(_this->linux_side, pvCompressedBuffer, unCompressedBufferSize, peTransformSpace, pTransformArray, unTransformArrayCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_TriggerHapticVibrationAction, 36)
+EVRInputError __thiscall winIVRInput_IVRInput_004_TriggerHapticVibrationAction(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_TriggerHapticVibrationAction(_this->linux_side, action, fStartSecondsFromNow, fDurationSeconds, fFrequency, fAmplitude, ulRestrictToDevice);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetActionOrigins, 32)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetActionOrigins(winIVRInput_IVRInput_004 *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_GetActionOrigins(_this->linux_side, actionSetHandle, digitalActionHandle, originsOut, originOutCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetOriginLocalizedName, 24)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetOriginLocalizedName(winIVRInput_IVRInput_004 *_this, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_GetOriginLocalizedName(_this->linux_side, origin, pchNameArray, unNameArraySize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetOriginTrackedDeviceInfo, 24)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetOriginTrackedDeviceInfo(winIVRInput_IVRInput_004 *_this, VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_GetOriginTrackedDeviceInfo(_this->linux_side, origin, pOriginInfo, unOriginInfoSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_ShowActionOrigins, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_004_ShowActionOrigins(winIVRInput_IVRInput_004 *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_ShowActionOrigins(_this->linux_side, actionSetHandle, ulActionHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_ShowBindingsForActionSet, 28)
+EVRInputError __thiscall winIVRInput_IVRInput_004_ShowBindingsForActionSet(winIVRInput_IVRInput_004 *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_004_ShowBindingsForActionSet(_this->linux_side, pSets, unSizeOfVRSelectedActionSet_t, unSetCount, originToHighlight);
+}
+
+extern vtable_ptr winIVRInput_IVRInput_004_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRInput_IVRInput_004,
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_SetActionManifestPath)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_GetActionSetHandle)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_GetActionHandle)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_GetInputSourceHandle)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_UpdateActionState)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_GetDigitalActionData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_GetAnalogActionData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_GetPoseActionData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_GetSkeletalActionData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_GetSkeletalBoneData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_GetSkeletalBoneDataCompressed)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_DecompressSkeletalBoneData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_TriggerHapticVibrationAction)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_GetActionOrigins)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_GetOriginLocalizedName)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_GetOriginTrackedDeviceInfo)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_ShowActionOrigins)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_004_ShowBindingsForActionSet)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRInput_IVRInput_004 *create_winIVRInput_IVRInput_004(void *linux_side)
+{
+    winIVRInput_IVRInput_004 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRInput_IVRInput_004));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRInput_IVRInput_004_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRInput_IVRInput_004(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRInput_IVRInput_004 *create_winIVRInput_IVRInput_004_FnTable(void *linux_side)
+{
+    winIVRInput_IVRInput_004 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRInput_IVRInput_004));
+    struct thunk *thunks = alloc_thunks(18);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 18 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVRInput_IVRInput_004_SetActionManifestPath, 1, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVRInput_IVRInput_004_GetActionSetHandle, 2, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVRInput_IVRInput_004_GetActionHandle, 2, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVRInput_IVRInput_004_GetInputSourceHandle, 2, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVRInput_IVRInput_004_UpdateActionState, 3, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVRInput_IVRInput_004_GetDigitalActionData, 4, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVRInput_IVRInput_004_GetAnalogActionData, 4, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVRInput_IVRInput_004_GetPoseActionData, 6, TRUE, FALSE);
+    init_thunk(&thunks[8], r, winIVRInput_IVRInput_004_GetSkeletalActionData, 4, FALSE, FALSE);
+    init_thunk(&thunks[9], r, winIVRInput_IVRInput_004_GetSkeletalBoneData, 6, FALSE, FALSE);
+    init_thunk(&thunks[10], r, winIVRInput_IVRInput_004_GetSkeletalBoneDataCompressed, 7, FALSE, FALSE);
+    init_thunk(&thunks[11], r, winIVRInput_IVRInput_004_DecompressSkeletalBoneData, 5, FALSE, FALSE);
+    init_thunk(&thunks[12], r, winIVRInput_IVRInput_004_TriggerHapticVibrationAction, 6, TRUE, TRUE);
+    init_thunk(&thunks[13], r, winIVRInput_IVRInput_004_GetActionOrigins, 4, FALSE, FALSE);
+    init_thunk(&thunks[14], r, winIVRInput_IVRInput_004_GetOriginLocalizedName, 3, FALSE, FALSE);
+    init_thunk(&thunks[15], r, winIVRInput_IVRInput_004_GetOriginTrackedDeviceInfo, 3, FALSE, FALSE);
+    init_thunk(&thunks[16], r, winIVRInput_IVRInput_004_ShowActionOrigins, 2, FALSE, FALSE);
+    init_thunk(&thunks[17], r, winIVRInput_IVRInput_004_ShowBindingsForActionSet, 4, FALSE, FALSE);
+    for (i = 0; i < 18; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVRInput_IVRInput_004_FnTable(void *object)
+{
+    winIVRInput_IVRInput_004 *win_object = object;
+    TRACE("%p\n", win_object);
+    VirtualFree(win_object->vtable[0], 0, MEM_RELEASE);
+    HeapFree(GetProcessHeap(), 0, win_object->vtable);
+    HeapFree(GetProcessHeap(), 0, win_object);
+}
+
 #include "cppIVRInput_IVRInput_003.h"
 
 typedef struct __winIVRInput_IVRInput_003 {

vrclient_x64/vrclient_x64/winIVROverlay.c

@@ -341,7 +341,7 @@ EVROverlayError __thiscall winIVROverlay_IVROverlay_018_GetTransformForOverlayCo
 }
 
 DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_018_PollNextOverlayEvent, 24)
-bool __thiscall winIVROverlay_IVROverlay_018_PollNextOverlayEvent(winIVROverlay_IVROverlay_018 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1015 * pEvent, uint32_t uncbVREvent)
+bool __thiscall winIVROverlay_IVROverlay_018_PollNextOverlayEvent(winIVROverlay_IVROverlay_018 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1017 * pEvent, uint32_t uncbVREvent)
 {
     TRACE("%p\n", _this);
     return cppIVROverlay_IVROverlay_018_PollNextOverlayEvent(_this->linux_side, ulOverlayHandle, pEvent, uncbVREvent);

vrclient_x64/vrclient_x64/winIVRRenderModels.c

@@ -18,6 +18,234 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
 
+#include "cppIVRRenderModels_IVRRenderModels_006.h"
+
+typedef struct __winIVRRenderModels_IVRRenderModels_006 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVRRenderModels_IVRRenderModels_006;
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async, 20)
+EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, winRenderModel_t_1017 ** ppRenderModel)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(_this->linux_side, pchRenderModelName, ppRenderModel);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_FreeRenderModel, 12)
+void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeRenderModel(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_t_1017 * pRenderModel)
+{
+    TRACE("%p\n", _this);
+    cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(_this->linux_side, pRenderModel);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async, 16)
+EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_1017 ** ppTexture)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(_this->linux_side, textureId, ppTexture);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_FreeTexture, 12)
+void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeTexture(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_TextureMap_t_1017 * pTexture)
+{
+    TRACE("%p\n", _this);
+    cppIVRRenderModels_IVRRenderModels_006_FreeTexture(_this->linux_side, pTexture);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_LoadTextureD3D11_Async, 24)
+EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTextureD3D11_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_LoadTextureD3D11_Async(_this->linux_side, textureId, pD3D11Device, ppD3D11Texture2D);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_LoadIntoTextureD3D11_Async, 16)
+EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadIntoTextureD3D11_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, void * pDstTexture)
+{
+    TRACE("%p\n", _this);
+    return ivrrendermodels_load_into_texture_d3d11_async(cppIVRRenderModels_IVRRenderModels_006_LoadIntoTextureD3D11_Async, _this->linux_side, textureId, pDstTexture, 6);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_FreeTextureD3D11, 12)
+void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeTextureD3D11(winIVRRenderModels_IVRRenderModels_006 *_this, void * pD3D11Texture2D)
+{
+    TRACE("%p\n", _this);
+    cppIVRRenderModels_IVRRenderModels_006_FreeTextureD3D11(_this->linux_side, pD3D11Texture2D);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_GetRenderModelName, 20)
+uint32_t __thiscall winIVRRenderModels_IVRRenderModels_006_GetRenderModelName(winIVRRenderModels_IVRRenderModels_006 *_this, uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_GetRenderModelName(_this->linux_side, unRenderModelIndex, pchRenderModelName, unRenderModelNameLen);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_GetRenderModelCount, 4)
+uint32_t __thiscall winIVRRenderModels_IVRRenderModels_006_GetRenderModelCount(winIVRRenderModels_IVRRenderModels_006 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_GetRenderModelCount(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_GetComponentCount, 12)
+uint32_t __thiscall winIVRRenderModels_IVRRenderModels_006_GetComponentCount(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_GetComponentCount(_this->linux_side, pchRenderModelName);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_GetComponentName, 28)
+uint32_t __thiscall winIVRRenderModels_IVRRenderModels_006_GetComponentName(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_GetComponentName(_this->linux_side, pchRenderModelName, unComponentIndex, pchComponentName, unComponentNameLen);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_GetComponentButtonMask, 20)
+uint64_t __thiscall winIVRRenderModels_IVRRenderModels_006_GetComponentButtonMask(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, const char * pchComponentName)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_GetComponentButtonMask(_this->linux_side, pchRenderModelName, pchComponentName);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_GetComponentRenderModelName, 32)
+uint32_t __thiscall winIVRRenderModels_IVRRenderModels_006_GetComponentRenderModelName(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_GetComponentRenderModelName(_this->linux_side, pchRenderModelName, pchComponentName, pchComponentRenderModelName, unComponentRenderModelNameLen);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_GetComponentStateForDevicePath, 44)
+bool __thiscall winIVRRenderModels_IVRRenderModels_006_GetComponentStateForDevicePath(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, const char * pchComponentName, VRInputValueHandle_t devicePath, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_GetComponentStateForDevicePath(_this->linux_side, pchRenderModelName, pchComponentName, devicePath, pState, pComponentState);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_GetComponentState, 44)
+bool __thiscall winIVRRenderModels_IVRRenderModels_006_GetComponentState(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_GetComponentState(_this->linux_side, pchRenderModelName, pchComponentName, pControllerState, pState, pComponentState);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_RenderModelHasComponent, 20)
+bool __thiscall winIVRRenderModels_IVRRenderModels_006_RenderModelHasComponent(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, const char * pchComponentName)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_RenderModelHasComponent(_this->linux_side, pchRenderModelName, pchComponentName);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_GetRenderModelThumbnailURL, 32)
+uint32_t __thiscall winIVRRenderModels_IVRRenderModels_006_GetRenderModelThumbnailURL(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, char * pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError * peError)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_GetRenderModelThumbnailURL(_this->linux_side, pchRenderModelName, pchThumbnailURL, unThumbnailURLLen, peError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_GetRenderModelOriginalPath, 32)
+uint32_t __thiscall winIVRRenderModels_IVRRenderModels_006_GetRenderModelOriginalPath(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, char * pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError * peError)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_GetRenderModelOriginalPath(_this->linux_side, pchRenderModelName, pchOriginalPath, unOriginalPathLen, peError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_GetRenderModelErrorNameFromEnum, 8)
+const char * __thiscall winIVRRenderModels_IVRRenderModels_006_GetRenderModelErrorNameFromEnum(winIVRRenderModels_IVRRenderModels_006 *_this, EVRRenderModelError error)
+{
+    TRACE("%p\n", _this);
+    return cppIVRRenderModels_IVRRenderModels_006_GetRenderModelErrorNameFromEnum(_this->linux_side, error);
+}
+
+extern vtable_ptr winIVRRenderModels_IVRRenderModels_006_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRRenderModels_IVRRenderModels_006,
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_FreeRenderModel)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_FreeTexture)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_LoadTextureD3D11_Async)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_LoadIntoTextureD3D11_Async)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_FreeTextureD3D11)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_GetRenderModelName)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_GetRenderModelCount)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_GetComponentCount)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_GetComponentName)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_GetComponentButtonMask)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_GetComponentRenderModelName)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_GetComponentStateForDevicePath)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_GetComponentState)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_RenderModelHasComponent)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_GetRenderModelThumbnailURL)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_GetRenderModelOriginalPath)
+        VTABLE_ADD_FUNC(winIVRRenderModels_IVRRenderModels_006_GetRenderModelErrorNameFromEnum)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRRenderModels_IVRRenderModels_006 *create_winIVRRenderModels_IVRRenderModels_006(void *linux_side)
+{
+    winIVRRenderModels_IVRRenderModels_006 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRRenderModels_IVRRenderModels_006));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRRenderModels_IVRRenderModels_006_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRRenderModels_IVRRenderModels_006(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRRenderModels_IVRRenderModels_006 *create_winIVRRenderModels_IVRRenderModels_006_FnTable(void *linux_side)
+{
+    winIVRRenderModels_IVRRenderModels_006 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRRenderModels_IVRRenderModels_006));
+    struct thunk *thunks = alloc_thunks(19);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 19 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async, 2, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVRRenderModels_IVRRenderModels_006_FreeRenderModel, 1, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async, 2, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVRRenderModels_IVRRenderModels_006_FreeTexture, 1, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVRRenderModels_IVRRenderModels_006_LoadTextureD3D11_Async, 3, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVRRenderModels_IVRRenderModels_006_LoadIntoTextureD3D11_Async, 2, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVRRenderModels_IVRRenderModels_006_FreeTextureD3D11, 1, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVRRenderModels_IVRRenderModels_006_GetRenderModelName, 3, FALSE, FALSE);
+    init_thunk(&thunks[8], r, winIVRRenderModels_IVRRenderModels_006_GetRenderModelCount, 0, FALSE, FALSE);
+    init_thunk(&thunks[9], r, winIVRRenderModels_IVRRenderModels_006_GetComponentCount, 1, FALSE, FALSE);
+    init_thunk(&thunks[10], r, winIVRRenderModels_IVRRenderModels_006_GetComponentName, 4, FALSE, FALSE);
+    init_thunk(&thunks[11], r, winIVRRenderModels_IVRRenderModels_006_GetComponentButtonMask, 2, FALSE, FALSE);
+    init_thunk(&thunks[12], r, winIVRRenderModels_IVRRenderModels_006_GetComponentRenderModelName, 4, FALSE, FALSE);
+    init_thunk(&thunks[13], r, winIVRRenderModels_IVRRenderModels_006_GetComponentStateForDevicePath, 5, FALSE, FALSE);
+    init_thunk(&thunks[14], r, winIVRRenderModels_IVRRenderModels_006_GetComponentState, 5, FALSE, FALSE);
+    init_thunk(&thunks[15], r, winIVRRenderModels_IVRRenderModels_006_RenderModelHasComponent, 2, FALSE, FALSE);
+    init_thunk(&thunks[16], r, winIVRRenderModels_IVRRenderModels_006_GetRenderModelThumbnailURL, 4, FALSE, FALSE);
+    init_thunk(&thunks[17], r, winIVRRenderModels_IVRRenderModels_006_GetRenderModelOriginalPath, 4, FALSE, FALSE);
+    init_thunk(&thunks[18], r, winIVRRenderModels_IVRRenderModels_006_GetRenderModelErrorNameFromEnum, 1, FALSE, FALSE);
+    for (i = 0; i < 19; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVRRenderModels_IVRRenderModels_006_FnTable(void *object)
+{
+    winIVRRenderModels_IVRRenderModels_006 *win_object = object;
+    TRACE("%p\n", win_object);
+    VirtualFree(win_object->vtable[0], 0, MEM_RELEASE);
+    HeapFree(GetProcessHeap(), 0, win_object->vtable);
+    HeapFree(GetProcessHeap(), 0, win_object);
+}
+
 #include "cppIVRRenderModels_IVRRenderModels_005.h"
 
 typedef struct __winIVRRenderModels_IVRRenderModels_005 {

vrclient_x64/vrclient_x64/winIVRSystem.c

@@ -241,14 +241,14 @@ const char * __thiscall winIVRSystem_IVRSystem_019_GetPropErrorNameFromEnum(winI
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_019_PollNextEvent, 16)
-bool __thiscall winIVRSystem_IVRSystem_019_PollNextEvent(winIVRSystem_IVRSystem_019 *_this, winVREvent_t_1015 * pEvent, uint32_t uncbVREvent)
+bool __thiscall winIVRSystem_IVRSystem_019_PollNextEvent(winIVRSystem_IVRSystem_019 *_this, winVREvent_t_1017 * pEvent, uint32_t uncbVREvent)
 {
     TRACE("%p\n", _this);
     return cppIVRSystem_IVRSystem_019_PollNextEvent(_this->linux_side, pEvent, uncbVREvent);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_019_PollNextEventWithPose, 28)
-bool __thiscall winIVRSystem_IVRSystem_019_PollNextEventWithPose(winIVRSystem_IVRSystem_019 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1015 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+bool __thiscall winIVRSystem_IVRSystem_019_PollNextEventWithPose(winIVRSystem_IVRSystem_019 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1017 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
 {
     TRACE("%p\n", _this);
     return cppIVRSystem_IVRSystem_019_PollNextEventWithPose(_this->linux_side, eOrigin, pEvent, uncbVREvent, pTrackedDevicePose);
@@ -270,14 +270,14 @@ HiddenAreaMesh_t *__thiscall winIVRSystem_IVRSystem_019_GetHiddenAreaMesh(winIVR
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_019_GetControllerState, 20)
-bool __thiscall winIVRSystem_IVRSystem_019_GetControllerState(winIVRSystem_IVRSystem_019 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1015 * pControllerState, uint32_t unControllerStateSize)
+bool __thiscall winIVRSystem_IVRSystem_019_GetControllerState(winIVRSystem_IVRSystem_019 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1017 * pControllerState, uint32_t unControllerStateSize)
 {
     TRACE("%p\n", _this);
     return cppIVRSystem_IVRSystem_019_GetControllerState(_this->linux_side, unControllerDeviceIndex, pControllerState, unControllerStateSize);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_019_GetControllerStateWithPose, 32)
-bool __thiscall winIVRSystem_IVRSystem_019_GetControllerStateWithPose(winIVRSystem_IVRSystem_019 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1015 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+bool __thiscall winIVRSystem_IVRSystem_019_GetControllerStateWithPose(winIVRSystem_IVRSystem_019 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1017 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
 {
     TRACE("%p\n", _this);
     return cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(_this->linux_side, eOrigin, unControllerDeviceIndex, pControllerState, unControllerStateSize, pTrackedDevicePose);

vrclient_x64/vrclient_x64/winIVRTrackedCamera.c

@@ -18,6 +18,171 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
 
+#include "cppIVRTrackedCamera_IVRTrackedCamera_004.h"
+
+typedef struct __winIVRTrackedCamera_IVRTrackedCamera_004 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVRTrackedCamera_IVRTrackedCamera_004;
+
+DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraErrorNameFromEnum, 8)
+const char * __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraErrorNameFromEnum(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, EVRTrackedCameraError eCameraError)
+{
+    TRACE("%p\n", _this);
+    return cppIVRTrackedCamera_IVRTrackedCamera_004_GetCameraErrorNameFromEnum(_this->linux_side, eCameraError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_HasCamera, 16)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_HasCamera(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera)
+{
+    TRACE("%p\n", _this);
+    return cppIVRTrackedCamera_IVRTrackedCamera_004_HasCamera(_this->linux_side, nDeviceIndex, pHasCamera);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraFrameSize, 36)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraFrameSize(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRTrackedCamera_IVRTrackedCamera_004_GetCameraFrameSize(_this->linux_side, nDeviceIndex, eFrameType, pnWidth, pnHeight, pnFrameBufferSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraIntrinsics, 28)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraIntrinsics(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter)
+{
+    TRACE("%p\n", _this);
+    return cppIVRTrackedCamera_IVRTrackedCamera_004_GetCameraIntrinsics(_this->linux_side, nDeviceIndex, eFrameType, pFocalLength, pCenter);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraProjection, 28)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraProjection(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection)
+{
+    TRACE("%p\n", _this);
+    return cppIVRTrackedCamera_IVRTrackedCamera_004_GetCameraProjection(_this->linux_side, nDeviceIndex, eFrameType, flZNear, flZFar, pProjection);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_AcquireVideoStreamingService, 16)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_AcquireVideoStreamingService(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRTrackedCamera_IVRTrackedCamera_004_AcquireVideoStreamingService(_this->linux_side, nDeviceIndex, pHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamingService, 12)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamingService(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedCameraHandle_t hTrackedCamera)
+{
+    TRACE("%p\n", _this);
+    return cppIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamingService(_this->linux_side, hTrackedCamera);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer, 40)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(_this->linux_side, hTrackedCamera, eFrameType, pFrameBuffer, nFrameBufferSize, pFrameHeader, nFrameHeaderSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureSize, 36)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureSize(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    TRACE("%p\n", _this);
+    return cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureSize(_this->linux_side, nDeviceIndex, eFrameType, pTextureBounds, pnWidth, pnHeight);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11, 44)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(_this->linux_side, hTrackedCamera, eFrameType, pD3D11DeviceOrResource, ppD3D11ShaderResourceView, pFrameHeader, nFrameHeaderSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL, 36)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(_this->linux_side, hTrackedCamera, eFrameType, pglTextureId, pFrameHeader, nFrameHeaderSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamTextureGL, 16)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamTextureGL(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId)
+{
+    TRACE("%p\n", _this);
+    return cppIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamTextureGL(_this->linux_side, hTrackedCamera, glTextureId);
+}
+
+extern vtable_ptr winIVRTrackedCamera_IVRTrackedCamera_004_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRTrackedCamera_IVRTrackedCamera_004,
+        VTABLE_ADD_FUNC(winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraErrorNameFromEnum)
+        VTABLE_ADD_FUNC(winIVRTrackedCamera_IVRTrackedCamera_004_HasCamera)
+        VTABLE_ADD_FUNC(winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraFrameSize)
+        VTABLE_ADD_FUNC(winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraIntrinsics)
+        VTABLE_ADD_FUNC(winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraProjection)
+        VTABLE_ADD_FUNC(winIVRTrackedCamera_IVRTrackedCamera_004_AcquireVideoStreamingService)
+        VTABLE_ADD_FUNC(winIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamingService)
+        VTABLE_ADD_FUNC(winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer)
+        VTABLE_ADD_FUNC(winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureSize)
+        VTABLE_ADD_FUNC(winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11)
+        VTABLE_ADD_FUNC(winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL)
+        VTABLE_ADD_FUNC(winIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamTextureGL)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRTrackedCamera_IVRTrackedCamera_004 *create_winIVRTrackedCamera_IVRTrackedCamera_004(void *linux_side)
+{
+    winIVRTrackedCamera_IVRTrackedCamera_004 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRTrackedCamera_IVRTrackedCamera_004));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRTrackedCamera_IVRTrackedCamera_004_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRTrackedCamera_IVRTrackedCamera_004(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRTrackedCamera_IVRTrackedCamera_004 *create_winIVRTrackedCamera_IVRTrackedCamera_004_FnTable(void *linux_side)
+{
+    winIVRTrackedCamera_IVRTrackedCamera_004 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRTrackedCamera_IVRTrackedCamera_004));
+    struct thunk *thunks = alloc_thunks(12);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 12 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraErrorNameFromEnum, 1, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVRTrackedCamera_IVRTrackedCamera_004_HasCamera, 2, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraFrameSize, 5, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraIntrinsics, 4, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVRTrackedCamera_IVRTrackedCamera_004_GetCameraProjection, 5, TRUE, TRUE);
+    init_thunk(&thunks[5], r, winIVRTrackedCamera_IVRTrackedCamera_004_AcquireVideoStreamingService, 2, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamingService, 1, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer, 6, FALSE, FALSE);
+    init_thunk(&thunks[8], r, winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureSize, 5, FALSE, FALSE);
+    init_thunk(&thunks[9], r, winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11, 6, FALSE, FALSE);
+    init_thunk(&thunks[10], r, winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL, 5, FALSE, FALSE);
+    init_thunk(&thunks[11], r, winIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamTextureGL, 2, FALSE, FALSE);
+    for (i = 0; i < 12; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVRTrackedCamera_IVRTrackedCamera_004_FnTable(void *object)
+{
+    winIVRTrackedCamera_IVRTrackedCamera_004 *win_object = object;
+    TRACE("%p\n", win_object);
+    VirtualFree(win_object->vtable[0], 0, MEM_RELEASE);
+    HeapFree(GetProcessHeap(), 0, win_object->vtable);
+    HeapFree(GetProcessHeap(), 0, win_object);
+}
+
 #include "cppIVRTrackedCamera_IVRTrackedCamera_003.h"
 
 typedef struct __winIVRTrackedCamera_IVRTrackedCamera_003 {

vrclient_x64/vrclient_x64/win_constructors.h

@@ -14,24 +14,30 @@ extern void *create_winIVRNotifications_IVRNotifications_002(void *);
 extern void *create_winIVRNotifications_IVRNotifications_002_FnTable(void *);
 extern void *create_winIVROverlay_IVROverlay_018(void *);
 extern void *create_winIVROverlay_IVROverlay_018_FnTable(void *);
-extern void *create_winIVRRenderModels_IVRRenderModels_005(void *);
+extern void *create_winIVRRenderModels_IVRRenderModels_006(void *);
-extern void *create_winIVRRenderModels_IVRRenderModels_005_FnTable(void *);
+extern void *create_winIVRRenderModels_IVRRenderModels_006_FnTable(void *);
 extern void *create_winIVRExtendedDisplay_IVRExtendedDisplay_001(void *);
 extern void *create_winIVRExtendedDisplay_IVRExtendedDisplay_001_FnTable(void *);
-extern void *create_winIVRTrackedCamera_IVRTrackedCamera_003(void *);
+extern void *create_winIVRTrackedCamera_IVRTrackedCamera_004(void *);
-extern void *create_winIVRTrackedCamera_IVRTrackedCamera_003_FnTable(void *);
+extern void *create_winIVRTrackedCamera_IVRTrackedCamera_004_FnTable(void *);
 extern void *create_winIVRScreenshots_IVRScreenshots_001(void *);
 extern void *create_winIVRScreenshots_IVRScreenshots_001_FnTable(void *);
 extern void *create_winIVRResources_IVRResources_001(void *);
 extern void *create_winIVRResources_IVRResources_001_FnTable(void *);
 extern void *create_winIVRDriverManager_IVRDriverManager_001(void *);
 extern void *create_winIVRDriverManager_IVRDriverManager_001_FnTable(void *);
-extern void *create_winIVRInput_IVRInput_003(void *);
+extern void *create_winIVRInput_IVRInput_004(void *);
-extern void *create_winIVRInput_IVRInput_003_FnTable(void *);
+extern void *create_winIVRInput_IVRInput_004_FnTable(void *);
 extern void *create_winIVRIOBuffer_IVRIOBuffer_001(void *);
 extern void *create_winIVRIOBuffer_IVRIOBuffer_001_FnTable(void *);
 extern void *create_winIVRClientCore_IVRClientCore_003(void *);
 extern void *create_winIVRClientCore_IVRClientCore_003_FnTable(void *);
+extern void *create_winIVRTrackedCamera_IVRTrackedCamera_003(void *);
+extern void *create_winIVRTrackedCamera_IVRTrackedCamera_003_FnTable(void *);
+extern void *create_winIVRRenderModels_IVRRenderModels_005(void *);
+extern void *create_winIVRRenderModels_IVRRenderModels_005_FnTable(void *);
+extern void *create_winIVRInput_IVRInput_003(void *);
+extern void *create_winIVRInput_IVRInput_003_FnTable(void *);
 extern void *create_winIVRSystem_IVRSystem_017(void *);
 extern void *create_winIVRSystem_IVRSystem_017_FnTable(void *);
 extern void *create_winIVROverlay_IVROverlay_017(void *);

vrclient_x64/vrclient_x64/win_constructors_table.dat

@@ -14,24 +14,30 @@
     {"FnTable:IVRNotifications_002", &create_winIVRNotifications_IVRNotifications_002_FnTable, &destroy_winIVRNotifications_IVRNotifications_002_FnTable},
     {"IVROverlay_018", &create_winIVROverlay_IVROverlay_018, &destroy_winIVROverlay_IVROverlay_018},
     {"FnTable:IVROverlay_018", &create_winIVROverlay_IVROverlay_018_FnTable, &destroy_winIVROverlay_IVROverlay_018_FnTable},
-    {"IVRRenderModels_005", &create_winIVRRenderModels_IVRRenderModels_005, &destroy_winIVRRenderModels_IVRRenderModels_005},
+    {"IVRRenderModels_006", &create_winIVRRenderModels_IVRRenderModels_006, &destroy_winIVRRenderModels_IVRRenderModels_006},
-    {"FnTable:IVRRenderModels_005", &create_winIVRRenderModels_IVRRenderModels_005_FnTable, &destroy_winIVRRenderModels_IVRRenderModels_005_FnTable},
+    {"FnTable:IVRRenderModels_006", &create_winIVRRenderModels_IVRRenderModels_006_FnTable, &destroy_winIVRRenderModels_IVRRenderModels_006_FnTable},
     {"IVRExtendedDisplay_001", &create_winIVRExtendedDisplay_IVRExtendedDisplay_001, &destroy_winIVRExtendedDisplay_IVRExtendedDisplay_001},
     {"FnTable:IVRExtendedDisplay_001", &create_winIVRExtendedDisplay_IVRExtendedDisplay_001_FnTable, &destroy_winIVRExtendedDisplay_IVRExtendedDisplay_001_FnTable},
-    {"IVRTrackedCamera_003", &create_winIVRTrackedCamera_IVRTrackedCamera_003, &destroy_winIVRTrackedCamera_IVRTrackedCamera_003},
+    {"IVRTrackedCamera_004", &create_winIVRTrackedCamera_IVRTrackedCamera_004, &destroy_winIVRTrackedCamera_IVRTrackedCamera_004},
-    {"FnTable:IVRTrackedCamera_003", &create_winIVRTrackedCamera_IVRTrackedCamera_003_FnTable, &destroy_winIVRTrackedCamera_IVRTrackedCamera_003_FnTable},
+    {"FnTable:IVRTrackedCamera_004", &create_winIVRTrackedCamera_IVRTrackedCamera_004_FnTable, &destroy_winIVRTrackedCamera_IVRTrackedCamera_004_FnTable},
     {"IVRScreenshots_001", &create_winIVRScreenshots_IVRScreenshots_001, &destroy_winIVRScreenshots_IVRScreenshots_001},
     {"FnTable:IVRScreenshots_001", &create_winIVRScreenshots_IVRScreenshots_001_FnTable, &destroy_winIVRScreenshots_IVRScreenshots_001_FnTable},
     {"IVRResources_001", &create_winIVRResources_IVRResources_001, &destroy_winIVRResources_IVRResources_001},
     {"FnTable:IVRResources_001", &create_winIVRResources_IVRResources_001_FnTable, &destroy_winIVRResources_IVRResources_001_FnTable},
     {"IVRDriverManager_001", &create_winIVRDriverManager_IVRDriverManager_001, &destroy_winIVRDriverManager_IVRDriverManager_001},
     {"FnTable:IVRDriverManager_001", &create_winIVRDriverManager_IVRDriverManager_001_FnTable, &destroy_winIVRDriverManager_IVRDriverManager_001_FnTable},
-    {"IVRInput_003", &create_winIVRInput_IVRInput_003, &destroy_winIVRInput_IVRInput_003},
+    {"IVRInput_004", &create_winIVRInput_IVRInput_004, &destroy_winIVRInput_IVRInput_004},
-    {"FnTable:IVRInput_003", &create_winIVRInput_IVRInput_003_FnTable, &destroy_winIVRInput_IVRInput_003_FnTable},
+    {"FnTable:IVRInput_004", &create_winIVRInput_IVRInput_004_FnTable, &destroy_winIVRInput_IVRInput_004_FnTable},
     {"IVRIOBuffer_001", &create_winIVRIOBuffer_IVRIOBuffer_001, &destroy_winIVRIOBuffer_IVRIOBuffer_001},
     {"FnTable:IVRIOBuffer_001", &create_winIVRIOBuffer_IVRIOBuffer_001_FnTable, &destroy_winIVRIOBuffer_IVRIOBuffer_001_FnTable},
     {"IVRClientCore_003", &create_winIVRClientCore_IVRClientCore_003, &destroy_winIVRClientCore_IVRClientCore_003},
     {"FnTable:IVRClientCore_003", &create_winIVRClientCore_IVRClientCore_003_FnTable, &destroy_winIVRClientCore_IVRClientCore_003_FnTable},
+    {"IVRTrackedCamera_003", &create_winIVRTrackedCamera_IVRTrackedCamera_003, &destroy_winIVRTrackedCamera_IVRTrackedCamera_003},
+    {"FnTable:IVRTrackedCamera_003", &create_winIVRTrackedCamera_IVRTrackedCamera_003_FnTable, &destroy_winIVRTrackedCamera_IVRTrackedCamera_003_FnTable},
+    {"IVRRenderModels_005", &create_winIVRRenderModels_IVRRenderModels_005, &destroy_winIVRRenderModels_IVRRenderModels_005},
+    {"FnTable:IVRRenderModels_005", &create_winIVRRenderModels_IVRRenderModels_005_FnTable, &destroy_winIVRRenderModels_IVRRenderModels_005_FnTable},
+    {"IVRInput_003", &create_winIVRInput_IVRInput_003, &destroy_winIVRInput_IVRInput_003},
+    {"FnTable:IVRInput_003", &create_winIVRInput_IVRInput_003_FnTable, &destroy_winIVRInput_IVRInput_003_FnTable},
     {"IVRSystem_017", &create_winIVRSystem_IVRSystem_017, &destroy_winIVRSystem_IVRSystem_017},
     {"FnTable:IVRSystem_017", &create_winIVRSystem_IVRSystem_017_FnTable, &destroy_winIVRSystem_IVRSystem_017_FnTable},
     {"IVROverlay_017", &create_winIVROverlay_IVROverlay_017, &destroy_winIVROverlay_IVROverlay_017},

vrclient_x64/vrclient_x64/win_destructors.h

@@ -14,24 +14,30 @@ extern void destroy_winIVRNotifications_IVRNotifications_002(void *);
 extern void destroy_winIVRNotifications_IVRNotifications_002_FnTable(void *);
 extern void destroy_winIVROverlay_IVROverlay_018(void *);
 extern void destroy_winIVROverlay_IVROverlay_018_FnTable(void *);
-extern void destroy_winIVRRenderModels_IVRRenderModels_005(void *);
+extern void destroy_winIVRRenderModels_IVRRenderModels_006(void *);
-extern void destroy_winIVRRenderModels_IVRRenderModels_005_FnTable(void *);
+extern void destroy_winIVRRenderModels_IVRRenderModels_006_FnTable(void *);
 extern void destroy_winIVRExtendedDisplay_IVRExtendedDisplay_001(void *);
 extern void destroy_winIVRExtendedDisplay_IVRExtendedDisplay_001_FnTable(void *);
-extern void destroy_winIVRTrackedCamera_IVRTrackedCamera_003(void *);
+extern void destroy_winIVRTrackedCamera_IVRTrackedCamera_004(void *);
-extern void destroy_winIVRTrackedCamera_IVRTrackedCamera_003_FnTable(void *);
+extern void destroy_winIVRTrackedCamera_IVRTrackedCamera_004_FnTable(void *);
 extern void destroy_winIVRScreenshots_IVRScreenshots_001(void *);
 extern void destroy_winIVRScreenshots_IVRScreenshots_001_FnTable(void *);
 extern void destroy_winIVRResources_IVRResources_001(void *);
 extern void destroy_winIVRResources_IVRResources_001_FnTable(void *);
 extern void destroy_winIVRDriverManager_IVRDriverManager_001(void *);
 extern void destroy_winIVRDriverManager_IVRDriverManager_001_FnTable(void *);
-extern void destroy_winIVRInput_IVRInput_003(void *);
+extern void destroy_winIVRInput_IVRInput_004(void *);
-extern void destroy_winIVRInput_IVRInput_003_FnTable(void *);
+extern void destroy_winIVRInput_IVRInput_004_FnTable(void *);
 extern void destroy_winIVRIOBuffer_IVRIOBuffer_001(void *);
 extern void destroy_winIVRIOBuffer_IVRIOBuffer_001_FnTable(void *);
 extern void destroy_winIVRClientCore_IVRClientCore_003(void *);
 extern void destroy_winIVRClientCore_IVRClientCore_003_FnTable(void *);
+extern void destroy_winIVRTrackedCamera_IVRTrackedCamera_003(void *);
+extern void destroy_winIVRTrackedCamera_IVRTrackedCamera_003_FnTable(void *);
+extern void destroy_winIVRRenderModels_IVRRenderModels_005(void *);
+extern void destroy_winIVRRenderModels_IVRRenderModels_005_FnTable(void *);
+extern void destroy_winIVRInput_IVRInput_003(void *);
+extern void destroy_winIVRInput_IVRInput_003_FnTable(void *);
 extern void destroy_winIVRSystem_IVRSystem_017(void *);
 extern void destroy_winIVRSystem_IVRSystem_017_FnTable(void *);
 extern void destroy_winIVROverlay_IVROverlay_017(void *);