vrclient: Support openvr v1.1.3b

vrclient_x64/gen_wrapper.py

@@ -12,6 +12,7 @@ import os
 import re
 
 sdk_versions = [
+    "v1.1.3b",
     "v1.0.17",
     "v1.0.16",
     "v1.0.15",

vrclient_x64/make_sdks.sh

@@ -4,8 +4,8 @@
 
 for f in $(git tag); do
     mkdir openvr_$f
-    git show $f:./headers/openvr.h | grep -v 'pragma once' > openvr_$f/openvr.h
+    git show $f:./headers/openvr.h | grep -av 'pragma once' > openvr_$f/openvr.h
-    git show $f:./src/ivrclientcore.h | grep -v 'pragma once' > openvr_$f/ivrclientcore.h
+    git show $f:./src/ivrclientcore.h | grep -av 'pragma once' > openvr_$f/ivrclientcore.h
     if [ x"$(head openvr_$f/ivrclientcore.h)" = x"" ]; then
         rm openvr_$f/ivrclientcore.h
     fi

vrclient_x64/openvr_v1.1.3b/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/main_autogen.c

@@ -9,19 +9,23 @@ int main(void)
     test_capi_thunks_IVRApplications_006();
     test_capi_thunks_IVRSettings_002();
     test_capi_thunks_IVRChaperone_003();
-    test_capi_thunks_IVRChaperoneSetup_005();
+    test_capi_thunks_IVRChaperoneSetup_006();
     test_capi_thunks_IVRCompositor_022();
     test_capi_thunks_IVRNotifications_002();
-    test_capi_thunks_IVROverlay_018();
+    test_capi_thunks_IVROverlay_019();
     test_capi_thunks_IVRRenderModels_006();
     test_capi_thunks_IVRExtendedDisplay_001();
-    test_capi_thunks_IVRTrackedCamera_004();
+    test_capi_thunks_IVRTrackedCamera_005();
     test_capi_thunks_IVRScreenshots_001();
     test_capi_thunks_IVRResources_001();
     test_capi_thunks_IVRDriverManager_001();
-    test_capi_thunks_IVRInput_004();
+    test_capi_thunks_IVRInput_005();
     test_capi_thunks_IVRIOBuffer_001();
     test_capi_thunks_IVRClientCore_003();
+    test_capi_thunks_IVRChaperoneSetup_005();
+    test_capi_thunks_IVROverlay_018();
+    test_capi_thunks_IVRTrackedCamera_004();
+    test_capi_thunks_IVRInput_004();
     test_capi_thunks_IVRTrackedCamera_003();
     test_capi_thunks_IVRRenderModels_005();
     test_capi_thunks_IVRInput_003();

vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_006.cpp

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

vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.cpp

@@ -0,0 +1,109 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.1.3b/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRChaperoneSetup_IVRChaperoneSetup_006.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_CommitWorkingCopy(void *linux_side, EChaperoneConfigFile configFile)
+{
+    return ((IVRChaperoneSetup*)linux_side)->CommitWorkingCopy((vr::EChaperoneConfigFile)configFile);
+}
+
+void cppIVRChaperoneSetup_IVRChaperoneSetup_006_RevertWorkingCopy(void *linux_side)
+{
+    ((IVRChaperoneSetup*)linux_side)->RevertWorkingCopy();
+}
+
+bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_GetWorkingPlayAreaSize(void *linux_side, float * pSizeX, float * pSizeZ)
+{
+    return ((IVRChaperoneSetup*)linux_side)->GetWorkingPlayAreaSize((float *)pSizeX, (float *)pSizeZ);
+}
+
+bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_GetWorkingPlayAreaRect(void *linux_side, HmdQuad_t * rect)
+{
+    return ((IVRChaperoneSetup*)linux_side)->GetWorkingPlayAreaRect((vr::HmdQuad_t *)rect);
+}
+
+bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_GetWorkingCollisionBoundsInfo(void *linux_side, HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount)
+{
+    return ((IVRChaperoneSetup*)linux_side)->GetWorkingCollisionBoundsInfo((vr::HmdQuad_t *)pQuadsBuffer, (uint32_t *)punQuadsCount);
+}
+
+bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_GetLiveCollisionBoundsInfo(void *linux_side, HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount)
+{
+    return ((IVRChaperoneSetup*)linux_side)->GetLiveCollisionBoundsInfo((vr::HmdQuad_t *)pQuadsBuffer, (uint32_t *)punQuadsCount);
+}
+
+bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_GetWorkingSeatedZeroPoseToRawTrackingPose(void *linux_side, HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose)
+{
+    return ((IVRChaperoneSetup*)linux_side)->GetWorkingSeatedZeroPoseToRawTrackingPose((vr::HmdMatrix34_t *)pmatSeatedZeroPoseToRawTrackingPose);
+}
+
+bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_GetWorkingStandingZeroPoseToRawTrackingPose(void *linux_side, HmdMatrix34_t * pmatStandingZeroPoseToRawTrackingPose)
+{
+    return ((IVRChaperoneSetup*)linux_side)->GetWorkingStandingZeroPoseToRawTrackingPose((vr::HmdMatrix34_t *)pmatStandingZeroPoseToRawTrackingPose);
+}
+
+void cppIVRChaperoneSetup_IVRChaperoneSetup_006_SetWorkingPlayAreaSize(void *linux_side, float sizeX, float sizeZ)
+{
+    ((IVRChaperoneSetup*)linux_side)->SetWorkingPlayAreaSize((float)sizeX, (float)sizeZ);
+}
+
+void cppIVRChaperoneSetup_IVRChaperoneSetup_006_SetWorkingCollisionBoundsInfo(void *linux_side, HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount)
+{
+    ((IVRChaperoneSetup*)linux_side)->SetWorkingCollisionBoundsInfo((vr::HmdQuad_t *)pQuadsBuffer, (uint32_t)unQuadsCount);
+}
+
+void cppIVRChaperoneSetup_IVRChaperoneSetup_006_SetWorkingPerimeter(void *linux_side, HmdVector2_t * pPointBuffer, uint32_t unPointCount)
+{
+    ((IVRChaperoneSetup*)linux_side)->SetWorkingPerimeter((vr::HmdVector2_t *)pPointBuffer, (uint32_t)unPointCount);
+}
+
+void cppIVRChaperoneSetup_IVRChaperoneSetup_006_SetWorkingSeatedZeroPoseToRawTrackingPose(void *linux_side, HmdMatrix34_t * pMatSeatedZeroPoseToRawTrackingPose)
+{
+    ((IVRChaperoneSetup*)linux_side)->SetWorkingSeatedZeroPoseToRawTrackingPose((const vr::HmdMatrix34_t *)pMatSeatedZeroPoseToRawTrackingPose);
+}
+
+void cppIVRChaperoneSetup_IVRChaperoneSetup_006_SetWorkingStandingZeroPoseToRawTrackingPose(void *linux_side, HmdMatrix34_t * pMatStandingZeroPoseToRawTrackingPose)
+{
+    ((IVRChaperoneSetup*)linux_side)->SetWorkingStandingZeroPoseToRawTrackingPose((const vr::HmdMatrix34_t *)pMatStandingZeroPoseToRawTrackingPose);
+}
+
+void cppIVRChaperoneSetup_IVRChaperoneSetup_006_ReloadFromDisk(void *linux_side, EChaperoneConfigFile configFile)
+{
+    ((IVRChaperoneSetup*)linux_side)->ReloadFromDisk((vr::EChaperoneConfigFile)configFile);
+}
+
+bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_GetLiveSeatedZeroPoseToRawTrackingPose(void *linux_side, HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose)
+{
+    return ((IVRChaperoneSetup*)linux_side)->GetLiveSeatedZeroPoseToRawTrackingPose((vr::HmdMatrix34_t *)pmatSeatedZeroPoseToRawTrackingPose);
+}
+
+bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_ExportLiveToBuffer(void *linux_side, char * pBuffer, uint32_t * pnBufferLength)
+{
+    return ((IVRChaperoneSetup*)linux_side)->ExportLiveToBuffer((char *)pBuffer, (uint32_t *)pnBufferLength);
+}
+
+bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_ImportFromBufferToWorking(void *linux_side, const char * pBuffer, uint32_t nImportFlags)
+{
+    return ((IVRChaperoneSetup*)linux_side)->ImportFromBufferToWorking((const char *)pBuffer, (uint32_t)nImportFlags);
+}
+
+void cppIVRChaperoneSetup_IVRChaperoneSetup_006_ShowWorkingSetPreview(void *linux_side)
+{
+    ((IVRChaperoneSetup*)linux_side)->ShowWorkingSetPreview();
+}
+
+void cppIVRChaperoneSetup_IVRChaperoneSetup_006_HideWorkingSetPreview(void *linux_side)
+{
+    ((IVRChaperoneSetup*)linux_side)->HideWorkingSetPreview();
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.h

@@ -0,0 +1,25 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_CommitWorkingCopy(void *, EChaperoneConfigFile);
+extern void cppIVRChaperoneSetup_IVRChaperoneSetup_006_RevertWorkingCopy(void *);
+extern bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_GetWorkingPlayAreaSize(void *, float *, float *);
+extern bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_GetWorkingPlayAreaRect(void *, HmdQuad_t *);
+extern bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_GetWorkingCollisionBoundsInfo(void *, HmdQuad_t *, uint32_t *);
+extern bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_GetLiveCollisionBoundsInfo(void *, HmdQuad_t *, uint32_t *);
+extern bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_GetWorkingSeatedZeroPoseToRawTrackingPose(void *, HmdMatrix34_t *);
+extern bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_GetWorkingStandingZeroPoseToRawTrackingPose(void *, HmdMatrix34_t *);
+extern void cppIVRChaperoneSetup_IVRChaperoneSetup_006_SetWorkingPlayAreaSize(void *, float, float);
+extern void cppIVRChaperoneSetup_IVRChaperoneSetup_006_SetWorkingCollisionBoundsInfo(void *, HmdQuad_t *, uint32_t);
+extern void cppIVRChaperoneSetup_IVRChaperoneSetup_006_SetWorkingPerimeter(void *, HmdVector2_t *, uint32_t);
+extern void cppIVRChaperoneSetup_IVRChaperoneSetup_006_SetWorkingSeatedZeroPoseToRawTrackingPose(void *, HmdMatrix34_t *);
+extern void cppIVRChaperoneSetup_IVRChaperoneSetup_006_SetWorkingStandingZeroPoseToRawTrackingPose(void *, HmdMatrix34_t *);
+extern void cppIVRChaperoneSetup_IVRChaperoneSetup_006_ReloadFromDisk(void *, EChaperoneConfigFile);
+extern bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_GetLiveSeatedZeroPoseToRawTrackingPose(void *, HmdMatrix34_t *);
+extern bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_ExportLiveToBuffer(void *, char *, uint32_t *);
+extern bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_ImportFromBufferToWorking(void *, const char *, uint32_t);
+extern void cppIVRChaperoneSetup_IVRChaperoneSetup_006_ShowWorkingSetPreview(void *);
+extern void cppIVRChaperoneSetup_IVRChaperoneSetup_006_HideWorkingSetPreview(void *);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_003.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.17/ivrclientcore.h"
+#include "openvr_v1.1.3b/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.17/ivrclientcore.h"
+#include "openvr_v1.1.3b/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.17/ivrclientcore.h"
+#include "openvr_v1.1.3b/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
@@ -224,6 +224,11 @@ vr::EVRCompositorError cppIVRCompositor_IVRCompositor_022_SubmitExplicitTimingDa
     return ((IVRCompositor*)linux_side)->SubmitExplicitTimingData();
 }
 
+bool cppIVRCompositor_IVRCompositor_022_IsMotionSmoothingEnabled(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->IsMotionSmoothingEnabled();
+}
+
 #ifdef __cplusplus
 }
 #endif

vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_022.h

@@ -44,6 +44,7 @@ extern uint32_t cppIVRCompositor_IVRCompositor_022_GetVulkanInstanceExtensionsRe
 extern uint32_t cppIVRCompositor_IVRCompositor_022_GetVulkanDeviceExtensionsRequired(void *, VkPhysicalDevice_T *, char *, uint32_t);
 extern void cppIVRCompositor_IVRCompositor_022_SetExplicitTimingMode(void *, EVRCompositorTimingMode);
 extern EVRCompositorError cppIVRCompositor_IVRCompositor_022_SubmitExplicitTimingData(void *);
+extern bool cppIVRCompositor_IVRCompositor_022_IsMotionSmoothingEnabled(void *);
 #ifdef __cplusplus
 }
 #endif

vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_005.cpp

@@ -0,0 +1,134 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.1.3b/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRInput_IVRInput_005.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::EVRInputError cppIVRInput_IVRInput_005_SetActionManifestPath(void *linux_side, const char * pchActionManifestPath)
+{
+    return ((IVRInput*)linux_side)->SetActionManifestPath((const char *)pchActionManifestPath);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_005_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_005_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_005_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_005_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_005_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_005_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_005_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_005_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, (vr::InputSkeletalActionData_t *)pActionData, (uint32_t)unActionDataSize);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_005_GetBoneCount(void *linux_side, VRActionHandle_t action, uint32_t * pBoneCount)
+{
+    return ((IVRInput*)linux_side)->GetBoneCount((vr::VRActionHandle_t)action, (uint32_t *)pBoneCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_005_GetBoneHierarchy(void *linux_side, VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount)
+{
+    return ((IVRInput*)linux_side)->GetBoneHierarchy((vr::VRActionHandle_t)action, (vr::BoneIndex_t *)pParentIndices, (uint32_t)unIndexArayCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_005_GetBoneName(void *linux_side, VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize)
+{
+    return ((IVRInput*)linux_side)->GetBoneName((vr::VRActionHandle_t)action, (vr::BoneIndex_t)nBoneIndex, (char *)pchBoneName, (uint32_t)unNameBufferSize);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_005_GetSkeletalReferenceTransforms(void *linux_side, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalReferenceTransforms((vr::VRActionHandle_t)action, (vr::EVRSkeletalTransformSpace)eTransformSpace, (vr::EVRSkeletalReferencePose)eReferencePose, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_005_GetSkeletalTrackingLevel(void *linux_side, VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalTrackingLevel((vr::VRActionHandle_t)action, (vr::EVRSkeletalTrackingLevel *)pSkeletalTrackingLevel);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_005_GetSkeletalBoneData(void *linux_side, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalBoneData((vr::VRActionHandle_t)action, (vr::EVRSkeletalTransformSpace)eTransformSpace, (vr::EVRSkeletalMotionRange)eMotionRange, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_005_GetSkeletalSummaryData(void *linux_side, VRActionHandle_t action, VRSkeletalSummaryData_t * pSkeletalSummaryData)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalSummaryData((vr::VRActionHandle_t)action, (vr::VRSkeletalSummaryData_t *)pSkeletalSummaryData);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_005_GetSkeletalBoneDataCompressed(void *linux_side, VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalBoneDataCompressed((vr::VRActionHandle_t)action, (vr::EVRSkeletalMotionRange)eMotionRange, (void *)pvCompressedData, (uint32_t)unCompressedSize, (uint32_t *)punRequiredCompressedSize);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_005_DecompressSkeletalBoneData(void *linux_side, const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    return ((IVRInput*)linux_side)->DecompressSkeletalBoneData((const void *)pvCompressedBuffer, (uint32_t)unCompressedBufferSize, (vr::EVRSkeletalTransformSpace)eTransformSpace, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_005_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_005_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_005_GetOriginLocalizedName(void *linux_side, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude)
+{
+    return ((IVRInput*)linux_side)->GetOriginLocalizedName((vr::VRInputValueHandle_t)origin, (char *)pchNameArray, (uint32_t)unNameArraySize, (int32_t)unStringSectionsToInclude);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_005_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_005_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_005_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_005.h

@@ -0,0 +1,30 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern EVRInputError cppIVRInput_IVRInput_005_SetActionManifestPath(void *, const char *);
+extern EVRInputError cppIVRInput_IVRInput_005_GetActionSetHandle(void *, const char *, VRActionSetHandle_t *);
+extern EVRInputError cppIVRInput_IVRInput_005_GetActionHandle(void *, const char *, VRActionHandle_t *);
+extern EVRInputError cppIVRInput_IVRInput_005_GetInputSourceHandle(void *, const char *, VRInputValueHandle_t *);
+extern EVRInputError cppIVRInput_IVRInput_005_UpdateActionState(void *, VRActiveActionSet_t *, uint32_t, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetDigitalActionData(void *, VRActionHandle_t, InputDigitalActionData_t *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetAnalogActionData(void *, VRActionHandle_t, InputAnalogActionData_t *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetPoseActionData(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, InputPoseActionData_t *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetSkeletalActionData(void *, VRActionHandle_t, InputSkeletalActionData_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetBoneCount(void *, VRActionHandle_t, uint32_t *);
+extern EVRInputError cppIVRInput_IVRInput_005_GetBoneHierarchy(void *, VRActionHandle_t, BoneIndex_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetBoneName(void *, VRActionHandle_t, BoneIndex_t, char *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetSkeletalReferenceTransforms(void *, VRActionHandle_t, EVRSkeletalTransformSpace, EVRSkeletalReferencePose, VRBoneTransform_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetSkeletalTrackingLevel(void *, VRActionHandle_t, EVRSkeletalTrackingLevel *);
+extern EVRInputError cppIVRInput_IVRInput_005_GetSkeletalBoneData(void *, VRActionHandle_t, EVRSkeletalTransformSpace, EVRSkeletalMotionRange, VRBoneTransform_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetSkeletalSummaryData(void *, VRActionHandle_t, VRSkeletalSummaryData_t *);
+extern EVRInputError cppIVRInput_IVRInput_005_GetSkeletalBoneDataCompressed(void *, VRActionHandle_t, EVRSkeletalMotionRange, void *, uint32_t, uint32_t *);
+extern EVRInputError cppIVRInput_IVRInput_005_DecompressSkeletalBoneData(void *, const void *, uint32_t, EVRSkeletalTransformSpace, VRBoneTransform_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_005_TriggerHapticVibrationAction(void *, VRActionHandle_t, float, float, float, float, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetActionOrigins(void *, VRActionSetHandle_t, VRActionHandle_t, VRInputValueHandle_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetOriginLocalizedName(void *, VRInputValueHandle_t, char *, uint32_t, int32_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetOriginTrackedDeviceInfo(void *, VRInputValueHandle_t, InputOriginInfo_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_005_ShowActionOrigins(void *, VRActionSetHandle_t, VRActionHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_005_ShowBindingsForActionSet(void *, VRActiveActionSet_t *, uint32_t, uint32_t, VRInputValueHandle_t);
+#ifdef __cplusplus
+}
+#endif