vrclient: Support IVRInput and IVRIOBuffer

vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_001.cpp

@@ -0,0 +1,39 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.0.15/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRIOBuffer_IVRIOBuffer_001.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::EIOBufferError cppIVRIOBuffer_IVRIOBuffer_001_Open(void *linux_side, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer)
+{
+    return ((IVRIOBuffer*)linux_side)->Open((const char *)pchPath, (vr::EIOBufferMode)mode, (uint32_t)unElementSize, (uint32_t)unElements, (vr::IOBufferHandle_t *)pulBuffer);
+}
+
+vr::EIOBufferError cppIVRIOBuffer_IVRIOBuffer_001_Close(void *linux_side, IOBufferHandle_t ulBuffer)
+{
+    return ((IVRIOBuffer*)linux_side)->Close((vr::IOBufferHandle_t)ulBuffer);
+}
+
+vr::EIOBufferError cppIVRIOBuffer_IVRIOBuffer_001_Read(void *linux_side, IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead)
+{
+    return ((IVRIOBuffer*)linux_side)->Read((vr::IOBufferHandle_t)ulBuffer, (void *)pDst, (uint32_t)unBytes, (uint32_t *)punRead);
+}
+
+vr::EIOBufferError cppIVRIOBuffer_IVRIOBuffer_001_Write(void *linux_side, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes)
+{
+    return ((IVRIOBuffer*)linux_side)->Write((vr::IOBufferHandle_t)ulBuffer, (void *)pSrc, (uint32_t)unBytes);
+}
+
+vr::PropertyContainerHandle_t cppIVRIOBuffer_IVRIOBuffer_001_PropertyContainer(void *linux_side, IOBufferHandle_t ulBuffer)
+{
+    return ((IVRIOBuffer*)linux_side)->PropertyContainer((vr::IOBufferHandle_t)ulBuffer);
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_001.h

@@ -0,0 +1,11 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern EIOBufferError cppIVRIOBuffer_IVRIOBuffer_001_Open(void *, const char *, EIOBufferMode, uint32_t, uint32_t, IOBufferHandle_t *);
+extern EIOBufferError cppIVRIOBuffer_IVRIOBuffer_001_Close(void *, IOBufferHandle_t);
+extern EIOBufferError cppIVRIOBuffer_IVRIOBuffer_001_Read(void *, IOBufferHandle_t, void *, uint32_t, uint32_t *);
+extern EIOBufferError cppIVRIOBuffer_IVRIOBuffer_001_Write(void *, IOBufferHandle_t, void *, uint32_t);
+extern PropertyContainerHandle_t cppIVRIOBuffer_IVRIOBuffer_001_PropertyContainer(void *, IOBufferHandle_t);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/cppIVRInput_IVRInput_003.cpp

@@ -0,0 +1,99 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.0.15/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRInput_IVRInput_003.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::EVRInputError cppIVRInput_IVRInput_003_SetActionManifestPath(void *linux_side, const char * pchActionManifestPath)
+{
+    return ((IVRInput*)linux_side)->SetActionManifestPath((const char *)pchActionManifestPath);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_003_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_003_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_003_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_003_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_003_GetDigitalActionData(void *linux_side, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize)
+{
+    return ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, (vr::InputDigitalActionData_t *)pActionData, (uint32_t)unActionDataSize);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_003_GetAnalogActionData(void *linux_side, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize)
+{
+    return ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, (vr::InputAnalogActionData_t *)pActionData, (uint32_t)unActionDataSize);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_003_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize)
+{
+    return ((IVRInput*)linux_side)->GetPoseActionData((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, (vr::InputPoseActionData_t *)pActionData, (uint32_t)unActionDataSize);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_003_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, InputSkeletonActionData_t * pActionData, uint32_t unActionDataSize, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, (vr::EVRSkeletalTransformSpace)eBoneParent, (float)fPredictedSecondsFromNow, (vr::InputSkeletonActionData_t *)pActionData, (uint32_t)unActionDataSize, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_003_GetSkeletalActionDataCompressed(void *linux_side, VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize)
+{
+    return ((IVRInput*)linux_side)->GetSkeletalActionDataCompressed((vr::VRActionHandle_t)action, (vr::EVRSkeletalTransformSpace)eBoneParent, (float)fPredictedSecondsFromNow, (void *)pvCompressedData, (uint32_t)unCompressedSize, (uint32_t *)punRequiredCompressedSize);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_003_UncompressSkeletalActionData(void *linux_side, void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace * peBoneParent, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    return ((IVRInput*)linux_side)->UncompressSkeletalActionData((void *)pvCompressedBuffer, (uint32_t)unCompressedBufferSize, (vr::EVRSkeletalTransformSpace *)peBoneParent, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_003_TriggerHapticVibrationAction(void *linux_side, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude)
+{
+    return ((IVRInput*)linux_side)->TriggerHapticVibrationAction((vr::VRActionHandle_t)action, (float)fStartSecondsFromNow, (float)fDurationSeconds, (float)fFrequency, (float)fAmplitude);
+}
+
+vr::EVRInputError cppIVRInput_IVRInput_003_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_003_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_003_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_003_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_003_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/cppIVRInput_IVRInput_003.h

@@ -0,0 +1,23 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern EVRInputError cppIVRInput_IVRInput_003_SetActionManifestPath(void *, const char *);
+extern EVRInputError cppIVRInput_IVRInput_003_GetActionSetHandle(void *, const char *, VRActionSetHandle_t *);
+extern EVRInputError cppIVRInput_IVRInput_003_GetActionHandle(void *, const char *, VRActionHandle_t *);
+extern EVRInputError cppIVRInput_IVRInput_003_GetInputSourceHandle(void *, const char *, VRInputValueHandle_t *);
+extern EVRInputError cppIVRInput_IVRInput_003_UpdateActionState(void *, VRActiveActionSet_t *, uint32_t, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_003_GetDigitalActionData(void *, VRActionHandle_t, InputDigitalActionData_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_003_GetAnalogActionData(void *, VRActionHandle_t, InputAnalogActionData_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_003_GetPoseActionData(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, InputPoseActionData_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_003_GetSkeletalActionData(void *, VRActionHandle_t, EVRSkeletalTransformSpace, float, InputSkeletonActionData_t *, uint32_t, VRBoneTransform_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_003_GetSkeletalActionDataCompressed(void *, VRActionHandle_t, EVRSkeletalTransformSpace, float, void *, uint32_t, uint32_t *);
+extern EVRInputError cppIVRInput_IVRInput_003_UncompressSkeletalActionData(void *, void *, uint32_t, EVRSkeletalTransformSpace *, VRBoneTransform_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_003_TriggerHapticVibrationAction(void *, VRActionHandle_t, float, float, float, float);
+extern EVRInputError cppIVRInput_IVRInput_003_GetActionOrigins(void *, VRActionSetHandle_t, VRActionHandle_t, VRInputValueHandle_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_003_GetOriginLocalizedName(void *, VRInputValueHandle_t, char *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_003_GetOriginTrackedDeviceInfo(void *, VRInputValueHandle_t, InputOriginInfo_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_003_ShowActionOrigins(void *, VRActionSetHandle_t, VRActionHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_003_ShowBindingsForActionSet(void *, VRActiveActionSet_t *, uint32_t, uint32_t, VRInputValueHandle_t);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/gen_wrapper.py

@@ -59,6 +59,8 @@ files = [
         "IVRDriverManager",
         "IVRExtendedDisplay",
         "IVRNotifications",
+        "IVRInput",
+        "IVRIOBuffer",
         "IVROverlay",
         "IVRRenderModels",
         "IVRResources",
@@ -622,7 +624,7 @@ def handle_struct(sdkver, struct, which):
 
 #clang.cindex.Config.set_library_file("/usr/lib/llvm-3.8/lib/libclang-3.8.so.1");
 
-prog = re.compile("^.*const\s*char.* (\w*)_Version.*\"(.*)\"")
+prog = re.compile("^.*const\s*char.* \*?(\w*)_Version.*\"(.*)\"")
 for sdkver in sdk_versions:
     iface_versions = {}
     print("sdkver is: " + sdkver)

vrclient_x64/vrclient_defs.h

@@ -58,7 +58,11 @@ typedef int
         NotificationError_t,
         VROverlayError,
         VROverlayVisibility,
-        ECameraVideoStreamFormat;
+        ECameraVideoStreamFormat,
+        EVRInputError,
+        EIOBufferError,
+        EVRSkeletalTransformSpace,
+        EIOBufferMode;
 
 typedef uint32_t DriverId_t;
 typedef uint32_t TrackedDeviceIndex_t;
@@ -73,6 +77,10 @@ typedef uint64_t TrackedCameraHandle_t;
 typedef uint32_t PropertyTypeTag_t;
 typedef uint64_t PropertyContainerHandle_t;
 typedef PropertyContainerHandle_t DriverHandle_t;
+typedef uint64_t IOBufferHandle_t;
+typedef uint64_t VRActionHandle_t;
+typedef uint64_t VRActionSetHandle_t;
+typedef uint64_t VRInputValueHandle_t;
 
 /* never dereferenced */
 typedef struct VROverlayIntersectionParams_t VROverlayIntersectionParams_t;
@@ -101,6 +109,13 @@ typedef struct VkDevice_T VkDevice_T;
 typedef struct VkPhysicalDevice_T VkPhysicalDevice_T;
 typedef struct VkInstance_T VkInstance_T;
 typedef struct VkQueue_T VkQueue_T;
+typedef struct InputDigitalActionData_t InputDigitalActionData_t;
+typedef struct InputSkeletonActionData_t InputSkeletonActionData_t;
+typedef struct InputPoseActionData_t InputPoseActionData_t;
+typedef struct InputAnalogActionData_t InputAnalogActionData_t;
+typedef struct VRActiveActionSet_t VRActiveActionSet_t;
+typedef struct VRBoneTransform_t VRBoneTransform_t;
+typedef struct InputOriginInfo_t InputOriginInfo_t;
 
 /* dereferenced structs */
 typedef struct HmdMatrix34_t

vrclient_x64/winIVRIOBuffer.c

@@ -0,0 +1,122 @@
+/* This file is auto-generated, do not edit. */
+#include <stdarg.h>
+#include <stdint.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wine/debug.h"
+
+#include "cxx.h"
+
+#include "vrclient_defs.h"
+
+#include "vrclient_private.h"
+
+#include "struct_converters.h"
+
+#include "flatapi.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
+
+#include "cppIVRIOBuffer_IVRIOBuffer_001.h"
+
+typedef struct __winIVRIOBuffer_IVRIOBuffer_001 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVRIOBuffer_IVRIOBuffer_001;
+
+DEFINE_THISCALL_WRAPPER(winIVRIOBuffer_IVRIOBuffer_001_Open, 32)
+EIOBufferError __thiscall winIVRIOBuffer_IVRIOBuffer_001_Open(winIVRIOBuffer_IVRIOBuffer_001 *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer)
+{
+    TRACE("%p\n", _this);
+    return cppIVRIOBuffer_IVRIOBuffer_001_Open(_this->linux_side, pchPath, mode, unElementSize, unElements, pulBuffer);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRIOBuffer_IVRIOBuffer_001_Close, 12)
+EIOBufferError __thiscall winIVRIOBuffer_IVRIOBuffer_001_Close(winIVRIOBuffer_IVRIOBuffer_001 *_this, IOBufferHandle_t ulBuffer)
+{
+    TRACE("%p\n", _this);
+    return cppIVRIOBuffer_IVRIOBuffer_001_Close(_this->linux_side, ulBuffer);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRIOBuffer_IVRIOBuffer_001_Read, 32)
+EIOBufferError __thiscall winIVRIOBuffer_IVRIOBuffer_001_Read(winIVRIOBuffer_IVRIOBuffer_001 *_this, IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead)
+{
+    TRACE("%p\n", _this);
+    return cppIVRIOBuffer_IVRIOBuffer_001_Read(_this->linux_side, ulBuffer, pDst, unBytes, punRead);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRIOBuffer_IVRIOBuffer_001_Write, 24)
+EIOBufferError __thiscall winIVRIOBuffer_IVRIOBuffer_001_Write(winIVRIOBuffer_IVRIOBuffer_001 *_this, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes)
+{
+    TRACE("%p\n", _this);
+    return cppIVRIOBuffer_IVRIOBuffer_001_Write(_this->linux_side, ulBuffer, pSrc, unBytes);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRIOBuffer_IVRIOBuffer_001_PropertyContainer, 12)
+PropertyContainerHandle_t __thiscall winIVRIOBuffer_IVRIOBuffer_001_PropertyContainer(winIVRIOBuffer_IVRIOBuffer_001 *_this, IOBufferHandle_t ulBuffer)
+{
+    TRACE("%p\n", _this);
+    return cppIVRIOBuffer_IVRIOBuffer_001_PropertyContainer(_this->linux_side, ulBuffer);
+}
+
+extern vtable_ptr winIVRIOBuffer_IVRIOBuffer_001_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRIOBuffer_IVRIOBuffer_001,
+        VTABLE_ADD_FUNC(winIVRIOBuffer_IVRIOBuffer_001_Open)
+        VTABLE_ADD_FUNC(winIVRIOBuffer_IVRIOBuffer_001_Close)
+        VTABLE_ADD_FUNC(winIVRIOBuffer_IVRIOBuffer_001_Read)
+        VTABLE_ADD_FUNC(winIVRIOBuffer_IVRIOBuffer_001_Write)
+        VTABLE_ADD_FUNC(winIVRIOBuffer_IVRIOBuffer_001_PropertyContainer)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRIOBuffer_IVRIOBuffer_001 *create_winIVRIOBuffer_IVRIOBuffer_001(void *linux_side)
+{
+    winIVRIOBuffer_IVRIOBuffer_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRIOBuffer_IVRIOBuffer_001));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRIOBuffer_IVRIOBuffer_001_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRIOBuffer_IVRIOBuffer_001(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRIOBuffer_IVRIOBuffer_001 *create_winIVRIOBuffer_IVRIOBuffer_001_FnTable(void *linux_side)
+{
+    winIVRIOBuffer_IVRIOBuffer_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRIOBuffer_IVRIOBuffer_001));
+    struct thunk *thunks = alloc_thunks(5);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 5 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVRIOBuffer_IVRIOBuffer_001_Open);
+    init_thunk(&thunks[1], r, winIVRIOBuffer_IVRIOBuffer_001_Close);
+    init_thunk(&thunks[2], r, winIVRIOBuffer_IVRIOBuffer_001_Read);
+    init_thunk(&thunks[3], r, winIVRIOBuffer_IVRIOBuffer_001_Write);
+    init_thunk(&thunks[4], r, winIVRIOBuffer_IVRIOBuffer_001_PropertyContainer);
+    for (i = 0; i < 5; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVRIOBuffer_IVRIOBuffer_001_FnTable(void *object)
+{
+    winIVRIOBuffer_IVRIOBuffer_001 *win_object = object;
+    TRACE("%p\n", win_object);
+    VirtualFree(win_object->vtable[0], 0, MEM_RELEASE);
+    HeapFree(GetProcessHeap(), 0, win_object->vtable);
+    HeapFree(GetProcessHeap(), 0, win_object);
+}
+

vrclient_x64/winIVRInput.c

@@ -0,0 +1,230 @@
+/* This file is auto-generated, do not edit. */
+#include <stdarg.h>
+#include <stdint.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wine/debug.h"
+
+#include "cxx.h"
+
+#include "vrclient_defs.h"
+
+#include "vrclient_private.h"
+
+#include "struct_converters.h"
+
+#include "flatapi.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
+
+#include "cppIVRInput_IVRInput_003.h"
+
+typedef struct __winIVRInput_IVRInput_003 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVRInput_IVRInput_003;
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_SetActionManifestPath, 12)
+EVRInputError __thiscall winIVRInput_IVRInput_003_SetActionManifestPath(winIVRInput_IVRInput_003 *_this, const char * pchActionManifestPath)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_SetActionManifestPath(_this->linux_side, pchActionManifestPath);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetActionSetHandle, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetActionSetHandle(winIVRInput_IVRInput_003 *_this, const char * pchActionSetName, VRActionSetHandle_t * pHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_GetActionSetHandle(_this->linux_side, pchActionSetName, pHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetActionHandle, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetActionHandle(winIVRInput_IVRInput_003 *_this, const char * pchActionName, VRActionHandle_t * pHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_GetActionHandle(_this->linux_side, pchActionName, pHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetInputSourceHandle, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetInputSourceHandle(winIVRInput_IVRInput_003 *_this, const char * pchInputSourcePath, VRInputValueHandle_t * pHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_GetInputSourceHandle(_this->linux_side, pchInputSourcePath, pHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_UpdateActionState, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_003_UpdateActionState(winIVRInput_IVRInput_003 *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_UpdateActionState(_this->linux_side, pSets, unSizeOfVRSelectedActionSet_t, unSetCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetDigitalActionData, 24)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetDigitalActionData(winIVRInput_IVRInput_003 *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_GetDigitalActionData(_this->linux_side, action, pActionData, unActionDataSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetAnalogActionData, 24)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetAnalogActionData(winIVRInput_IVRInput_003 *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_GetAnalogActionData(_this->linux_side, action, pActionData, unActionDataSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetPoseActionData, 32)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetPoseActionData(winIVRInput_IVRInput_003 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_GetPoseActionData(_this->linux_side, action, eOrigin, fPredictedSecondsFromNow, pActionData, unActionDataSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetSkeletalActionData, 44)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetSkeletalActionData(winIVRInput_IVRInput_003 *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, InputSkeletonActionData_t * pActionData, uint32_t unActionDataSize, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_GetSkeletalActionData(_this->linux_side, action, eBoneParent, fPredictedSecondsFromNow, pActionData, unActionDataSize, pTransformArray, unTransformArrayCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetSkeletalActionDataCompressed, 40)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetSkeletalActionDataCompressed(winIVRInput_IVRInput_003 *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_GetSkeletalActionDataCompressed(_this->linux_side, action, eBoneParent, fPredictedSecondsFromNow, pvCompressedData, unCompressedSize, punRequiredCompressedSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_UncompressSkeletalActionData, 36)
+EVRInputError __thiscall winIVRInput_IVRInput_003_UncompressSkeletalActionData(winIVRInput_IVRInput_003 *_this, void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace * peBoneParent, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_UncompressSkeletalActionData(_this->linux_side, pvCompressedBuffer, unCompressedBufferSize, peBoneParent, pTransformArray, unTransformArrayCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_TriggerHapticVibrationAction, 28)
+EVRInputError __thiscall winIVRInput_IVRInput_003_TriggerHapticVibrationAction(winIVRInput_IVRInput_003 *_this, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_TriggerHapticVibrationAction(_this->linux_side, action, fStartSecondsFromNow, fDurationSeconds, fFrequency, fAmplitude);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetActionOrigins, 32)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetActionOrigins(winIVRInput_IVRInput_003 *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_GetActionOrigins(_this->linux_side, actionSetHandle, digitalActionHandle, originsOut, originOutCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetOriginLocalizedName, 24)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetOriginLocalizedName(winIVRInput_IVRInput_003 *_this, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_GetOriginLocalizedName(_this->linux_side, origin, pchNameArray, unNameArraySize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetOriginTrackedDeviceInfo, 24)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetOriginTrackedDeviceInfo(winIVRInput_IVRInput_003 *_this, VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_GetOriginTrackedDeviceInfo(_this->linux_side, origin, pOriginInfo, unOriginInfoSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_ShowActionOrigins, 20)
+EVRInputError __thiscall winIVRInput_IVRInput_003_ShowActionOrigins(winIVRInput_IVRInput_003 *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_ShowActionOrigins(_this->linux_side, actionSetHandle, ulActionHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_ShowBindingsForActionSet, 28)
+EVRInputError __thiscall winIVRInput_IVRInput_003_ShowBindingsForActionSet(winIVRInput_IVRInput_003 *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_003_ShowBindingsForActionSet(_this->linux_side, pSets, unSizeOfVRSelectedActionSet_t, unSetCount, originToHighlight);
+}
+
+extern vtable_ptr winIVRInput_IVRInput_003_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRInput_IVRInput_003,
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_SetActionManifestPath)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_GetActionSetHandle)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_GetActionHandle)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_GetInputSourceHandle)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_UpdateActionState)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_GetDigitalActionData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_GetAnalogActionData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_GetPoseActionData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_GetSkeletalActionData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_GetSkeletalActionDataCompressed)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_UncompressSkeletalActionData)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_TriggerHapticVibrationAction)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_GetActionOrigins)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_GetOriginLocalizedName)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_GetOriginTrackedDeviceInfo)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_ShowActionOrigins)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_003_ShowBindingsForActionSet)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRInput_IVRInput_003 *create_winIVRInput_IVRInput_003(void *linux_side)
+{
+    winIVRInput_IVRInput_003 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRInput_IVRInput_003));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRInput_IVRInput_003_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRInput_IVRInput_003(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRInput_IVRInput_003 *create_winIVRInput_IVRInput_003_FnTable(void *linux_side)
+{
+    winIVRInput_IVRInput_003 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRInput_IVRInput_003));
+    struct thunk *thunks = alloc_thunks(17);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 17 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVRInput_IVRInput_003_SetActionManifestPath);
+    init_thunk(&thunks[1], r, winIVRInput_IVRInput_003_GetActionSetHandle);
+    init_thunk(&thunks[2], r, winIVRInput_IVRInput_003_GetActionHandle);
+    init_thunk(&thunks[3], r, winIVRInput_IVRInput_003_GetInputSourceHandle);
+    init_thunk(&thunks[4], r, winIVRInput_IVRInput_003_UpdateActionState);
+    init_thunk(&thunks[5], r, winIVRInput_IVRInput_003_GetDigitalActionData);
+    init_thunk(&thunks[6], r, winIVRInput_IVRInput_003_GetAnalogActionData);
+    init_thunk(&thunks[7], r, winIVRInput_IVRInput_003_GetPoseActionData);
+    init_thunk(&thunks[8], r, winIVRInput_IVRInput_003_GetSkeletalActionData);
+    init_thunk(&thunks[9], r, winIVRInput_IVRInput_003_GetSkeletalActionDataCompressed);
+    init_thunk(&thunks[10], r, winIVRInput_IVRInput_003_UncompressSkeletalActionData);
+    init_thunk(&thunks[11], r, winIVRInput_IVRInput_003_TriggerHapticVibrationAction);
+    init_thunk(&thunks[12], r, winIVRInput_IVRInput_003_GetActionOrigins);
+    init_thunk(&thunks[13], r, winIVRInput_IVRInput_003_GetOriginLocalizedName);
+    init_thunk(&thunks[14], r, winIVRInput_IVRInput_003_GetOriginTrackedDeviceInfo);
+    init_thunk(&thunks[15], r, winIVRInput_IVRInput_003_ShowActionOrigins);
+    init_thunk(&thunks[16], r, winIVRInput_IVRInput_003_ShowBindingsForActionSet);
+    for (i = 0; i < 17; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVRInput_IVRInput_003_FnTable(void *object)
+{
+    winIVRInput_IVRInput_003 *win_object = object;
+    TRACE("%p\n", win_object);
+    VirtualFree(win_object->vtable[0], 0, MEM_RELEASE);
+    HeapFree(GetProcessHeap(), 0, win_object->vtable);
+    HeapFree(GetProcessHeap(), 0, win_object);
+}
+

vrclient_x64/win_constructors.h

@@ -26,6 +26,10 @@ 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_003_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_winIVRSystem_IVRSystem_017(void *);

vrclient_x64/win_constructors_table.dat

@@ -26,6 +26,10 @@
     {"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},
+    {"FnTable:IVRInput_003", &create_winIVRInput_IVRInput_003_FnTable, &destroy_winIVRInput_IVRInput_003_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},
     {"IVRSystem_017", &create_winIVRSystem_IVRSystem_017, &destroy_winIVRSystem_IVRSystem_017},

vrclient_x64/win_destructors.h

@@ -26,6 +26,10 @@ 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_003_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_winIVRSystem_IVRSystem_017(void *);