openvr: Support v1.2.10

vrclient_x64/gen_wrapper.py

@@ -12,6 +12,7 @@ import os
 import re
 
 sdk_versions = [
+    "v1.2.10",
     "v1.1.3b",
     "v1.0.17",
     "v1.0.16",
@@ -1099,7 +1100,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/7.0.1/include/'])
+        tu = index.parse(input_name, args=['-x', 'c++', '-std=c++11', '-DGNUC', '-Iopenvr_%s/' % sdkver, '-I/usr/lib/clang/8.0.0/include/'])
 
         diagnostics = list(tu.diagnostics)
         if len(diagnostics) > 0:

vrclient_x64/openvr_v1.2.10/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.c

@@ -2546,7 +2546,7 @@ EVRInputError __thiscall IVRInput_005_ShowBindingsForActionSet(void *_this, VRAc
     return 0;
 }
 
-EIOBufferError __thiscall IVRIOBuffer_001_Open(void *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer)
+EIOBufferError __thiscall IVRIOBuffer_002_Open(void *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchPath);
@@ -2557,14 +2557,14 @@ EIOBufferError __thiscall IVRIOBuffer_001_Open(void *_this, const char * pchPath
     return 0;
 }
 
-EIOBufferError __thiscall IVRIOBuffer_001_Close(void *_this, IOBufferHandle_t ulBuffer)
+EIOBufferError __thiscall IVRIOBuffer_002_Close(void *_this, IOBufferHandle_t ulBuffer)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulBuffer);
     return 0;
 }
 
-EIOBufferError __thiscall IVRIOBuffer_001_Read(void *_this, IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead)
+EIOBufferError __thiscall IVRIOBuffer_002_Read(void *_this, IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulBuffer);
@@ -2574,7 +2574,7 @@ EIOBufferError __thiscall IVRIOBuffer_001_Read(void *_this, IOBufferHandle_t ulB
     return 0;
 }
 
-EIOBufferError __thiscall IVRIOBuffer_001_Write(void *_this, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes)
+EIOBufferError __thiscall IVRIOBuffer_002_Write(void *_this, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulBuffer);
@@ -2583,7 +2583,14 @@ EIOBufferError __thiscall IVRIOBuffer_001_Write(void *_this, IOBufferHandle_t ul
     return 0;
 }
 
-PropertyContainerHandle_t __thiscall IVRIOBuffer_001_PropertyContainer(void *_this, IOBufferHandle_t ulBuffer)
+PropertyContainerHandle_t __thiscall IVRIOBuffer_002_PropertyContainer(void *_this, IOBufferHandle_t ulBuffer)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulBuffer);
+    return 0;
+}
+
+bool __thiscall IVRIOBuffer_002_HasReaders(void *_this, IOBufferHandle_t ulBuffer)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulBuffer);
@@ -2638,6 +2645,50 @@ const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRIn
     return 0;
 }
 
+EIOBufferError __thiscall IVRIOBuffer_001_Open(void *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchPath);
+    push_uint32_parameter(mode);
+    push_uint32_parameter(unElementSize);
+    push_uint32_parameter(unElements);
+    push_ptr_parameter(pulBuffer);
+    return 0;
+}
+
+EIOBufferError __thiscall IVRIOBuffer_001_Close(void *_this, IOBufferHandle_t ulBuffer)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulBuffer);
+    return 0;
+}
+
+EIOBufferError __thiscall IVRIOBuffer_001_Read(void *_this, IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulBuffer);
+    push_ptr_parameter(pDst);
+    push_uint32_parameter(unBytes);
+    push_ptr_parameter(punRead);
+    return 0;
+}
+
+EIOBufferError __thiscall IVRIOBuffer_001_Write(void *_this, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulBuffer);
+    push_ptr_parameter(pSrc);
+    push_uint32_parameter(unBytes);
+    return 0;
+}
+
+PropertyContainerHandle_t __thiscall IVRIOBuffer_001_PropertyContainer(void *_this, IOBufferHandle_t ulBuffer)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulBuffer);
+    return 0;
+}
+
 bool __thiscall IVRChaperoneSetup_005_CommitWorkingCopy(void *_this, EChaperoneConfigFile configFile)
 {
     push_ptr_parameter(_this);

vrclient_x64/tests/capi_thunks_autogen.h

@@ -671,17 +671,19 @@ EVRInputError __thiscall IVRInput_005_ShowActionOrigins(void *_this, VRActionSet
 
 EVRInputError __thiscall IVRInput_005_ShowBindingsForActionSet(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight);
 
-void test_capi_thunks_IVRIOBuffer_001(void);
+void test_capi_thunks_IVRIOBuffer_002(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_002_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_002_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_002_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);
+EIOBufferError __thiscall IVRIOBuffer_002_Write(void *_this, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes);
 
-PropertyContainerHandle_t __thiscall IVRIOBuffer_001_PropertyContainer(void *_this, IOBufferHandle_t ulBuffer);
+PropertyContainerHandle_t __thiscall IVRIOBuffer_002_PropertyContainer(void *_this, IOBufferHandle_t ulBuffer);
+
+bool __thiscall IVRIOBuffer_002_HasReaders(void *_this, IOBufferHandle_t ulBuffer);
 
 void test_capi_thunks_IVRClientCore_003(void);
 
@@ -699,6 +701,18 @@ const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_thi
 
 const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError);
 
+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_IVRChaperoneSetup_005(void);
 
 bool __thiscall IVRChaperoneSetup_005_CommitWorkingCopy(void *_this, EChaperoneConfigFile configFile);

vrclient_x64/tests/capi_thunks_tests_autogen.c

@@ -3012,58 +3012,66 @@ void test_capi_thunks_IVRInput_005(void)
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
-void test_capi_thunks_IVRIOBuffer_001(void)
+void test_capi_thunks_IVRIOBuffer_002(void)
 {
     struct thunk *t = alloc_thunks(1);
 
-    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Open, 5, FALSE, FALSE);
+    init_thunk(t, this_ptr_value, IVRIOBuffer_002_Open, 5, FALSE, FALSE);
-    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Open)(const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer) = (void *)t;
+    EIOBufferError (__stdcall *capi_IVRIOBuffer_002_Open)(const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer) = (void *)t;
 
     clear_parameters();
