diff --git a/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_001.cpp b/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_001.cpp new file mode 100644 index 00000000..aacf3a39 --- /dev/null +++ b/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 diff --git a/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_001.h b/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_001.h new file mode 100644 index 00000000..6ff16ae3 --- /dev/null +++ b/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 diff --git a/vrclient_x64/cppIVRInput_IVRInput_003.cpp b/vrclient_x64/cppIVRInput_IVRInput_003.cpp new file mode 100644 index 00000000..9c89a1a2 --- /dev/null +++ b/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 diff --git a/vrclient_x64/cppIVRInput_IVRInput_003.h b/vrclient_x64/cppIVRInput_IVRInput_003.h new file mode 100644 index 00000000..1d2a3ca4 --- /dev/null +++ b/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 diff --git a/vrclient_x64/gen_wrapper.py b/vrclient_x64/gen_wrapper.py index 083ccf32..2c5c586b 100755 --- a/vrclient_x64/gen_wrapper.py +++ b/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) diff --git a/vrclient_x64/vrclient_defs.h b/vrclient_x64/vrclient_defs.h index 0e91dd70..7ae7aead 100644 --- a/vrclient_x64/vrclient_defs.h +++ b/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 diff --git a/vrclient_x64/winIVRIOBuffer.c b/vrclient_x64/winIVRIOBuffer.c new file mode 100644 index 00000000..f9503a4c --- /dev/null +++ b/vrclient_x64/winIVRIOBuffer.c @@ -0,0 +1,122 @@ +/* This file is auto-generated, do not edit. */ +#include +#include + +#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); +} + diff --git a/vrclient_x64/winIVRInput.c b/vrclient_x64/winIVRInput.c new file mode 100644 index 00000000..d18b97e7 --- /dev/null +++ b/vrclient_x64/winIVRInput.c @@ -0,0 +1,230 @@ +/* This file is auto-generated, do not edit. */ +#include +#include + +#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); +} + diff --git a/vrclient_x64/win_constructors.h b/vrclient_x64/win_constructors.h index cc5c97ee..69416a3e 100644 --- a/vrclient_x64/win_constructors.h +++ b/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 *); diff --git a/vrclient_x64/win_constructors_table.dat b/vrclient_x64/win_constructors_table.dat index 95e3c7f2..c639315e 100644 --- a/vrclient_x64/win_constructors_table.dat +++ b/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}, diff --git a/vrclient_x64/win_destructors.h b/vrclient_x64/win_destructors.h index 5602922b..511262ca 100644 --- a/vrclient_x64/win_destructors.h +++ b/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 *);