-    capi_IVRIOBuffer_001_Open((void *)1, 2, 3, 4, (void *)5);
+    capi_IVRIOBuffer_002_Open((void *)1, 2, 3, 4, (void *)5);
-    check_ptr_parameter("IVRIOBuffer_001_Open", this_ptr_value);
+    check_ptr_parameter("IVRIOBuffer_002_Open", this_ptr_value);
-    check_ptr_parameter("IVRIOBuffer_001_Open", (void *)1);
+    check_ptr_parameter("IVRIOBuffer_002_Open", (void *)1);
-    check_uint32_parameter("IVRIOBuffer_001_Open", 2);
+    check_uint32_parameter("IVRIOBuffer_002_Open", 2);
-    check_uint32_parameter("IVRIOBuffer_001_Open", 3);
+    check_uint32_parameter("IVRIOBuffer_002_Open", 3);
-    check_uint32_parameter("IVRIOBuffer_001_Open", 4);
+    check_uint32_parameter("IVRIOBuffer_002_Open", 4);
-    check_ptr_parameter("IVRIOBuffer_001_Open", (void *)5);
+    check_ptr_parameter("IVRIOBuffer_002_Open", (void *)5);
 
-    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Close, 1, FALSE, FALSE);
+    init_thunk(t, this_ptr_value, IVRIOBuffer_002_Close, 1, FALSE, FALSE);
-    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Close)(IOBufferHandle_t ulBuffer) = (void *)t;
+    EIOBufferError (__stdcall *capi_IVRIOBuffer_002_Close)(IOBufferHandle_t ulBuffer) = (void *)t;
 
     clear_parameters();
-    capi_IVRIOBuffer_001_Close(1);
+    capi_IVRIOBuffer_002_Close(1);
-    check_ptr_parameter("IVRIOBuffer_001_Close", this_ptr_value);
+    check_ptr_parameter("IVRIOBuffer_002_Close", this_ptr_value);
-    check_uint64_parameter("IVRIOBuffer_001_Close", 1);
+    check_uint64_parameter("IVRIOBuffer_002_Close", 1);
 
-    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Read, 4, FALSE, FALSE);
+    init_thunk(t, this_ptr_value, IVRIOBuffer_002_Read, 4, FALSE, FALSE);
-    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Read)(IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead) = (void *)t;
+    EIOBufferError (__stdcall *capi_IVRIOBuffer_002_Read)(IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead) = (void *)t;
 
     clear_parameters();
-    capi_IVRIOBuffer_001_Read(1, (void *)2, 3, (void *)4);
+    capi_IVRIOBuffer_002_Read(1, (void *)2, 3, (void *)4);
-    check_ptr_parameter("IVRIOBuffer_001_Read", this_ptr_value);
+    check_ptr_parameter("IVRIOBuffer_002_Read", this_ptr_value);
-    check_uint64_parameter("IVRIOBuffer_001_Read", 1);
+    check_uint64_parameter("IVRIOBuffer_002_Read", 1);
-    check_ptr_parameter("IVRIOBuffer_001_Read", (void *)2);
+    check_ptr_parameter("IVRIOBuffer_002_Read", (void *)2);
-    check_uint32_parameter("IVRIOBuffer_001_Read", 3);
+    check_uint32_parameter("IVRIOBuffer_002_Read", 3);
-    check_ptr_parameter("IVRIOBuffer_001_Read", (void *)4);
+    check_ptr_parameter("IVRIOBuffer_002_Read", (void *)4);
 
-    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Write, 3, FALSE, FALSE);
+    init_thunk(t, this_ptr_value, IVRIOBuffer_002_Write, 3, FALSE, FALSE);
-    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Write)(IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes) = (void *)t;
+    EIOBufferError (__stdcall *capi_IVRIOBuffer_002_Write)(IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes) = (void *)t;
 
     clear_parameters();
-    capi_IVRIOBuffer_001_Write(1, (void *)2, 3);
+    capi_IVRIOBuffer_002_Write(1, (void *)2, 3);
-    check_ptr_parameter("IVRIOBuffer_001_Write", this_ptr_value);
+    check_ptr_parameter("IVRIOBuffer_002_Write", this_ptr_value);
-    check_uint64_parameter("IVRIOBuffer_001_Write", 1);
+    check_uint64_parameter("IVRIOBuffer_002_Write", 1);
-    check_ptr_parameter("IVRIOBuffer_001_Write", (void *)2);
+    check_ptr_parameter("IVRIOBuffer_002_Write", (void *)2);
-    check_uint32_parameter("IVRIOBuffer_001_Write", 3);
+    check_uint32_parameter("IVRIOBuffer_002_Write", 3);
 
-    init_thunk(t, this_ptr_value, IVRIOBuffer_001_PropertyContainer, 1, FALSE, FALSE);
+    init_thunk(t, this_ptr_value, IVRIOBuffer_002_PropertyContainer, 1, FALSE, FALSE);
-    PropertyContainerHandle_t (__stdcall *capi_IVRIOBuffer_001_PropertyContainer)(IOBufferHandle_t ulBuffer) = (void *)t;
+    PropertyContainerHandle_t (__stdcall *capi_IVRIOBuffer_002_PropertyContainer)(IOBufferHandle_t ulBuffer) = (void *)t;
 
     clear_parameters();
-    capi_IVRIOBuffer_001_PropertyContainer(1);
+    capi_IVRIOBuffer_002_PropertyContainer(1);
-    check_ptr_parameter("IVRIOBuffer_001_PropertyContainer", this_ptr_value);
+    check_ptr_parameter("IVRIOBuffer_002_PropertyContainer", this_ptr_value);
-    check_uint64_parameter("IVRIOBuffer_001_PropertyContainer", 1);
+    check_uint64_parameter("IVRIOBuffer_002_PropertyContainer", 1);
+
+    init_thunk(t, this_ptr_value, IVRIOBuffer_002_HasReaders, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRIOBuffer_002_HasReaders)(IOBufferHandle_t ulBuffer) = (void *)t;
+
+    clear_parameters();
+    capi_IVRIOBuffer_002_HasReaders(1);
+    check_ptr_parameter("IVRIOBuffer_002_HasReaders", this_ptr_value);
+    check_uint64_parameter("IVRIOBuffer_002_HasReaders", 1);
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
@@ -3129,6 +3137,61 @@ void test_capi_thunks_IVRClientCore_003(void)
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
+void test_capi_thunks_IVRIOBuffer_001(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Open, 5, FALSE, FALSE);
+    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Open)(const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer) = (void *)t;
+
+    clear_parameters();
+    capi_IVRIOBuffer_001_Open((void *)1, 2, 3, 4, (void *)5);
+    check_ptr_parameter("IVRIOBuffer_001_Open", this_ptr_value);
+    check_ptr_parameter("IVRIOBuffer_001_Open", (void *)1);
+    check_uint32_parameter("IVRIOBuffer_001_Open", 2);
+    check_uint32_parameter("IVRIOBuffer_001_Open", 3);
+    check_uint32_parameter("IVRIOBuffer_001_Open", 4);
+    check_ptr_parameter("IVRIOBuffer_001_Open", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Close, 1, FALSE, FALSE);
+    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Close)(IOBufferHandle_t ulBuffer) = (void *)t;
+
+    clear_parameters();
+    capi_IVRIOBuffer_001_Close(1);
+    check_ptr_parameter("IVRIOBuffer_001_Close", this_ptr_value);
+    check_uint64_parameter("IVRIOBuffer_001_Close", 1);
+
+    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Read, 4, FALSE, FALSE);
+    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Read)(IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead) = (void *)t;
+
+    clear_parameters();
+    capi_IVRIOBuffer_001_Read(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRIOBuffer_001_Read", this_ptr_value);
+    check_uint64_parameter("IVRIOBuffer_001_Read", 1);
+    check_ptr_parameter("IVRIOBuffer_001_Read", (void *)2);
+    check_uint32_parameter("IVRIOBuffer_001_Read", 3);
+    check_ptr_parameter("IVRIOBuffer_001_Read", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Write, 3, FALSE, FALSE);
+    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Write)(IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes) = (void *)t;
+
+    clear_parameters();
+    capi_IVRIOBuffer_001_Write(1, (void *)2, 3);
+    check_ptr_parameter("IVRIOBuffer_001_Write", this_ptr_value);
+    check_uint64_parameter("IVRIOBuffer_001_Write", 1);
+    check_ptr_parameter("IVRIOBuffer_001_Write", (void *)2);
+    check_uint32_parameter("IVRIOBuffer_001_Write", 3);
+
+    init_thunk(t, this_ptr_value, IVRIOBuffer_001_PropertyContainer, 1, FALSE, FALSE);
+    PropertyContainerHandle_t (__stdcall *capi_IVRIOBuffer_001_PropertyContainer)(IOBufferHandle_t ulBuffer) = (void *)t;
+
+    clear_parameters();
+    capi_IVRIOBuffer_001_PropertyContainer(1);
+    check_ptr_parameter("IVRIOBuffer_001_PropertyContainer", this_ptr_value);
+    check_uint64_parameter("IVRIOBuffer_001_PropertyContainer", 1);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
 void test_capi_thunks_IVRChaperoneSetup_005(void)
 {
     struct thunk *t = alloc_thunks(1);

vrclient_x64/tests/main_autogen.c

@@ -20,8 +20,9 @@ int main(void)
     test_capi_thunks_IVRResources_001();
     test_capi_thunks_IVRDriverManager_001();
     test_capi_thunks_IVRInput_005();
-    test_capi_thunks_IVRIOBuffer_001();
+    test_capi_thunks_IVRIOBuffer_002();
     test_capi_thunks_IVRClientCore_003();
+    test_capi_thunks_IVRIOBuffer_001();
     test_capi_thunks_IVRChaperoneSetup_005();
     test_capi_thunks_IVROverlay_018();
     test_capi_thunks_IVRTrackedCamera_004();

vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_006.cpp

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

vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.cpp

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

vrclient_x64/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_002.cpp

@@ -0,0 +1,44 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.2.10/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRIOBuffer_IVRIOBuffer_002.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::EIOBufferError cppIVRIOBuffer_IVRIOBuffer_002_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_002_Close(void *linux_side, IOBufferHandle_t ulBuffer)
+{
+    return ((IVRIOBuffer*)linux_side)->Close((vr::IOBufferHandle_t)ulBuffer);
+}
+
+vr::EIOBufferError cppIVRIOBuffer_IVRIOBuffer_002_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_002_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_002_PropertyContainer(void *linux_side, IOBufferHandle_t ulBuffer)
+{
+    return ((IVRIOBuffer*)linux_side)->PropertyContainer((vr::IOBufferHandle_t)ulBuffer);
+}
+
+bool cppIVRIOBuffer_IVRIOBuffer_002_HasReaders(void *linux_side, IOBufferHandle_t ulBuffer)
+{
+    return ((IVRIOBuffer*)linux_side)->HasReaders((vr::IOBufferHandle_t)ulBuffer);
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_002.h

@@ -0,0 +1,12 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern EIOBufferError cppIVRIOBuffer_IVRIOBuffer_002_Open(void *, const char *, EIOBufferMode, uint32_t, uint32_t, IOBufferHandle_t *);
+extern EIOBufferError cppIVRIOBuffer_IVRIOBuffer_002_Close(void *, IOBufferHandle_t);
+extern EIOBufferError cppIVRIOBuffer_IVRIOBuffer_002_Read(void *, IOBufferHandle_t, void *, uint32_t, uint32_t *);
+extern EIOBufferError cppIVRIOBuffer_IVRIOBuffer_002_Write(void *, IOBufferHandle_t, void *, uint32_t);
+extern PropertyContainerHandle_t cppIVRIOBuffer_IVRIOBuffer_002_PropertyContainer(void *, IOBufferHandle_t);
+extern bool cppIVRIOBuffer_IVRIOBuffer_002_HasReaders(void *, IOBufferHandle_t);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_005.cpp

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

vrclient_x64/vrclient_x64/cppIVRNotifications_IVRNotifications_002.cpp

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

vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_019.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.1.3b/ivrclientcore.h"
+#include "openvr_v1.2.10/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
@@ -234,12 +234,12 @@ vr::EVROverlayError cppIVROverlay_IVROverlay_019_GetTransformForOverlayCoordinat
     return ((IVROverlay*)linux_side)->GetTransformForOverlayCoordinates((vr::VROverlayHandle_t)ulOverlayHandle, (vr::ETrackingUniverseOrigin)eTrackingOrigin, (vr::HmdVector2_t)coordinatesInOverlay, (vr::HmdMatrix34_t *)pmatTransform);
 }
 
-bool cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_113b * pEvent, uint32_t uncbVREvent)
+bool cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1210 * pEvent, uint32_t uncbVREvent)
 {
     VREvent_t lin;
     bool _ret;
     _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, &lin, sizeof(lin));
-    struct_VREvent_t_113b_lin_to_win(&lin, pEvent);
+    struct_VREvent_t_1210_lin_to_win(&lin, pEvent);
     return _ret;
 }
 

vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_019.h

@@ -46,7 +46,7 @@ extern EVROverlayError cppIVROverlay_IVROverlay_019_ShowOverlay(void *, VROverla
 extern EVROverlayError cppIVROverlay_IVROverlay_019_HideOverlay(void *, VROverlayHandle_t);
 extern bool cppIVROverlay_IVROverlay_019_IsOverlayVisible(void *, VROverlayHandle_t);
 extern EVROverlayError cppIVROverlay_IVROverlay_019_GetTransformForOverlayCoordinates(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdVector2_t, HmdMatrix34_t *);
-extern bool cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_113b *, uint32_t);
+extern bool cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1210 *, uint32_t);
 extern EVROverlayError cppIVROverlay_IVROverlay_019_GetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod *);
 extern EVROverlayError cppIVROverlay_IVROverlay_019_SetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod);
 extern EVROverlayError cppIVROverlay_IVROverlay_019_GetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);

vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.1.3b/ivrclientcore.h"
+#include "openvr_v1.2.10/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
@@ -9,34 +9,34 @@ extern "C" {
 #ifdef __cplusplus
 extern "C" {
 #endif
-vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_113b ** ppRenderModel)
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1210 ** ppRenderModel)
 {
     RenderModel_t *lin;
     vr::EVRRenderModelError _ret;
     _ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, &lin);
     if(_ret == 0)
-        *ppRenderModel = struct_RenderModel_t_113b_wrap(lin);
+        *ppRenderModel = struct_RenderModel_t_1210_wrap(lin);
     return _ret;
 }
 
-void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_113b * pRenderModel)
+void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1210 * pRenderModel)
 {
-    ((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_113b_unwrap(pRenderModel));
+    ((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1210_unwrap(pRenderModel));
 }
 
-vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_113b ** ppTexture)
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1210 ** 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_113b_wrap(lin);
+        *ppTexture = struct_RenderModel_TextureMap_t_1210_wrap(lin);
     return _ret;
 }
 
-void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_113b * pTexture)
+void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1210 * pTexture)
 {
-    ((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_113b_unwrap(pTexture));
+    ((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1210_unwrap(pTexture));
 }
 
 vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTextureD3D11_Async(void *linux_side, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D)

vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.h

@@ -1,10 +1,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *, const char *, winRenderModel_t_113b **);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1210 **);
-extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_113b *);
+extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_1210 *);
-extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_113b **);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1210 **);
-extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_113b *);
+extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_1210 *);
 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 *);

vrclient_x64/vrclient_x64/cppIVRResources_IVRResources_001.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.1.3b/ivrclientcore.h"
+#include "openvr_v1.2.10/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.1.3b/ivrclientcore.h"
+#include "openvr_v1.2.10/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.1.3b/ivrclientcore.h"
+#include "openvr_v1.2.10/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.1.3b/ivrclientcore.h"
+#include "openvr_v1.2.10/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_113b * pEvent, uint32_t uncbVREvent)
+bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *linux_side, winVREvent_t_1210 * pEvent, uint32_t uncbVREvent)
 {
     VREvent_t lin;
     bool _ret;
     _ret = ((IVRSystem*)linux_side)->PollNextEvent(&lin, sizeof(lin));
-    struct_VREvent_t_113b_lin_to_win(&lin, pEvent);
+    struct_VREvent_t_1210_lin_to_win(&lin, pEvent);
     return _ret;
 }
 
-bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_113b * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1210 * 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_113b_lin_to_win(&lin, pEvent);
+    struct_VREvent_t_1210_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_113b * pControllerState, uint32_t unControllerStateSize)
+bool cppIVRSystem_IVRSystem_019_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1210 * pControllerState, uint32_t unControllerStateSize)
 {
     VRControllerState001_t lin;
     bool _ret;
     _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, &lin, sizeof(lin));
-    struct_VRControllerState001_t_113b_lin_to_win(&lin, pControllerState);
+    struct_VRControllerState001_t_1210_lin_to_win(&lin, pControllerState);
     return _ret;
 }
 
-bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_113b * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1210 * 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_113b_lin_to_win(&lin, pControllerState);
+    struct_VRControllerState001_t_1210_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_113b *, uint32_t);
+extern bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *, winVREvent_t_1210 *, uint32_t);
-extern bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_113b *, uint32_t, TrackedDevicePose_t *);
+extern bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1210 *, 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_113b *, uint32_t);
+extern bool cppIVRSystem_IVRSystem_019_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1210 *, uint32_t);
-extern bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_113b *, uint32_t, TrackedDevicePose_t *);
+extern bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1210 *, 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_005.cpp

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

vrclient_x64/vrclient_x64/struct_converters.h

@@ -1,3 +1,13 @@
+typedef struct winVREvent_t_1210 winVREvent_t_1210;
+extern void struct_VREvent_t_1210_lin_to_win(void *l, void *w);
+typedef struct winVRControllerState001_t_1210 winVRControllerState001_t_1210;
+extern void struct_VRControllerState001_t_1210_lin_to_win(void *l, void *w);
+typedef struct winRenderModel_TextureMap_t_1210 winRenderModel_TextureMap_t_1210;
+extern struct winRenderModel_TextureMap_t_1210 *struct_RenderModel_TextureMap_t_1210_wrap(void *l);
+extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1210_unwrap(winRenderModel_TextureMap_t_1210 *w);
+typedef struct winRenderModel_t_1210 winRenderModel_t_1210;
+extern struct winRenderModel_t_1210 *struct_RenderModel_t_1210_wrap(void *l);
+extern RenderModel_t *struct_RenderModel_t_1210_unwrap(winRenderModel_t_1210 *w);
 typedef struct winVREvent_t_113b winVREvent_t_113b;
 extern void struct_VREvent_t_113b_lin_to_win(void *l, void *w);
 typedef struct winVRControllerState001_t_113b winVRControllerState001_t_113b;

vrclient_x64/vrclient_x64/struct_converters_1210.cpp

@@ -0,0 +1,108 @@
+#include <stdlib.h>
+#include <string.h>
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.2.10/openvr.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+#pragma pack(push, 8)
+struct winVREvent_t_1210 {
+    uint32_t eventType;
+    vr::TrackedDeviceIndex_t trackedDeviceIndex;
+    float eventAgeSeconds;
+    vr::VREvent_Data_t data;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_VREvent_t_1210_lin_to_win(void *l, void *w)
+{
+    struct winVREvent_t_1210 *win = (struct winVREvent_t_1210 *)w;
+    VREvent_t *lin = (VREvent_t *)l;
+    win->eventType = lin->eventType;
+    win->trackedDeviceIndex = lin->trackedDeviceIndex;
+    win->eventAgeSeconds = lin->eventAgeSeconds;
+    win->data = lin->data;
+}
+
+#pragma pack(push, 8)
+struct winVRControllerState001_t_1210 {
+    uint32_t unPacketNum;
+    uint64_t ulButtonPressed;
+    uint64_t ulButtonTouched;
+    vr::VRControllerAxis_t rAxis[5];
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_VRControllerState001_t_1210_lin_to_win(void *l, void *w)
+{
+    struct winVRControllerState001_t_1210 *win = (struct winVRControllerState001_t_1210 *)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));
+}
+
+#pragma pack(push, 8)
+struct winRenderModel_TextureMap_t_1210 {
+    uint16_t unWidth;
+    uint16_t unHeight;
+    const uint8_t * rubTextureMapData;
+
+    RenderModel_TextureMap_t *linux_side;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+struct winRenderModel_TextureMap_t_1210 *struct_RenderModel_TextureMap_t_1210_wrap(void *l)
+{
+    struct winRenderModel_TextureMap_t_1210 *win = (struct winRenderModel_TextureMap_t_1210 *)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_1210_unwrap(winRenderModel_TextureMap_t_1210 *w)
+{
+    RenderModel_TextureMap_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+#pragma pack(push, 8)
+struct winRenderModel_t_1210 {
+    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));
+#pragma pack(pop)
+
+struct winRenderModel_t_1210 *struct_RenderModel_t_1210_wrap(void *l)
+{
+    struct winRenderModel_t_1210 *win = (struct winRenderModel_t_1210 *)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_1210_unwrap(winRenderModel_t_1210 *w)
+{
+    RenderModel_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+
+}

vrclient_x64/vrclient_x64/winIVRIOBuffer.c

@@ -18,6 +18,117 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
 
+#include "cppIVRIOBuffer_IVRIOBuffer_002.h"
+
+typedef struct __winIVRIOBuffer_IVRIOBuffer_002 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVRIOBuffer_IVRIOBuffer_002;
+
+DEFINE_THISCALL_WRAPPER(winIVRIOBuffer_IVRIOBuffer_002_Open, 32)
+EIOBufferError __thiscall winIVRIOBuffer_IVRIOBuffer_002_Open(winIVRIOBuffer_IVRIOBuffer_002 *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer)
+{
+    TRACE("%p\n", _this);
+    return cppIVRIOBuffer_IVRIOBuffer_002_Open(_this->linux_side, pchPath, mode, unElementSize, unElements, pulBuffer);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRIOBuffer_IVRIOBuffer_002_Close, 12)
+EIOBufferError __thiscall winIVRIOBuffer_IVRIOBuffer_002_Close(winIVRIOBuffer_IVRIOBuffer_002 *_this, IOBufferHandle_t ulBuffer)
+{
+    TRACE("%p\n", _this);
+    return cppIVRIOBuffer_IVRIOBuffer_002_Close(_this->linux_side, ulBuffer);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRIOBuffer_IVRIOBuffer_002_Read, 32)
+EIOBufferError __thiscall winIVRIOBuffer_IVRIOBuffer_002_Read(winIVRIOBuffer_IVRIOBuffer_002 *_this, IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead)
+{
+    TRACE("%p\n", _this);
+    return cppIVRIOBuffer_IVRIOBuffer_002_Read(_this->linux_side, ulBuffer, pDst, unBytes, punRead);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRIOBuffer_IVRIOBuffer_002_Write, 24)
+EIOBufferError __thiscall winIVRIOBuffer_IVRIOBuffer_002_Write(winIVRIOBuffer_IVRIOBuffer_002 *_this, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes)
+{
+    TRACE("%p\n", _this);
+    return cppIVRIOBuffer_IVRIOBuffer_002_Write(_this->linux_side, ulBuffer, pSrc, unBytes);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRIOBuffer_IVRIOBuffer_002_PropertyContainer, 12)
+PropertyContainerHandle_t __thiscall winIVRIOBuffer_IVRIOBuffer_002_PropertyContainer(winIVRIOBuffer_IVRIOBuffer_002 *_this, IOBufferHandle_t ulBuffer)
+{
+    TRACE("%p\n", _this);
+    return cppIVRIOBuffer_IVRIOBuffer_002_PropertyContainer(_this->linux_side, ulBuffer);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRIOBuffer_IVRIOBuffer_002_HasReaders, 12)
+bool __thiscall winIVRIOBuffer_IVRIOBuffer_002_HasReaders(winIVRIOBuffer_IVRIOBuffer_002 *_this, IOBufferHandle_t ulBuffer)
+{
+    TRACE("%p\n", _this);
+    return cppIVRIOBuffer_IVRIOBuffer_002_HasReaders(_this->linux_side, ulBuffer);
+}
+
+extern vtable_ptr winIVRIOBuffer_IVRIOBuffer_002_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRIOBuffer_IVRIOBuffer_002,
+        VTABLE_ADD_FUNC(winIVRIOBuffer_IVRIOBuffer_002_Open)
+        VTABLE_ADD_FUNC(winIVRIOBuffer_IVRIOBuffer_002_Close)
+        VTABLE_ADD_FUNC(winIVRIOBuffer_IVRIOBuffer_002_Read)
+        VTABLE_ADD_FUNC(winIVRIOBuffer_IVRIOBuffer_002_Write)
+        VTABLE_ADD_FUNC(winIVRIOBuffer_IVRIOBuffer_002_PropertyContainer)
+        VTABLE_ADD_FUNC(winIVRIOBuffer_IVRIOBuffer_002_HasReaders)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRIOBuffer_IVRIOBuffer_002 *create_winIVRIOBuffer_IVRIOBuffer_002(void *linux_side)
+{
+    winIVRIOBuffer_IVRIOBuffer_002 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRIOBuffer_IVRIOBuffer_002));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRIOBuffer_IVRIOBuffer_002_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRIOBuffer_IVRIOBuffer_002(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRIOBuffer_IVRIOBuffer_002 *create_winIVRIOBuffer_IVRIOBuffer_002_FnTable(void *linux_side)
+{
+    winIVRIOBuffer_IVRIOBuffer_002 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRIOBuffer_IVRIOBuffer_002));
+    struct thunk *thunks = alloc_thunks(6);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 6 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVRIOBuffer_IVRIOBuffer_002_Open, 5, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVRIOBuffer_IVRIOBuffer_002_Close, 1, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVRIOBuffer_IVRIOBuffer_002_Read, 4, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVRIOBuffer_IVRIOBuffer_002_Write, 3, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVRIOBuffer_IVRIOBuffer_002_PropertyContainer, 1, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVRIOBuffer_IVRIOBuffer_002_HasReaders, 1, FALSE, FALSE);
+    for (i = 0; i < 6; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVRIOBuffer_IVRIOBuffer_002_FnTable(void *object)
+{
+    winIVRIOBuffer_IVRIOBuffer_002 *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 "cppIVRIOBuffer_IVRIOBuffer_001.h"
 
 typedef struct __winIVRIOBuffer_IVRIOBuffer_001 {

vrclient_x64/vrclient_x64/winIVROverlay.c

@@ -341,7 +341,7 @@ EVROverlayError __thiscall winIVROverlay_IVROverlay_019_GetTransformForOverlayCo
 }
 
 DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_019_PollNextOverlayEvent, 24)
-bool __thiscall winIVROverlay_IVROverlay_019_PollNextOverlayEvent(winIVROverlay_IVROverlay_019 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_113b * pEvent, uint32_t uncbVREvent)
+bool __thiscall winIVROverlay_IVROverlay_019_PollNextOverlayEvent(winIVROverlay_IVROverlay_019 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1210 * pEvent, uint32_t uncbVREvent)
 {
     TRACE("%p\n", _this);
     return cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(_this->linux_side, ulOverlayHandle, pEvent, uncbVREvent);

vrclient_x64/vrclient_x64/winIVRRenderModels.c

@@ -26,28 +26,28 @@ typedef struct __winIVRRenderModels_IVRRenderModels_006 {
 } 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_113b ** ppRenderModel)
+EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, winRenderModel_t_1210 ** 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_113b * pRenderModel)
+void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeRenderModel(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_t_1210 * 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_113b ** ppTexture)
+EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_1210 ** 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_113b * pTexture)
+void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeTexture(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_TextureMap_t_1210 * pTexture)
 {
     TRACE("%p\n", _this);
     cppIVRRenderModels_IVRRenderModels_006_FreeTexture(_this->linux_side, pTexture);

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_113b * pEvent, uint32_t uncbVREvent)
+bool __thiscall winIVRSystem_IVRSystem_019_PollNextEvent(winIVRSystem_IVRSystem_019 *_this, winVREvent_t_1210 * 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_113b * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+bool __thiscall winIVRSystem_IVRSystem_019_PollNextEventWithPose(winIVRSystem_IVRSystem_019 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1210 * 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_113b * pControllerState, uint32_t unControllerStateSize)
+bool __thiscall winIVRSystem_IVRSystem_019_GetControllerState(winIVRSystem_IVRSystem_019 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1210 * 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_113b * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+bool __thiscall winIVRSystem_IVRSystem_019_GetControllerStateWithPose(winIVRSystem_IVRSystem_019 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1210 * 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/win_constructors.h

@@ -28,10 +28,12 @@ extern void *create_winIVRDriverManager_IVRDriverManager_001(void *);
 extern void *create_winIVRDriverManager_IVRDriverManager_001_FnTable(void *);
 extern void *create_winIVRInput_IVRInput_005(void *);
 extern void *create_winIVRInput_IVRInput_005_FnTable(void *);
-extern void *create_winIVRIOBuffer_IVRIOBuffer_001(void *);
+extern void *create_winIVRIOBuffer_IVRIOBuffer_002(void *);
-extern void *create_winIVRIOBuffer_IVRIOBuffer_001_FnTable(void *);
+extern void *create_winIVRIOBuffer_IVRIOBuffer_002_FnTable(void *);
 extern void *create_winIVRClientCore_IVRClientCore_003(void *);
 extern void *create_winIVRClientCore_IVRClientCore_003_FnTable(void *);
+extern void *create_winIVRIOBuffer_IVRIOBuffer_001(void *);
+extern void *create_winIVRIOBuffer_IVRIOBuffer_001_FnTable(void *);
 extern void *create_winIVRChaperoneSetup_IVRChaperoneSetup_005(void *);
 extern void *create_winIVRChaperoneSetup_IVRChaperoneSetup_005_FnTable(void *);
 extern void *create_winIVROverlay_IVROverlay_018(void *);

vrclient_x64/vrclient_x64/win_constructors_table.dat

@@ -28,10 +28,12 @@
     {"FnTable:IVRDriverManager_001", &create_winIVRDriverManager_IVRDriverManager_001_FnTable, &destroy_winIVRDriverManager_IVRDriverManager_001_FnTable},
     {"IVRInput_005", &create_winIVRInput_IVRInput_005, &destroy_winIVRInput_IVRInput_005},
     {"FnTable:IVRInput_005", &create_winIVRInput_IVRInput_005_FnTable, &destroy_winIVRInput_IVRInput_005_FnTable},
-    {"IVRIOBuffer_001", &create_winIVRIOBuffer_IVRIOBuffer_001, &destroy_winIVRIOBuffer_IVRIOBuffer_001},
+    {"IVRIOBuffer_002", &create_winIVRIOBuffer_IVRIOBuffer_002, &destroy_winIVRIOBuffer_IVRIOBuffer_002},
-    {"FnTable:IVRIOBuffer_001", &create_winIVRIOBuffer_IVRIOBuffer_001_FnTable, &destroy_winIVRIOBuffer_IVRIOBuffer_001_FnTable},
+    {"FnTable:IVRIOBuffer_002", &create_winIVRIOBuffer_IVRIOBuffer_002_FnTable, &destroy_winIVRIOBuffer_IVRIOBuffer_002_FnTable},
     {"IVRClientCore_003", &create_winIVRClientCore_IVRClientCore_003, &destroy_winIVRClientCore_IVRClientCore_003},
     {"FnTable:IVRClientCore_003", &create_winIVRClientCore_IVRClientCore_003_FnTable, &destroy_winIVRClientCore_IVRClientCore_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},
     {"IVRChaperoneSetup_005", &create_winIVRChaperoneSetup_IVRChaperoneSetup_005, &destroy_winIVRChaperoneSetup_IVRChaperoneSetup_005},
     {"FnTable:IVRChaperoneSetup_005", &create_winIVRChaperoneSetup_IVRChaperoneSetup_005_FnTable, &destroy_winIVRChaperoneSetup_IVRChaperoneSetup_005_FnTable},
     {"IVROverlay_018", &create_winIVROverlay_IVROverlay_018, &destroy_winIVROverlay_IVROverlay_018},

vrclient_x64/vrclient_x64/win_destructors.h

@@ -28,10 +28,12 @@ extern void destroy_winIVRDriverManager_IVRDriverManager_001(void *);
 extern void destroy_winIVRDriverManager_IVRDriverManager_001_FnTable(void *);
 extern void destroy_winIVRInput_IVRInput_005(void *);
 extern void destroy_winIVRInput_IVRInput_005_FnTable(void *);
-extern void destroy_winIVRIOBuffer_IVRIOBuffer_001(void *);
+extern void destroy_winIVRIOBuffer_IVRIOBuffer_002(void *);
-extern void destroy_winIVRIOBuffer_IVRIOBuffer_001_FnTable(void *);
+extern void destroy_winIVRIOBuffer_IVRIOBuffer_002_FnTable(void *);
 extern void destroy_winIVRClientCore_IVRClientCore_003(void *);
 extern void destroy_winIVRClientCore_IVRClientCore_003_FnTable(void *);
+extern void destroy_winIVRIOBuffer_IVRIOBuffer_001(void *);
+extern void destroy_winIVRIOBuffer_IVRIOBuffer_001_FnTable(void *);
 extern void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_005(void *);
 extern void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_005_FnTable(void *);
 extern void destroy_winIVROverlay_IVROverlay_018(void *);