suyu/Yucom
25
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

openvr: Support v1.4.18

Browse source
This commit is contained in:
Andrew Eikum 2019-06-28 14:27:56 -05:00
parent 27b0d4083d
commit 44f447e9a6
43 changed files with 6667 additions and 324 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
vrclient_x64/gen_wrapper.py
View file

@ -12,6 +12,7 @@ import os
import re
sdk_versions = [
"v1.4.18",
"v1.3.22",
"v1.2.10",
"v1.1.3b",

36
vrclient_x64/openvr_v1.4.18/ivrclientcore.h Normal file
View file

@ -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";
}

5046
vrclient_x64/openvr_v1.4.18/openvr.h Normal file
View file

File diff suppressed because it is too large Load diff

460
vrclient_x64/tests/capi_thunks_autogen.c
View file

@ -900,6 +900,11 @@ void __thiscall IVRChaperoneSetup_006_HideWorkingSetPreview(void *_this)
push_ptr_parameter(_this);
}
void __thiscall IVRChaperoneSetup_006_RoomSetupStarting(void *_this)
{
push_ptr_parameter(_this);
}
void __thiscall IVRCompositor_022_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
{
push_ptr_parameter(_this);
@ -1197,6 +1202,18 @@ bool __thiscall IVRCompositor_022_IsMotionSmoothingEnabled(void *_this)
return 0;
}
bool __thiscall IVRCompositor_022_IsMotionSmoothingSupported(void *_this)
{
push_ptr_parameter(_this);
return 0;
}
bool __thiscall IVRCompositor_022_IsCurrentSceneFocusAppLoading(void *_this)
{
push_ptr_parameter(_this);
return 0;
}
EVRNotificationError __thiscall IVRNotifications_002_CreateNotification(void *_this, VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char * pchText, EVRNotificationStyle style, NotificationBitmap_t * pImage, VRNotificationId * pNotificationId)
{
push_ptr_parameter(_this);
@ -2319,6 +2336,350 @@ DriverHandle_t __thiscall IVRDriverManager_001_GetDriverHandle(void *_this, cons
return 0;
}
EVRInputError __thiscall IVRInput_006_SetActionManifestPath(void *_this, const char * pchActionManifestPath)
{
push_ptr_parameter(_this);
push_ptr_parameter(pchActionManifestPath);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetActionSetHandle(void *_this, const char * pchActionSetName, VRActionSetHandle_t * pHandle)
{
push_ptr_parameter(_this);
push_ptr_parameter(pchActionSetName);
push_ptr_parameter(pHandle);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetActionHandle(void *_this, const char * pchActionName, VRActionHandle_t * pHandle)
{
push_ptr_parameter(_this);
push_ptr_parameter(pchActionName);
push_ptr_parameter(pHandle);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetInputSourceHandle(void *_this, const char * pchInputSourcePath, VRInputValueHandle_t * pHandle)
{
push_ptr_parameter(_this);
push_ptr_parameter(pchInputSourcePath);
push_ptr_parameter(pHandle);
return 0;
}
EVRInputError __thiscall IVRInput_006_UpdateActionState(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount)
{
push_ptr_parameter(_this);
push_ptr_parameter(pSets);
push_uint32_parameter(unSizeOfVRSelectedActionSet_t);
push_uint32_parameter(unSetCount);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetDigitalActionData(void *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
push_ptr_parameter(_this);
push_uint64_parameter(action);
push_ptr_parameter(pActionData);
push_uint32_parameter(unActionDataSize);
push_uint64_parameter(ulRestrictToDevice);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetAnalogActionData(void *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
push_ptr_parameter(_this);
push_uint64_parameter(action);
push_ptr_parameter(pActionData);
push_uint32_parameter(unActionDataSize);
push_uint64_parameter(ulRestrictToDevice);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetPoseActionDataRelativeToNow(void *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
push_ptr_parameter(_this);
push_uint64_parameter(action);
push_uint32_parameter(eOrigin);
push_float_parameter(fPredictedSecondsFromNow);
push_ptr_parameter(pActionData);
push_uint32_parameter(unActionDataSize);
push_uint64_parameter(ulRestrictToDevice);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetPoseActionDataForNextFrame(void *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
push_ptr_parameter(_this);
push_uint64_parameter(action);
push_uint32_parameter(eOrigin);
push_ptr_parameter(pActionData);
push_uint32_parameter(unActionDataSize);
push_uint64_parameter(ulRestrictToDevice);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetSkeletalActionData(void *_this, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize)
{
push_ptr_parameter(_this);
push_uint64_parameter(action);
push_ptr_parameter(pActionData);
push_uint32_parameter(unActionDataSize);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetBoneCount(void *_this, VRActionHandle_t action, uint32_t * pBoneCount)
{
push_ptr_parameter(_this);
push_uint64_parameter(action);
push_ptr_parameter(pBoneCount);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetBoneHierarchy(void *_this, VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount)
{
push_ptr_parameter(_this);
push_uint64_parameter(action);
push_ptr_parameter(pParentIndices);
push_uint32_parameter(unIndexArayCount);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetBoneName(void *_this, VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize)
{
push_ptr_parameter(_this);
push_uint64_parameter(action);
push_uint32_parameter(nBoneIndex);
push_ptr_parameter(pchBoneName);
push_uint32_parameter(unNameBufferSize);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetSkeletalReferenceTransforms(void *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
{
push_ptr_parameter(_this);
push_uint64_parameter(action);
push_uint32_parameter(eTransformSpace);
push_uint32_parameter(eReferencePose);
push_ptr_parameter(pTransformArray);
push_uint32_parameter(unTransformArrayCount);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetSkeletalTrackingLevel(void *_this, VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel)
{
push_ptr_parameter(_this);
push_uint64_parameter(action);
push_ptr_parameter(pSkeletalTrackingLevel);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetSkeletalBoneData(void *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
{
push_ptr_parameter(_this);
push_uint64_parameter(action);
push_uint32_parameter(eTransformSpace);
push_uint32_parameter(eMotionRange);
push_ptr_parameter(pTransformArray);
push_uint32_parameter(unTransformArrayCount);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetSkeletalSummaryData(void *_this, VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData)
{
push_ptr_parameter(_this);
push_uint64_parameter(action);
push_uint32_parameter(eSummaryType);
push_ptr_parameter(pSkeletalSummaryData);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetSkeletalBoneDataCompressed(void *_this, VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize)
{
push_ptr_parameter(_this);
push_uint64_parameter(action);
push_uint32_parameter(eMotionRange);
push_ptr_parameter(pvCompressedData);
push_uint32_parameter(unCompressedSize);
push_ptr_parameter(punRequiredCompressedSize);
return 0;
}
EVRInputError __thiscall IVRInput_006_DecompressSkeletalBoneData(void *_this, const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
{
push_ptr_parameter(_this);
push_ptr_parameter(pvCompressedBuffer);
push_uint32_parameter(unCompressedBufferSize);
push_uint32_parameter(eTransformSpace);
push_ptr_parameter(pTransformArray);
push_uint32_parameter(unTransformArrayCount);
return 0;
}
EVRInputError __thiscall IVRInput_006_TriggerHapticVibrationAction(void *_this, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice)
{
push_ptr_parameter(_this);
push_uint64_parameter(action);
push_float_parameter(fStartSecondsFromNow);
push_float_parameter(fDurationSeconds);
push_float_parameter(fFrequency);
push_float_parameter(fAmplitude);
push_uint64_parameter(ulRestrictToDevice);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetActionOrigins(void *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount)
{
push_ptr_parameter(_this);
push_uint64_parameter(actionSetHandle);
push_uint64_parameter(digitalActionHandle);
push_ptr_parameter(originsOut);
push_uint32_parameter(originOutCount);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetOriginLocalizedName(void *_this, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude)
{
push_ptr_parameter(_this);
push_uint64_parameter(origin);
push_ptr_parameter(pchNameArray);
push_uint32_parameter(unNameArraySize);
push_uint32_parameter(unStringSectionsToInclude);
return 0;
}
EVRInputError __thiscall IVRInput_006_GetOriginTrackedDeviceInfo(void *_this, VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize)
{
push_ptr_parameter(_this);
push_uint64_parameter(origin);
push_ptr_parameter(pOriginInfo);
push_uint32_parameter(unOriginInfoSize);
return 0;
}
EVRInputError __thiscall IVRInput_006_ShowActionOrigins(void *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle)
{
push_ptr_parameter(_this);
push_uint64_parameter(actionSetHandle);
push_uint64_parameter(ulActionHandle);
return 0;
}
EVRInputError __thiscall IVRInput_006_ShowBindingsForActionSet(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight)
{
push_ptr_parameter(_this);
push_ptr_parameter(pSets);
push_uint32_parameter(unSizeOfVRSelectedActionSet_t);
push_uint32_parameter(unSetCount);
push_uint64_parameter(originToHighlight);
return 0;
}
bool __thiscall IVRInput_006_IsUsingLegacyInput(void *_this)
{
push_ptr_parameter(_this);
return 0;
}
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);
push_uint32_parameter(mode);
push_uint32_parameter(unElementSize);
push_uint32_parameter(unElements);
push_ptr_parameter(pulBuffer);
return 0;
}
EIOBufferError __thiscall IVRIOBuffer_002_Close(void *_this, IOBufferHandle_t ulBuffer)
{
push_ptr_parameter(_this);
push_uint64_parameter(ulBuffer);
return 0;
}
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);
push_ptr_parameter(pDst);
push_uint32_parameter(unBytes);
push_ptr_parameter(punRead);
return 0;
}
EIOBufferError __thiscall IVRIOBuffer_002_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_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);
return 0;
}
EVRInitError __thiscall IVRClientCore_003_Init(void *_this, EVRApplicationType eApplicationType, const char * pStartupInfo)
{
push_ptr_parameter(_this);
push_uint32_parameter(eApplicationType);
push_ptr_parameter(pStartupInfo);
return 0;
}
void __thiscall IVRClientCore_003_Cleanup(void *_this)
{
push_ptr_parameter(_this);
}
EVRInitError __thiscall IVRClientCore_003_IsInterfaceVersionValid(void *_this, const char * pchInterfaceVersion)
{
push_ptr_parameter(_this);
push_ptr_parameter(pchInterfaceVersion);
return 0;
}
void * __thiscall IVRClientCore_003_GetGenericInterface(void *_this, const char * pchNameAndVersion, EVRInitError * peError)
{
push_ptr_parameter(_this);
push_ptr_parameter(pchNameAndVersion);
push_ptr_parameter(peError);
return 0;
}
bool __thiscall IVRClientCore_003_BIsHmdPresent(void *_this)
{
push_ptr_parameter(_this);
return 0;
}
const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_this, EVRInitError eError)
{
push_ptr_parameter(_this);
push_uint32_parameter(eError);
return 0;
}
const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError)
{
push_ptr_parameter(_this);
push_uint32_parameter(eError);
return 0;
}
EVRInputError __thiscall IVRInput_005_SetActionManifestPath(void *_this, const char * pchActionManifestPath)
{
push_ptr_parameter(_this);
@ -2552,105 +2913,6 @@ bool __thiscall IVRInput_005_IsUsingLegacyInput(void *_this)
return 0;
}
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);
push_uint32_parameter(mode);
push_uint32_parameter(unElementSize);
push_uint32_parameter(unElements);
push_ptr_parameter(pulBuffer);
return 0;
}
EIOBufferError __thiscall IVRIOBuffer_002_Close(void *_this, IOBufferHandle_t ulBuffer)
{
push_ptr_parameter(_this);
push_uint64_parameter(ulBuffer);
return 0;
}
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);
push_ptr_parameter(pDst);
push_uint32_parameter(unBytes);
push_ptr_parameter(punRead);
return 0;
}
EIOBufferError __thiscall IVRIOBuffer_002_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_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);
return 0;
}
EVRInitError __thiscall IVRClientCore_003_Init(void *_this, EVRApplicationType eApplicationType, const char * pStartupInfo)
{
push_ptr_parameter(_this);
push_uint32_parameter(eApplicationType);
push_ptr_parameter(pStartupInfo);
return 0;
}
void __thiscall IVRClientCore_003_Cleanup(void *_this)
{
push_ptr_parameter(_this);
}
EVRInitError __thiscall IVRClientCore_003_IsInterfaceVersionValid(void *_this, const char * pchInterfaceVersion)
{
push_ptr_parameter(_this);
push_ptr_parameter(pchInterfaceVersion);
return 0;
}
void * __thiscall IVRClientCore_003_GetGenericInterface(void *_this, const char * pchNameAndVersion, EVRInitError * peError)
{
push_ptr_parameter(_this);
push_ptr_parameter(pchNameAndVersion);
push_ptr_parameter(peError);
return 0;
}
bool __thiscall IVRClientCore_003_BIsHmdPresent(void *_this)
{
push_ptr_parameter(_this);
return 0;
}
const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_this, EVRInitError eError)
{
push_ptr_parameter(_this);
push_uint32_parameter(eError);
return 0;
}
const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError)
{
push_ptr_parameter(_this);
push_uint32_parameter(eError);
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);

120
vrclient_x64/tests/capi_thunks_autogen.h
View file

@ -255,6 +255,8 @@ void __thiscall IVRChaperoneSetup_006_ShowWorkingSetPreview(void *_this);
void __thiscall IVRChaperoneSetup_006_HideWorkingSetPreview(void *_this);
void __thiscall IVRChaperoneSetup_006_RoomSetupStarting(void *_this);
void test_capi_thunks_IVRCompositor_022(void);
void __thiscall IVRCompositor_022_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
@ -345,6 +347,10 @@ EVRCompositorError __thiscall IVRCompositor_022_SubmitExplicitTimingData(void *_
bool __thiscall IVRCompositor_022_IsMotionSmoothingEnabled(void *_this);
bool __thiscall IVRCompositor_022_IsMotionSmoothingSupported(void *_this);
bool __thiscall IVRCompositor_022_IsCurrentSceneFocusAppLoading(void *_this);
void test_capi_thunks_IVRNotifications_002(void);
EVRNotificationError __thiscall IVRNotifications_002_CreateNotification(void *_this, VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char * pchText, EVRNotificationStyle style, NotificationBitmap_t * pImage, VRNotificationId * pNotificationId);
@ -621,6 +627,90 @@ uint32_t __thiscall IVRDriverManager_001_GetDriverName(void *_this, DriverId_t n
DriverHandle_t __thiscall IVRDriverManager_001_GetDriverHandle(void *_this, const char * pchDriverName);
void test_capi_thunks_IVRInput_006(void);
EVRInputError __thiscall IVRInput_006_SetActionManifestPath(void *_this, const char * pchActionManifestPath);
EVRInputError __thiscall IVRInput_006_GetActionSetHandle(void *_this, const char * pchActionSetName, VRActionSetHandle_t * pHandle);
EVRInputError __thiscall IVRInput_006_GetActionHandle(void *_this, const char * pchActionName, VRActionHandle_t * pHandle);
EVRInputError __thiscall IVRInput_006_GetInputSourceHandle(void *_this, const char * pchInputSourcePath, VRInputValueHandle_t * pHandle);
EVRInputError __thiscall IVRInput_006_UpdateActionState(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount);
EVRInputError __thiscall IVRInput_006_GetDigitalActionData(void *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
EVRInputError __thiscall IVRInput_006_GetAnalogActionData(void *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
EVRInputError __thiscall IVRInput_006_GetPoseActionDataRelativeToNow(void *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
EVRInputError __thiscall IVRInput_006_GetPoseActionDataForNextFrame(void *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
EVRInputError __thiscall IVRInput_006_GetSkeletalActionData(void *_this, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize);
EVRInputError __thiscall IVRInput_006_GetBoneCount(void *_this, VRActionHandle_t action, uint32_t * pBoneCount);
EVRInputError __thiscall IVRInput_006_GetBoneHierarchy(void *_this, VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount);
EVRInputError __thiscall IVRInput_006_GetBoneName(void *_this, VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize);
EVRInputError __thiscall IVRInput_006_GetSkeletalReferenceTransforms(void *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
EVRInputError __thiscall IVRInput_006_GetSkeletalTrackingLevel(void *_this, VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel);
EVRInputError __thiscall IVRInput_006_GetSkeletalBoneData(void *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
EVRInputError __thiscall IVRInput_006_GetSkeletalSummaryData(void *_this, VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData);
EVRInputError __thiscall IVRInput_006_GetSkeletalBoneDataCompressed(void *_this, VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize);
EVRInputError __thiscall IVRInput_006_DecompressSkeletalBoneData(void *_this, const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
EVRInputError __thiscall IVRInput_006_TriggerHapticVibrationAction(void *_this, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice);
EVRInputError __thiscall IVRInput_006_GetActionOrigins(void *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount);
EVRInputError __thiscall IVRInput_006_GetOriginLocalizedName(void *_this, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude);
EVRInputError __thiscall IVRInput_006_GetOriginTrackedDeviceInfo(void *_this, VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize);
EVRInputError __thiscall IVRInput_006_ShowActionOrigins(void *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle);
EVRInputError __thiscall IVRInput_006_ShowBindingsForActionSet(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight);
bool __thiscall IVRInput_006_IsUsingLegacyInput(void *_this);
void test_capi_thunks_IVRIOBuffer_002(void);
EIOBufferError __thiscall IVRIOBuffer_002_Open(void *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer);
EIOBufferError __thiscall IVRIOBuffer_002_Close(void *_this, IOBufferHandle_t ulBuffer);
EIOBufferError __thiscall IVRIOBuffer_002_Read(void *_this, IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead);
EIOBufferError __thiscall IVRIOBuffer_002_Write(void *_this, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes);
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);
EVRInitError __thiscall IVRClientCore_003_Init(void *_this, EVRApplicationType eApplicationType, const char * pStartupInfo);
void __thiscall IVRClientCore_003_Cleanup(void *_this);
EVRInitError __thiscall IVRClientCore_003_IsInterfaceVersionValid(void *_this, const char * pchInterfaceVersion);
void * __thiscall IVRClientCore_003_GetGenericInterface(void *_this, const char * pchNameAndVersion, EVRInitError * peError);
bool __thiscall IVRClientCore_003_BIsHmdPresent(void *_this);
const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_this, EVRInitError eError);
const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError);
void test_capi_thunks_IVRInput_005(void);
EVRInputError __thiscall IVRInput_005_SetActionManifestPath(void *_this, const char * pchActionManifestPath);
@ -673,36 +763,6 @@ EVRInputError __thiscall IVRInput_005_ShowBindingsForActionSet(void *_this, VRAc
bool __thiscall IVRInput_005_IsUsingLegacyInput(void *_this);
void test_capi_thunks_IVRIOBuffer_002(void);
EIOBufferError __thiscall IVRIOBuffer_002_Open(void *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer);
EIOBufferError __thiscall IVRIOBuffer_002_Close(void *_this, IOBufferHandle_t ulBuffer);
EIOBufferError __thiscall IVRIOBuffer_002_Read(void *_this, IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead);
EIOBufferError __thiscall IVRIOBuffer_002_Write(void *_this, IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes);
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);
EVRInitError __thiscall IVRClientCore_003_Init(void *_this, EVRApplicationType eApplicationType, const char * pStartupInfo);
void __thiscall IVRClientCore_003_Cleanup(void *_this);
EVRInitError __thiscall IVRClientCore_003_IsInterfaceVersionValid(void *_this, const char * pchInterfaceVersion);
void * __thiscall IVRClientCore_003_GetGenericInterface(void *_this, const char * pchNameAndVersion, EVRInitError * peError);
bool __thiscall IVRClientCore_003_BIsHmdPresent(void *_this);
const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_this, EVRInitError eError);
const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError);
void test_capi_thunks_IVRIOBuffer_001(void);
EIOBufferError __thiscall IVRIOBuffer_001_Open(void *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer);

548
vrclient_x64/tests/capi_thunks_tests_autogen.c
View file

@ -1074,6 +1074,13 @@ void test_capi_thunks_IVRChaperoneSetup_006(void)
clear_parameters();
capi_IVRChaperoneSetup_006_HideWorkingSetPreview();
check_ptr_parameter("IVRChaperoneSetup_006_HideWorkingSetPreview", this_ptr_value);
init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_RoomSetupStarting, 0, FALSE, FALSE);
void (__stdcall *capi_IVRChaperoneSetup_006_RoomSetupStarting)() = (void *)t;
clear_parameters();
capi_IVRChaperoneSetup_006_RoomSetupStarting();
check_ptr_parameter("IVRChaperoneSetup_006_RoomSetupStarting", this_ptr_value);
VirtualFree(t, 0, MEM_RELEASE);
}
@ -1441,6 +1448,20 @@ void test_capi_thunks_IVRCompositor_022(void)
clear_parameters();
capi_IVRCompositor_022_IsMotionSmoothingEnabled();
check_ptr_parameter("IVRCompositor_022_IsMotionSmoothingEnabled", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_022_IsMotionSmoothingSupported, 0, FALSE, FALSE);
bool (__stdcall *capi_IVRCompositor_022_IsMotionSmoothingSupported)() = (void *)t;
clear_parameters();
capi_IVRCompositor_022_IsMotionSmoothingSupported();
check_ptr_parameter("IVRCompositor_022_IsMotionSmoothingSupported", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_022_IsCurrentSceneFocusAppLoading, 0, FALSE, FALSE);
bool (__stdcall *capi_IVRCompositor_022_IsCurrentSceneFocusAppLoading)() = (void *)t;
clear_parameters();
capi_IVRCompositor_022_IsCurrentSceneFocusAppLoading();
check_ptr_parameter("IVRCompositor_022_IsCurrentSceneFocusAppLoading", this_ptr_value);
VirtualFree(t, 0, MEM_RELEASE);
}
@ -2755,6 +2776,408 @@ void test_capi_thunks_IVRDriverManager_001(void)
VirtualFree(t, 0, MEM_RELEASE);
}
void test_capi_thunks_IVRInput_006(void)
{
struct thunk *t = alloc_thunks(1);
init_thunk(t, this_ptr_value, IVRInput_006_SetActionManifestPath, 1, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_SetActionManifestPath)(const char * pchActionManifestPath) = (void *)t;
clear_parameters();
capi_IVRInput_006_SetActionManifestPath((void *)1);
check_ptr_parameter("IVRInput_006_SetActionManifestPath", this_ptr_value);
check_ptr_parameter("IVRInput_006_SetActionManifestPath", (void *)1);
init_thunk(t, this_ptr_value, IVRInput_006_GetActionSetHandle, 2, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetActionSetHandle)(const char * pchActionSetName, VRActionSetHandle_t * pHandle) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetActionSetHandle((void *)1, (void *)2);
check_ptr_parameter("IVRInput_006_GetActionSetHandle", this_ptr_value);
check_ptr_parameter("IVRInput_006_GetActionSetHandle", (void *)1);
check_ptr_parameter("IVRInput_006_GetActionSetHandle", (void *)2);
init_thunk(t, this_ptr_value, IVRInput_006_GetActionHandle, 2, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetActionHandle)(const char * pchActionName, VRActionHandle_t * pHandle) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetActionHandle((void *)1, (void *)2);
check_ptr_parameter("IVRInput_006_GetActionHandle", this_ptr_value);
check_ptr_parameter("IVRInput_006_GetActionHandle", (void *)1);
check_ptr_parameter("IVRInput_006_GetActionHandle", (void *)2);
init_thunk(t, this_ptr_value, IVRInput_006_GetInputSourceHandle, 2, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetInputSourceHandle)(const char * pchInputSourcePath, VRInputValueHandle_t * pHandle) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetInputSourceHandle((void *)1, (void *)2);
check_ptr_parameter("IVRInput_006_GetInputSourceHandle", this_ptr_value);
check_ptr_parameter("IVRInput_006_GetInputSourceHandle", (void *)1);
check_ptr_parameter("IVRInput_006_GetInputSourceHandle", (void *)2);
init_thunk(t, this_ptr_value, IVRInput_006_UpdateActionState, 3, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_UpdateActionState)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount) = (void *)t;
clear_parameters();
capi_IVRInput_006_UpdateActionState((void *)1, 2, 3);
check_ptr_parameter("IVRInput_006_UpdateActionState", this_ptr_value);
check_ptr_parameter("IVRInput_006_UpdateActionState", (void *)1);
check_uint32_parameter("IVRInput_006_UpdateActionState", 2);
check_uint32_parameter("IVRInput_006_UpdateActionState", 3);
init_thunk(t, this_ptr_value, IVRInput_006_GetDigitalActionData, 4, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetDigitalActionData)(VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetDigitalActionData(1, (void *)2, 3, 4);
check_ptr_parameter("IVRInput_006_GetDigitalActionData", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetDigitalActionData", 1);
check_ptr_parameter("IVRInput_006_GetDigitalActionData", (void *)2);
check_uint32_parameter("IVRInput_006_GetDigitalActionData", 3);
check_uint64_parameter("IVRInput_006_GetDigitalActionData", 4);
init_thunk(t, this_ptr_value, IVRInput_006_GetAnalogActionData, 4, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetAnalogActionData)(VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetAnalogActionData(1, (void *)2, 3, 4);
check_ptr_parameter("IVRInput_006_GetAnalogActionData", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetAnalogActionData", 1);
check_ptr_parameter("IVRInput_006_GetAnalogActionData", (void *)2);
check_uint32_parameter("IVRInput_006_GetAnalogActionData", 3);
check_uint64_parameter("IVRInput_006_GetAnalogActionData", 4);
init_thunk(t, this_ptr_value, IVRInput_006_GetPoseActionDataRelativeToNow, 6, TRUE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetPoseActionDataRelativeToNow)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetPoseActionDataRelativeToNow(1, 2, 3.0f, (void *)4, 5, 6);
check_ptr_parameter("IVRInput_006_GetPoseActionDataRelativeToNow", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetPoseActionDataRelativeToNow", 1);
check_uint32_parameter("IVRInput_006_GetPoseActionDataRelativeToNow", 2);
check_float_parameter("IVRInput_006_GetPoseActionDataRelativeToNow", 3.0f);
check_ptr_parameter("IVRInput_006_GetPoseActionDataRelativeToNow", (void *)4);
check_uint32_parameter("IVRInput_006_GetPoseActionDataRelativeToNow", 5);
check_uint64_parameter("IVRInput_006_GetPoseActionDataRelativeToNow", 6);
init_thunk(t, this_ptr_value, IVRInput_006_GetPoseActionDataForNextFrame, 5, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetPoseActionDataForNextFrame)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetPoseActionDataForNextFrame(1, 2, (void *)3, 4, 5);
check_ptr_parameter("IVRInput_006_GetPoseActionDataForNextFrame", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetPoseActionDataForNextFrame", 1);
check_uint32_parameter("IVRInput_006_GetPoseActionDataForNextFrame", 2);
check_ptr_parameter("IVRInput_006_GetPoseActionDataForNextFrame", (void *)3);
check_uint32_parameter("IVRInput_006_GetPoseActionDataForNextFrame", 4);
check_uint64_parameter("IVRInput_006_GetPoseActionDataForNextFrame", 5);
init_thunk(t, this_ptr_value, IVRInput_006_GetSkeletalActionData, 3, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetSkeletalActionData)(VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetSkeletalActionData(1, (void *)2, 3);
check_ptr_parameter("IVRInput_006_GetSkeletalActionData", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetSkeletalActionData", 1);
check_ptr_parameter("IVRInput_006_GetSkeletalActionData", (void *)2);
check_uint32_parameter("IVRInput_006_GetSkeletalActionData", 3);
init_thunk(t, this_ptr_value, IVRInput_006_GetBoneCount, 2, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetBoneCount)(VRActionHandle_t action, uint32_t * pBoneCount) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetBoneCount(1, (void *)2);
check_ptr_parameter("IVRInput_006_GetBoneCount", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetBoneCount", 1);
check_ptr_parameter("IVRInput_006_GetBoneCount", (void *)2);
init_thunk(t, this_ptr_value, IVRInput_006_GetBoneHierarchy, 3, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetBoneHierarchy)(VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetBoneHierarchy(1, (void *)2, 3);
check_ptr_parameter("IVRInput_006_GetBoneHierarchy", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetBoneHierarchy", 1);
check_ptr_parameter("IVRInput_006_GetBoneHierarchy", (void *)2);
check_uint32_parameter("IVRInput_006_GetBoneHierarchy", 3);
init_thunk(t, this_ptr_value, IVRInput_006_GetBoneName, 4, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetBoneName)(VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetBoneName(1, 2, (void *)3, 4);
check_ptr_parameter("IVRInput_006_GetBoneName", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetBoneName", 1);
check_uint32_parameter("IVRInput_006_GetBoneName", 2);
check_ptr_parameter("IVRInput_006_GetBoneName", (void *)3);
check_uint32_parameter("IVRInput_006_GetBoneName", 4);
init_thunk(t, this_ptr_value, IVRInput_006_GetSkeletalReferenceTransforms, 5, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetSkeletalReferenceTransforms)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetSkeletalReferenceTransforms(1, 2, 3, (void *)4, 5);
check_ptr_parameter("IVRInput_006_GetSkeletalReferenceTransforms", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetSkeletalReferenceTransforms", 1);
check_uint32_parameter("IVRInput_006_GetSkeletalReferenceTransforms", 2);
check_uint32_parameter("IVRInput_006_GetSkeletalReferenceTransforms", 3);
check_ptr_parameter("IVRInput_006_GetSkeletalReferenceTransforms", (void *)4);
check_uint32_parameter("IVRInput_006_GetSkeletalReferenceTransforms", 5);
init_thunk(t, this_ptr_value, IVRInput_006_GetSkeletalTrackingLevel, 2, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetSkeletalTrackingLevel)(VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetSkeletalTrackingLevel(1, (void *)2);
check_ptr_parameter("IVRInput_006_GetSkeletalTrackingLevel", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetSkeletalTrackingLevel", 1);
check_ptr_parameter("IVRInput_006_GetSkeletalTrackingLevel", (void *)2);
init_thunk(t, this_ptr_value, IVRInput_006_GetSkeletalBoneData, 5, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetSkeletalBoneData)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetSkeletalBoneData(1, 2, 3, (void *)4, 5);
check_ptr_parameter("IVRInput_006_GetSkeletalBoneData", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetSkeletalBoneData", 1);
check_uint32_parameter("IVRInput_006_GetSkeletalBoneData", 2);
check_uint32_parameter("IVRInput_006_GetSkeletalBoneData", 3);
check_ptr_parameter("IVRInput_006_GetSkeletalBoneData", (void *)4);
check_uint32_parameter("IVRInput_006_GetSkeletalBoneData", 5);
init_thunk(t, this_ptr_value, IVRInput_006_GetSkeletalSummaryData, 3, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetSkeletalSummaryData)(VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetSkeletalSummaryData(1, 2, (void *)3);
check_ptr_parameter("IVRInput_006_GetSkeletalSummaryData", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetSkeletalSummaryData", 1);
check_uint32_parameter("IVRInput_006_GetSkeletalSummaryData", 2);
check_ptr_parameter("IVRInput_006_GetSkeletalSummaryData", (void *)3);
init_thunk(t, this_ptr_value, IVRInput_006_GetSkeletalBoneDataCompressed, 5, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetSkeletalBoneDataCompressed)(VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetSkeletalBoneDataCompressed(1, 2, (void *)3, 4, (void *)5);
check_ptr_parameter("IVRInput_006_GetSkeletalBoneDataCompressed", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetSkeletalBoneDataCompressed", 1);
check_uint32_parameter("IVRInput_006_GetSkeletalBoneDataCompressed", 2);
check_ptr_parameter("IVRInput_006_GetSkeletalBoneDataCompressed", (void *)3);
check_uint32_parameter("IVRInput_006_GetSkeletalBoneDataCompressed", 4);
check_ptr_parameter("IVRInput_006_GetSkeletalBoneDataCompressed", (void *)5);
init_thunk(t, this_ptr_value, IVRInput_006_DecompressSkeletalBoneData, 5, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_DecompressSkeletalBoneData)(const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;
clear_parameters();
capi_IVRInput_006_DecompressSkeletalBoneData((void *)1, 2, 3, (void *)4, 5);
check_ptr_parameter("IVRInput_006_DecompressSkeletalBoneData", this_ptr_value);
check_ptr_parameter("IVRInput_006_DecompressSkeletalBoneData", (void *)1);
check_uint32_parameter("IVRInput_006_DecompressSkeletalBoneData", 2);
check_uint32_parameter("IVRInput_006_DecompressSkeletalBoneData", 3);
check_ptr_parameter("IVRInput_006_DecompressSkeletalBoneData", (void *)4);
check_uint32_parameter("IVRInput_006_DecompressSkeletalBoneData", 5);
init_thunk(t, this_ptr_value, IVRInput_006_TriggerHapticVibrationAction, 6, TRUE, TRUE);
EVRInputError (__stdcall *capi_IVRInput_006_TriggerHapticVibrationAction)(VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;
clear_parameters();
capi_IVRInput_006_TriggerHapticVibrationAction(1, 2.0f, 3.0f, 4.0f, 5.0f, 6);
check_ptr_parameter("IVRInput_006_TriggerHapticVibrationAction", this_ptr_value);
check_uint64_parameter("IVRInput_006_TriggerHapticVibrationAction", 1);
check_float_parameter("IVRInput_006_TriggerHapticVibrationAction", 2.0f);
check_float_parameter("IVRInput_006_TriggerHapticVibrationAction", 3.0f);
check_float_parameter("IVRInput_006_TriggerHapticVibrationAction", 4.0f);
check_float_parameter("IVRInput_006_TriggerHapticVibrationAction", 5.0f);
check_uint64_parameter("IVRInput_006_TriggerHapticVibrationAction", 6);
init_thunk(t, this_ptr_value, IVRInput_006_GetActionOrigins, 4, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetActionOrigins(1, 2, (void *)3, 4);
check_ptr_parameter("IVRInput_006_GetActionOrigins", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetActionOrigins", 1);
check_uint64_parameter("IVRInput_006_GetActionOrigins", 2);
check_ptr_parameter("IVRInput_006_GetActionOrigins", (void *)3);
check_uint32_parameter("IVRInput_006_GetActionOrigins", 4);
init_thunk(t, this_ptr_value, IVRInput_006_GetOriginLocalizedName, 4, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetOriginLocalizedName)(VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetOriginLocalizedName(1, (void *)2, 3, 4);
check_ptr_parameter("IVRInput_006_GetOriginLocalizedName", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetOriginLocalizedName", 1);
check_ptr_parameter("IVRInput_006_GetOriginLocalizedName", (void *)2);
check_uint32_parameter("IVRInput_006_GetOriginLocalizedName", 3);
check_uint32_parameter("IVRInput_006_GetOriginLocalizedName", 4);
init_thunk(t, this_ptr_value, IVRInput_006_GetOriginTrackedDeviceInfo, 3, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_GetOriginTrackedDeviceInfo)(VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize) = (void *)t;
clear_parameters();
capi_IVRInput_006_GetOriginTrackedDeviceInfo(1, (void *)2, 3);
check_ptr_parameter("IVRInput_006_GetOriginTrackedDeviceInfo", this_ptr_value);
check_uint64_parameter("IVRInput_006_GetOriginTrackedDeviceInfo", 1);
check_ptr_parameter("IVRInput_006_GetOriginTrackedDeviceInfo", (void *)2);
check_uint32_parameter("IVRInput_006_GetOriginTrackedDeviceInfo", 3);
init_thunk(t, this_ptr_value, IVRInput_006_ShowActionOrigins, 2, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_ShowActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle) = (void *)t;
clear_parameters();
capi_IVRInput_006_ShowActionOrigins(1, 2);
check_ptr_parameter("IVRInput_006_ShowActionOrigins", this_ptr_value);
check_uint64_parameter("IVRInput_006_ShowActionOrigins", 1);
check_uint64_parameter("IVRInput_006_ShowActionOrigins", 2);
init_thunk(t, this_ptr_value, IVRInput_006_ShowBindingsForActionSet, 4, FALSE, FALSE);
EVRInputError (__stdcall *capi_IVRInput_006_ShowBindingsForActionSet)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight) = (void *)t;
clear_parameters();
capi_IVRInput_006_ShowBindingsForActionSet((void *)1, 2, 3, 4);
check_ptr_parameter("IVRInput_006_ShowBindingsForActionSet", this_ptr_value);
check_ptr_parameter("IVRInput_006_ShowBindingsForActionSet", (void *)1);
check_uint32_parameter("IVRInput_006_ShowBindingsForActionSet", 2);
check_uint32_parameter("IVRInput_006_ShowBindingsForActionSet", 3);
check_uint64_parameter("IVRInput_006_ShowBindingsForActionSet", 4);
init_thunk(t, this_ptr_value, IVRInput_006_IsUsingLegacyInput, 0, FALSE, FALSE);
bool (__stdcall *capi_IVRInput_006_IsUsingLegacyInput)() = (void *)t;
clear_parameters();
capi_IVRInput_006_IsUsingLegacyInput();
check_ptr_parameter("IVRInput_006_IsUsingLegacyInput", this_ptr_value);
VirtualFree(t, 0, MEM_RELEASE);
}
void test_capi_thunks_IVRIOBuffer_002(void)
{
struct thunk *t = alloc_thunks(1);
init_thunk(t, this_ptr_value, IVRIOBuffer_002_Open, 5, FALSE, FALSE);
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_002_Open((void *)1, 2, 3, 4, (void *)5);
check_ptr_parameter("IVRIOBuffer_002_Open", this_ptr_value);
check_ptr_parameter("IVRIOBuffer_002_Open", (void *)1);
check_uint32_parameter("IVRIOBuffer_002_Open", 2);
check_uint32_parameter("IVRIOBuffer_002_Open", 3);
check_uint32_parameter("IVRIOBuffer_002_Open", 4);
check_ptr_parameter("IVRIOBuffer_002_Open", (void *)5);
init_thunk(t, this_ptr_value, IVRIOBuffer_002_Close, 1, FALSE, FALSE);
EIOBufferError (__stdcall *capi_IVRIOBuffer_002_Close)(IOBufferHandle_t ulBuffer) = (void *)t;
clear_parameters();
capi_IVRIOBuffer_002_Close(1);
check_ptr_parameter("IVRIOBuffer_002_Close", this_ptr_value);
check_uint64_parameter("IVRIOBuffer_002_Close", 1);
init_thunk(t, this_ptr_value, IVRIOBuffer_002_Read, 4, FALSE, FALSE);
EIOBufferError (__stdcall *capi_IVRIOBuffer_002_Read)(IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead) = (void *)t;
clear_parameters();
capi_IVRIOBuffer_002_Read(1, (void *)2, 3, (void *)4);
check_ptr_parameter("IVRIOBuffer_002_Read", this_ptr_value);
check_uint64_parameter("IVRIOBuffer_002_Read", 1);
check_ptr_parameter("IVRIOBuffer_002_Read", (void *)2);
check_uint32_parameter("IVRIOBuffer_002_Read", 3);
check_ptr_parameter("IVRIOBuffer_002_Read", (void *)4);
init_thunk(t, this_ptr_value, IVRIOBuffer_002_Write, 3, FALSE, FALSE);
EIOBufferError (__stdcall *capi_IVRIOBuffer_002_Write)(IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes) = (void *)t;
clear_parameters();
capi_IVRIOBuffer_002_Write(1, (void *)2, 3);
check_ptr_parameter("IVRIOBuffer_002_Write", this_ptr_value);
check_uint64_parameter("IVRIOBuffer_002_Write", 1);
check_ptr_parameter("IVRIOBuffer_002_Write", (void *)2);
check_uint32_parameter("IVRIOBuffer_002_Write", 3);
init_thunk(t, this_ptr_value, IVRIOBuffer_002_PropertyContainer, 1, FALSE, FALSE);
PropertyContainerHandle_t (__stdcall *capi_IVRIOBuffer_002_PropertyContainer)(IOBufferHandle_t ulBuffer) = (void *)t;
clear_parameters();
capi_IVRIOBuffer_002_PropertyContainer(1);
check_ptr_parameter("IVRIOBuffer_002_PropertyContainer", this_ptr_value);
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);
}
void test_capi_thunks_IVRClientCore_003(void)
{
struct thunk *t = alloc_thunks(1);
init_thunk(t, this_ptr_value, IVRClientCore_003_Init, 2, FALSE, FALSE);
EVRInitError (__stdcall *capi_IVRClientCore_003_Init)(EVRApplicationType eApplicationType, const char * pStartupInfo) = (void *)t;
clear_parameters();
capi_IVRClientCore_003_Init(1, (void *)2);
check_ptr_parameter("IVRClientCore_003_Init", this_ptr_value);
check_uint32_parameter("IVRClientCore_003_Init", 1);
check_ptr_parameter("IVRClientCore_003_Init", (void *)2);
init_thunk(t, this_ptr_value, IVRClientCore_003_Cleanup, 0, FALSE, FALSE);
void (__stdcall *capi_IVRClientCore_003_Cleanup)() = (void *)t;
clear_parameters();
capi_IVRClientCore_003_Cleanup();
check_ptr_parameter("IVRClientCore_003_Cleanup", this_ptr_value);
init_thunk(t, this_ptr_value, IVRClientCore_003_IsInterfaceVersionValid, 1, FALSE, FALSE);
EVRInitError (__stdcall *capi_IVRClientCore_003_IsInterfaceVersionValid)(const char * pchInterfaceVersion) = (void *)t;
clear_parameters();
capi_IVRClientCore_003_IsInterfaceVersionValid((void *)1);
check_ptr_parameter("IVRClientCore_003_IsInterfaceVersionValid", this_ptr_value);
check_ptr_parameter("IVRClientCore_003_IsInterfaceVersionValid", (void *)1);
init_thunk(t, this_ptr_value, IVRClientCore_003_GetGenericInterface, 2, FALSE, FALSE);
void * (__stdcall *capi_IVRClientCore_003_GetGenericInterface)(const char * pchNameAndVersion, EVRInitError * peError) = (void *)t;
clear_parameters();
capi_IVRClientCore_003_GetGenericInterface((void *)1, (void *)2);
check_ptr_parameter("IVRClientCore_003_GetGenericInterface", this_ptr_value);
check_ptr_parameter("IVRClientCore_003_GetGenericInterface", (void *)1);
check_ptr_parameter("IVRClientCore_003_GetGenericInterface", (void *)2);
init_thunk(t, this_ptr_value, IVRClientCore_003_BIsHmdPresent, 0, FALSE, FALSE);
bool (__stdcall *capi_IVRClientCore_003_BIsHmdPresent)() = (void *)t;
clear_parameters();
capi_IVRClientCore_003_BIsHmdPresent();
check_ptr_parameter("IVRClientCore_003_BIsHmdPresent", this_ptr_value);
init_thunk(t, this_ptr_value, IVRClientCore_003_GetEnglishStringForHmdError, 1, FALSE, FALSE);
const char * (__stdcall *capi_IVRClientCore_003_GetEnglishStringForHmdError)(EVRInitError eError) = (void *)t;
clear_parameters();
capi_IVRClientCore_003_GetEnglishStringForHmdError(1);
check_ptr_parameter("IVRClientCore_003_GetEnglishStringForHmdError", this_ptr_value);
check_uint32_parameter("IVRClientCore_003_GetEnglishStringForHmdError", 1);
init_thunk(t, this_ptr_value, IVRClientCore_003_GetIDForVRInitError, 1, FALSE, FALSE);
const char * (__stdcall *capi_IVRClientCore_003_GetIDForVRInitError)(EVRInitError eError) = (void *)t;
clear_parameters();
capi_IVRClientCore_003_GetIDForVRInitError(1);
check_ptr_parameter("IVRClientCore_003_GetIDForVRInitError", this_ptr_value);
check_uint32_parameter("IVRClientCore_003_GetIDForVRInitError", 1);
VirtualFree(t, 0, MEM_RELEASE);
}
void test_capi_thunks_IVRInput_005(void)
{
struct thunk *t = alloc_thunks(1);
@ -3019,131 +3442,6 @@ void test_capi_thunks_IVRInput_005(void)
VirtualFree(t, 0, MEM_RELEASE);
}
void test_capi_thunks_IVRIOBuffer_002(void)
{
struct thunk *t = alloc_thunks(1);
init_thunk(t, this_ptr_value, IVRIOBuffer_002_Open, 5, FALSE, FALSE);
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_002_Open((void *)1, 2, 3, 4, (void *)5);
check_ptr_parameter("IVRIOBuffer_002_Open", this_ptr_value);
check_ptr_parameter("IVRIOBuffer_002_Open", (void *)1);
check_uint32_parameter("IVRIOBuffer_002_Open", 2);
check_uint32_parameter("IVRIOBuffer_002_Open", 3);
check_uint32_parameter("IVRIOBuffer_002_Open", 4);
check_ptr_parameter("IVRIOBuffer_002_Open", (void *)5);
init_thunk(t, this_ptr_value, IVRIOBuffer_002_Close, 1, FALSE, FALSE);
EIOBufferError (__stdcall *capi_IVRIOBuffer_002_Close)(IOBufferHandle_t ulBuffer) = (void *)t;
clear_parameters();
capi_IVRIOBuffer_002_Close(1);
check_ptr_parameter("IVRIOBuffer_002_Close", this_ptr_value);
check_uint64_parameter("IVRIOBuffer_002_Close", 1);
init_thunk(t, this_ptr_value, IVRIOBuffer_002_Read, 4, FALSE, FALSE);
EIOBufferError (__stdcall *capi_IVRIOBuffer_002_Read)(IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead) = (void *)t;
clear_parameters();
capi_IVRIOBuffer_002_Read(1, (void *)2, 3, (void *)4);
check_ptr_parameter("IVRIOBuffer_002_Read", this_ptr_value);
check_uint64_parameter("IVRIOBuffer_002_Read", 1);
check_ptr_parameter("IVRIOBuffer_002_Read", (void *)2);
check_uint32_parameter("IVRIOBuffer_002_Read", 3);
check_ptr_parameter("IVRIOBuffer_002_Read", (void *)4);
init_thunk(t, this_ptr_value, IVRIOBuffer_002_Write, 3, FALSE, FALSE);
EIOBufferError (__stdcall *capi_IVRIOBuffer_002_Write)(IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes) = (void *)t;
clear_parameters();
capi_IVRIOBuffer_002_Write(1, (void *)2, 3);
check_ptr_parameter("IVRIOBuffer_002_Write", this_ptr_value);
check_uint64_parameter("IVRIOBuffer_002_Write", 1);
check_ptr_parameter("IVRIOBuffer_002_Write", (void *)2);
check_uint32_parameter("IVRIOBuffer_002_Write", 3);
init_thunk(t, this_ptr_value, IVRIOBuffer_002_PropertyContainer, 1, FALSE, FALSE);
PropertyContainerHandle_t (__stdcall *capi_IVRIOBuffer_002_PropertyContainer)(IOBufferHandle_t ulBuffer) = (void *)t;
clear_parameters();
capi_IVRIOBuffer_002_PropertyContainer(1);
check_ptr_parameter("IVRIOBuffer_002_PropertyContainer", this_ptr_value);
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);
}
void test_capi_thunks_IVRClientCore_003(void)
{
struct thunk *t = alloc_thunks(1);
init_thunk(t, this_ptr_value, IVRClientCore_003_Init, 2, FALSE, FALSE);
EVRInitError (__stdcall *capi_IVRClientCore_003_Init)(EVRApplicationType eApplicationType, const char * pStartupInfo) = (void *)t;
clear_parameters();
capi_IVRClientCore_003_Init(1, (void *)2);
check_ptr_parameter("IVRClientCore_003_Init", this_ptr_value);
check_uint32_parameter("IVRClientCore_003_Init", 1);
check_ptr_parameter("IVRClientCore_003_Init", (void *)2);
init_thunk(t, this_ptr_value, IVRClientCore_003_Cleanup, 0, FALSE, FALSE);
void (__stdcall *capi_IVRClientCore_003_Cleanup)() = (void *)t;
clear_parameters();
capi_IVRClientCore_003_Cleanup();
check_ptr_parameter("IVRClientCore_003_Cleanup", this_ptr_value);
init_thunk(t, this_ptr_value, IVRClientCore_003_IsInterfaceVersionValid, 1, FALSE, FALSE);
EVRInitError (__stdcall *capi_IVRClientCore_003_IsInterfaceVersionValid)(const char * pchInterfaceVersion) = (void *)t;
clear_parameters();
capi_IVRClientCore_003_IsInterfaceVersionValid((void *)1);
check_ptr_parameter("IVRClientCore_003_IsInterfaceVersionValid", this_ptr_value);
check_ptr_parameter("IVRClientCore_003_IsInterfaceVersionValid", (void *)1);
init_thunk(t, this_ptr_value, IVRClientCore_003_GetGenericInterface, 2, FALSE, FALSE);
void * (__stdcall *capi_IVRClientCore_003_GetGenericInterface)(const char * pchNameAndVersion, EVRInitError * peError) = (void *)t;
clear_parameters();
capi_IVRClientCore_003_GetGenericInterface((void *)1, (void *)2);
check_ptr_parameter("IVRClientCore_003_GetGenericInterface", this_ptr_value);
check_ptr_parameter("IVRClientCore_003_GetGenericInterface", (void *)1);
check_ptr_parameter("IVRClientCore_003_GetGenericInterface", (void *)2);
init_thunk(t, this_ptr_value, IVRClientCore_003_BIsHmdPresent, 0, FALSE, FALSE);
bool (__stdcall *capi_IVRClientCore_003_BIsHmdPresent)() = (void *)t;
clear_parameters();
capi_IVRClientCore_003_BIsHmdPresent();
check_ptr_parameter("IVRClientCore_003_BIsHmdPresent", this_ptr_value);
init_thunk(t, this_ptr_value, IVRClientCore_003_GetEnglishStringForHmdError, 1, FALSE, FALSE);
const char * (__stdcall *capi_IVRClientCore_003_GetEnglishStringForHmdError)(EVRInitError eError) = (void *)t;
clear_parameters();
capi_IVRClientCore_003_GetEnglishStringForHmdError(1);
check_ptr_parameter("IVRClientCore_003_GetEnglishStringForHmdError", this_ptr_value);
check_uint32_parameter("IVRClientCore_003_GetEnglishStringForHmdError", 1);
init_thunk(t, this_ptr_value, IVRClientCore_003_GetIDForVRInitError, 1, FALSE, FALSE);
const char * (__stdcall *capi_IVRClientCore_003_GetIDForVRInitError)(EVRInitError eError) = (void *)t;
clear_parameters();
capi_IVRClientCore_003_GetIDForVRInitError(1);
check_ptr_parameter("IVRClientCore_003_GetIDForVRInitError", this_ptr_value);
check_uint32_parameter("IVRClientCore_003_GetIDForVRInitError", 1);
VirtualFree(t, 0, MEM_RELEASE);
}
void test_capi_thunks_IVRIOBuffer_001(void)
{
struct thunk *t = alloc_thunks(1);

3
vrclient_x64/tests/main_autogen.c
View file

@ -19,9 +19,10 @@ int main(void)
test_capi_thunks_IVRScreenshots_001();
test_capi_thunks_IVRResources_001();
test_capi_thunks_IVRDriverManager_001();
test_capi_thunks_IVRInput_005();
test_capi_thunks_IVRInput_006();
test_capi_thunks_IVRIOBuffer_002();
test_capi_thunks_IVRClientCore_003();
test_capi_thunks_IVRInput_005();
test_capi_thunks_IVRIOBuffer_001();
test_capi_thunks_IVRChaperoneSetup_005();
test_capi_thunks_IVROverlay_018();

2
vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_006.cpp
View file

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

7
vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.cpp
View file

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.3.22/ivrclientcore.h"
#include "openvr_v1.4.18/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
@ -104,6 +104,11 @@ void cppIVRChaperoneSetup_IVRChaperoneSetup_006_HideWorkingSetPreview(void *linu
((IVRChaperoneSetup*)linux_side)->HideWorkingSetPreview();
}
void cppIVRChaperoneSetup_IVRChaperoneSetup_006_RoomSetupStarting(void *linux_side)
{
((IVRChaperoneSetup*)linux_side)->RoomSetupStarting();
}
#ifdef __cplusplus
}
#endif

1
vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.h
View file

@ -20,6 +20,7 @@ extern bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_ExportLiveToBuffer(void *
extern bool cppIVRChaperoneSetup_IVRChaperoneSetup_006_ImportFromBufferToWorking(void *, const char *, uint32_t);
extern void cppIVRChaperoneSetup_IVRChaperoneSetup_006_ShowWorkingSetPreview(void *);
extern void cppIVRChaperoneSetup_IVRChaperoneSetup_006_HideWorkingSetPreview(void *);
extern void cppIVRChaperoneSetup_IVRChaperoneSetup_006_RoomSetupStarting(void *);
#ifdef __cplusplus
}
#endif

2
vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_003.cpp
View file

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

2
vrclient_x64/vrclient_x64/cppIVRClientCore_IVRClientCore_003.cpp
View file

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

12
vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_022.cpp
View file

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.3.22/ivrclientcore.h"
#include "openvr_v1.4.18/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
@ -229,6 +229,16 @@ bool cppIVRCompositor_IVRCompositor_022_IsMotionSmoothingEnabled(void *linux_sid
return ((IVRCompositor*)linux_side)->IsMotionSmoothingEnabled();
}
bool cppIVRCompositor_IVRCompositor_022_IsMotionSmoothingSupported(void *linux_side)
{
return ((IVRCompositor*)linux_side)->IsMotionSmoothingSupported();
}
bool cppIVRCompositor_IVRCompositor_022_IsCurrentSceneFocusAppLoading(void *linux_side)
{
return ((IVRCompositor*)linux_side)->IsCurrentSceneFocusAppLoading();
}
#ifdef __cplusplus
}
#endif

2
vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_022.h
View file

@ -45,6 +45,8 @@ extern uint32_t cppIVRCompositor_IVRCompositor_022_GetVulkanDeviceExtensionsRequ
extern void cppIVRCompositor_IVRCompositor_022_SetExplicitTimingMode(void *, EVRCompositorTimingMode);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_022_SubmitExplicitTimingData(void *);
extern bool cppIVRCompositor_IVRCompositor_022_IsMotionSmoothingEnabled(void *);
extern bool cppIVRCompositor_IVRCompositor_022_IsMotionSmoothingSupported(void *);
extern bool cppIVRCompositor_IVRCompositor_022_IsCurrentSceneFocusAppLoading(void *);
#ifdef __cplusplus
}
#endif

2
vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp
View file

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

2
vrclient_x64/vrclient_x64/cppIVRExtendedDisplay_IVRExtendedDisplay_001.cpp
View file

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

2
vrclient_x64/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_002.cpp
View file

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

144
vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_006.cpp Normal file
View file

@ -0,0 +1,144 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.4.18/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
}
#include "cppIVRInput_IVRInput_006.h"
#ifdef __cplusplus
extern "C" {
#endif
vr::EVRInputError cppIVRInput_IVRInput_006_SetActionManifestPath(void *linux_side, const char * pchActionManifestPath)
{
return ((IVRInput*)linux_side)->SetActionManifestPath((const char *)pchActionManifestPath);
}
vr::EVRInputError cppIVRInput_IVRInput_006_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_006_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_006_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_006_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_006_GetDigitalActionData(void *linux_side, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
return ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, (vr::InputDigitalActionData_t *)pActionData, (uint32_t)unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
}
vr::EVRInputError cppIVRInput_IVRInput_006_GetAnalogActionData(void *linux_side, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
return ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, (vr::InputAnalogActionData_t *)pActionData, (uint32_t)unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
}
vr::EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
return ((IVRInput*)linux_side)->GetPoseActionDataRelativeToNow((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, (vr::InputPoseActionData_t *)pActionData, (uint32_t)unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
}
vr::EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
return ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (vr::InputPoseActionData_t *)pActionData, (uint32_t)unActionDataSize, (vr::VRInputValueHandle_t)ulRestrictToDevice);
}
vr::EVRInputError cppIVRInput_IVRInput_006_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize)
{
return ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, (vr::InputSkeletalActionData_t *)pActionData, (uint32_t)unActionDataSize);
}
vr::EVRInputError cppIVRInput_IVRInput_006_GetBoneCount(void *linux_side, VRActionHandle_t action, uint32_t * pBoneCount)
{
return ((IVRInput*)linux_side)->GetBoneCount((vr::VRActionHandle_t)action, (uint32_t *)pBoneCount);
}
vr::EVRInputError cppIVRInput_IVRInput_006_GetBoneHierarchy(void *linux_side, VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount)
{
return ((IVRInput*)linux_side)->GetBoneHierarchy((vr::VRActionHandle_t)action, (vr::BoneIndex_t *)pParentIndices, (uint32_t)unIndexArayCount);
}
vr::EVRInputError cppIVRInput_IVRInput_006_GetBoneName(void *linux_side, VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize)
{
return ((IVRInput*)linux_side)->GetBoneName((vr::VRActionHandle_t)action, (vr::BoneIndex_t)nBoneIndex, (char *)pchBoneName, (uint32_t)unNameBufferSize);
}
vr::EVRInputError cppIVRInput_IVRInput_006_GetSkeletalReferenceTransforms(void *linux_side, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
{
return ((IVRInput*)linux_side)->GetSkeletalReferenceTransforms((vr::VRActionHandle_t)action, (vr::EVRSkeletalTransformSpace)eTransformSpace, (vr::EVRSkeletalReferencePose)eReferencePose, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount);
}
vr::EVRInputError cppIVRInput_IVRInput_006_GetSkeletalTrackingLevel(void *linux_side, VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel)
{
return ((IVRInput*)linux_side)->GetSkeletalTrackingLevel((vr::VRActionHandle_t)action, (vr::EVRSkeletalTrackingLevel *)pSkeletalTrackingLevel);
}
vr::EVRInputError cppIVRInput_IVRInput_006_GetSkeletalBoneData(void *linux_side, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
{
return ((IVRInput*)linux_side)->GetSkeletalBoneData((vr::VRActionHandle_t)action, (vr::EVRSkeletalTransformSpace)eTransformSpace, (vr::EVRSkeletalMotionRange)eMotionRange, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount);
}
vr::EVRInputError cppIVRInput_IVRInput_006_GetSkeletalSummaryData(void *linux_side, VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData)
{
return ((IVRInput*)linux_side)->GetSkeletalSummaryData((vr::VRActionHandle_t)action, (vr::EVRSummaryType)eSummaryType, (vr::VRSkeletalSummaryData_t *)pSkeletalSummaryData);
}
vr::EVRInputError cppIVRInput_IVRInput_006_GetSkeletalBoneDataCompressed(void *linux_side, VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize)
{
return ((IVRInput*)linux_side)->GetSkeletalBoneDataCompressed((vr::VRActionHandle_t)action, (vr::EVRSkeletalMotionRange)eMotionRange, (void *)pvCompressedData, (uint32_t)unCompressedSize, (uint32_t *)punRequiredCompressedSize);
}
vr::EVRInputError cppIVRInput_IVRInput_006_DecompressSkeletalBoneData(void *linux_side, const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
{
return ((IVRInput*)linux_side)->DecompressSkeletalBoneData((const void *)pvCompressedBuffer, (uint32_t)unCompressedBufferSize, (vr::EVRSkeletalTransformSpace)eTransformSpace, (vr::VRBoneTransform_t *)pTransformArray, (uint32_t)unTransformArrayCount);
}
vr::EVRInputError cppIVRInput_IVRInput_006_TriggerHapticVibrationAction(void *linux_side, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice)
{
return ((IVRInput*)linux_side)->TriggerHapticVibrationAction((vr::VRActionHandle_t)action, (float)fStartSecondsFromNow, (float)fDurationSeconds, (float)fFrequency, (float)fAmplitude, (vr::VRInputValueHandle_t)ulRestrictToDevice);
}
vr::EVRInputError cppIVRInput_IVRInput_006_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_006_GetOriginLocalizedName(void *linux_side, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude)
{
return ((IVRInput*)linux_side)->GetOriginLocalizedName((vr::VRInputValueHandle_t)origin, (char *)pchNameArray, (uint32_t)unNameArraySize, (int32_t)unStringSectionsToInclude);
}
vr::EVRInputError cppIVRInput_IVRInput_006_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_006_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_006_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);
}
bool cppIVRInput_IVRInput_006_IsUsingLegacyInput(void *linux_side)
{
return ((IVRInput*)linux_side)->IsUsingLegacyInput();
}
#ifdef __cplusplus
}
#endif

32
vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_006.h Normal file
View file

@ -0,0 +1,32 @@
#ifdef __cplusplus
extern "C" {
#endif
extern EVRInputError cppIVRInput_IVRInput_006_SetActionManifestPath(void *, const char *);
extern EVRInputError cppIVRInput_IVRInput_006_GetActionSetHandle(void *, const char *, VRActionSetHandle_t *);
extern EVRInputError cppIVRInput_IVRInput_006_GetActionHandle(void *, const char *, VRActionHandle_t *);
extern EVRInputError cppIVRInput_IVRInput_006_GetInputSourceHandle(void *, const char *, VRInputValueHandle_t *);
extern EVRInputError cppIVRInput_IVRInput_006_UpdateActionState(void *, VRActiveActionSet_t *, uint32_t, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_006_GetDigitalActionData(void *, VRActionHandle_t, InputDigitalActionData_t *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_006_GetAnalogActionData(void *, VRActionHandle_t, InputAnalogActionData_t *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, InputPoseActionData_t *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, InputPoseActionData_t *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_006_GetSkeletalActionData(void *, VRActionHandle_t, InputSkeletalActionData_t *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_006_GetBoneCount(void *, VRActionHandle_t, uint32_t *);
extern EVRInputError cppIVRInput_IVRInput_006_GetBoneHierarchy(void *, VRActionHandle_t, BoneIndex_t *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_006_GetBoneName(void *, VRActionHandle_t, BoneIndex_t, char *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_006_GetSkeletalReferenceTransforms(void *, VRActionHandle_t, EVRSkeletalTransformSpace, EVRSkeletalReferencePose, VRBoneTransform_t *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_006_GetSkeletalTrackingLevel(void *, VRActionHandle_t, EVRSkeletalTrackingLevel *);
extern EVRInputError cppIVRInput_IVRInput_006_GetSkeletalBoneData(void *, VRActionHandle_t, EVRSkeletalTransformSpace, EVRSkeletalMotionRange, VRBoneTransform_t *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_006_GetSkeletalSummaryData(void *, VRActionHandle_t, EVRSummaryType, VRSkeletalSummaryData_t *);
extern EVRInputError cppIVRInput_IVRInput_006_GetSkeletalBoneDataCompressed(void *, VRActionHandle_t, EVRSkeletalMotionRange, void *, uint32_t, uint32_t *);
extern EVRInputError cppIVRInput_IVRInput_006_DecompressSkeletalBoneData(void *, const void *, uint32_t, EVRSkeletalTransformSpace, VRBoneTransform_t *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_006_TriggerHapticVibrationAction(void *, VRActionHandle_t, float, float, float, float, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_006_GetActionOrigins(void *, VRActionSetHandle_t, VRActionHandle_t, VRInputValueHandle_t *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_006_GetOriginLocalizedName(void *, VRInputValueHandle_t, char *, uint32_t, int32_t);
extern EVRInputError cppIVRInput_IVRInput_006_GetOriginTrackedDeviceInfo(void *, VRInputValueHandle_t, InputOriginInfo_t *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_006_ShowActionOrigins(void *, VRActionSetHandle_t, VRActionHandle_t);
extern EVRInputError cppIVRInput_IVRInput_006_ShowBindingsForActionSet(void *, VRActiveActionSet_t *, uint32_t, uint32_t, VRInputValueHandle_t);
extern bool cppIVRInput_IVRInput_006_IsUsingLegacyInput(void *);
#ifdef __cplusplus
}
#endif

2
vrclient_x64/vrclient_x64/cppIVRNotifications_IVRNotifications_002.cpp
View file

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

6
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_019.cpp
View file

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.3.22/ivrclientcore.h"
#include "openvr_v1.4.18/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_1322 * pEvent, uint32_t uncbVREvent)
bool cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1418 * pEvent, uint32_t uncbVREvent)
{
VREvent_t lin;
bool _ret;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, &lin, sizeof(lin));
struct_VREvent_t_1322_lin_to_win(&lin, pEvent);
struct_VREvent_t_1418_lin_to_win(&lin, pEvent);
return _ret;
}

2
vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_019.h
View file

@ -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_1322 *, uint32_t);
extern bool cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1418 *, 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 *);

18
vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp
View file

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.3.22/ivrclientcore.h"
#include "openvr_v1.4.18/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_1322 ** ppRenderModel)
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1418 ** ppRenderModel)
{
RenderModel_t *lin;
vr::EVRRenderModelError _ret;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, &lin);
if(_ret == 0)
*ppRenderModel = struct_RenderModel_t_1322_wrap(lin);
*ppRenderModel = struct_RenderModel_t_1418_wrap(lin);
return _ret;
}
void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1322 * pRenderModel)
void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1418 * pRenderModel)
{
((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1322_unwrap(pRenderModel));
((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1418_unwrap(pRenderModel));
}
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1322 ** ppTexture)
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1418 ** 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_1322_wrap(lin);
*ppTexture = struct_RenderModel_TextureMap_t_1418_wrap(lin);
return _ret;
}
void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1322 * pTexture)
void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1418 * pTexture)
{
((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1322_unwrap(pTexture));
((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1418_unwrap(pTexture));
}
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTextureD3D11_Async(void *linux_side, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D)

8
vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.h
View file

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

2
vrclient_x64/vrclient_x64/cppIVRResources_IVRResources_001.cpp
View file

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

2
vrclient_x64/vrclient_x64/cppIVRScreenshots_IVRScreenshots_001.cpp
View file

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

2
vrclient_x64/vrclient_x64/cppIVRSettings_IVRSettings_002.cpp
View file

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

18
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_019.cpp
View file

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.3.22/ivrclientcore.h"
#include "openvr_v1.4.18/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_1322 * pEvent, uint32_t uncbVREvent)
bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *linux_side, winVREvent_t_1418 * pEvent, uint32_t uncbVREvent)
{
VREvent_t lin;
bool _ret;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(&lin, sizeof(lin));
struct_VREvent_t_1322_lin_to_win(&lin, pEvent);
struct_VREvent_t_1418_lin_to_win(&lin, pEvent);
return _ret;
}
bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1322 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1418 * 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_1322_lin_to_win(&lin, pEvent);
struct_VREvent_t_1418_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_1322 * pControllerState, uint32_t unControllerStateSize)
bool cppIVRSystem_IVRSystem_019_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1418 * pControllerState, uint32_t unControllerStateSize)
{
VRControllerState001_t lin;
bool _ret;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, &lin, sizeof(lin));
struct_VRControllerState001_t_1322_lin_to_win(&lin, pControllerState);
struct_VRControllerState001_t_1418_lin_to_win(&lin, pControllerState);
return _ret;
}
bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1322 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1418 * 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_1322_lin_to_win(&lin, pControllerState);
struct_VRControllerState001_t_1418_lin_to_win(&lin, pControllerState);
return _ret;
}

8
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_019.h
View file

@ -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_1322 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1322 *, uint32_t, TrackedDevicePose_t *);
extern bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *, winVREvent_t_1418 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1418 *, 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_1322 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1322 *, uint32_t, TrackedDevicePose_t *);
extern bool cppIVRSystem_IVRSystem_019_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1418 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1418 *, 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);

2
vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_005.cpp
View file

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

10
vrclient_x64/vrclient_x64/struct_converters.h
View file

@ -1,3 +1,13 @@
typedef struct winVREvent_t_1418 winVREvent_t_1418;
extern void struct_VREvent_t_1418_lin_to_win(void *l, void *w);
typedef struct winVRControllerState001_t_1418 winVRControllerState001_t_1418;
extern void struct_VRControllerState001_t_1418_lin_to_win(void *l, void *w);
typedef struct winRenderModel_TextureMap_t_1418 winRenderModel_TextureMap_t_1418;
extern struct winRenderModel_TextureMap_t_1418 *struct_RenderModel_TextureMap_t_1418_wrap(void *l);
extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1418_unwrap(winRenderModel_TextureMap_t_1418 *w);
typedef struct winRenderModel_t_1418 winRenderModel_t_1418;
extern struct winRenderModel_t_1418 *struct_RenderModel_t_1418_wrap(void *l);
extern RenderModel_t *struct_RenderModel_t_1418_unwrap(winRenderModel_t_1418 *w);
typedef struct winVREvent_t_1322 winVREvent_t_1322;
extern void struct_VREvent_t_1322_lin_to_win(void *l, void *w);
typedef struct winVRControllerState001_t_1322 winVRControllerState001_t_1322;

108
vrclient_x64/vrclient_x64/struct_converters_1418.cpp Normal file
View file

@ -0,0 +1,108 @@
#include <stdlib.h>
#include <string.h>
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.4.18/openvr.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
#pragma pack(push, 8)
struct winVREvent_t_1418 {
uint32_t eventType;
vr::TrackedDeviceIndex_t trackedDeviceIndex;
float eventAgeSeconds;
vr::VREvent_Data_t data;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_VREvent_t_1418_lin_to_win(void *l, void *w)
{
struct winVREvent_t_1418 *win = (struct winVREvent_t_1418 *)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_1418 {
uint32_t unPacketNum;
uint64_t ulButtonPressed;
uint64_t ulButtonTouched;
vr::VRControllerAxis_t rAxis[5];
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_VRControllerState001_t_1418_lin_to_win(void *l, void *w)
{
struct winVRControllerState001_t_1418 *win = (struct winVRControllerState001_t_1418 *)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_1418 {
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_1418 *struct_RenderModel_TextureMap_t_1418_wrap(void *l)
{
struct winRenderModel_TextureMap_t_1418 *win = (struct winRenderModel_TextureMap_t_1418 *)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_1418_unwrap(winRenderModel_TextureMap_t_1418 *w)
{
RenderModel_TextureMap_t *ret = w->linux_side;
free(w);
return ret;
}
#pragma pack(push, 8)
struct winRenderModel_t_1418 {
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_1418 *struct_RenderModel_t_1418_wrap(void *l)
{
struct winRenderModel_t_1418 *win = (struct winRenderModel_t_1418 *)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_1418_unwrap(winRenderModel_t_1418 *w)
{
RenderModel_t *ret = w->linux_side;
free(w);
return ret;
}
}

3
vrclient_x64/vrclient_x64/vrclient_defs.h
View file

@ -64,7 +64,8 @@ typedef int
EIOBufferMode,
EVRSkeletalMotionRange,
EVRSkeletalReferencePose,
EVRSkeletalTrackingLevel;
EVRSkeletalTrackingLevel,
EVRSummaryType;
typedef uint32_t DriverId_t;
typedef uint32_t TrackedDeviceIndex_t;

8
vrclient_x64/vrclient_x64/vrclient_main.c
View file

@ -32,8 +32,8 @@ typedef struct winRenderModel_t_1015 winRenderModel_t_1015;
typedef struct winRenderModel_TextureMap_t_1015 winRenderModel_TextureMap_t_1015;
#include "cppIVRRenderModels_IVRRenderModels_005.h"
typedef struct winRenderModel_t_113b winRenderModel_t_113b;
typedef struct winRenderModel_TextureMap_t_113b winRenderModel_TextureMap_t_113b;
typedef struct winRenderModel_t_1418 winRenderModel_t_1418;
typedef struct winRenderModel_TextureMap_t_1418 winRenderModel_TextureMap_t_1418;
#include "cppIVRRenderModels_IVRRenderModels_006.h"
WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
@ -1094,7 +1094,7 @@ EVRRenderModelError ivrrendermodels_load_into_texture_d3d11_async(
error = cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(linux_side, texture_id, &texture_map);
break;
case 6:
error = cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(linux_side, texture_id, (struct winRenderModel_TextureMap_t_113b **)&texture_map);
error = cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(linux_side, texture_id, (struct winRenderModel_TextureMap_t_1418 **)&texture_map);
break;
}
if (error == VRRenderModelError_Loading)
@ -1124,7 +1124,7 @@ EVRRenderModelError ivrrendermodels_load_into_texture_d3d11_async(
cppIVRRenderModels_IVRRenderModels_005_FreeTexture(linux_side, texture_map);
break;
case 6:
cppIVRRenderModels_IVRRenderModels_006_FreeTexture(linux_side, (struct winRenderModel_TextureMap_t_113b *)texture_map);
cppIVRRenderModels_IVRRenderModels_006_FreeTexture(linux_side, (struct winRenderModel_TextureMap_t_1418 *)texture_map);
break;
}
return error;

15
vrclient_x64/vrclient_x64/winIVRChaperoneSetup.c
View file

@ -158,6 +158,13 @@ void __thiscall winIVRChaperoneSetup_IVRChaperoneSetup_006_HideWorkingSetPreview
cppIVRChaperoneSetup_IVRChaperoneSetup_006_HideWorkingSetPreview(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRChaperoneSetup_IVRChaperoneSetup_006_RoomSetupStarting, 4)
void __thiscall winIVRChaperoneSetup_IVRChaperoneSetup_006_RoomSetupStarting(winIVRChaperoneSetup_IVRChaperoneSetup_006 *_this)
{
TRACE("%p\n", _this);
cppIVRChaperoneSetup_IVRChaperoneSetup_006_RoomSetupStarting(_this->linux_side);
}
extern vtable_ptr winIVRChaperoneSetup_IVRChaperoneSetup_006_vtable;
#ifndef __GNUC__
@ -183,6 +190,7 @@ void __asm_dummy_vtables(void) {
VTABLE_ADD_FUNC(winIVRChaperoneSetup_IVRChaperoneSetup_006_ImportFromBufferToWorking)
VTABLE_ADD_FUNC(winIVRChaperoneSetup_IVRChaperoneSetup_006_ShowWorkingSetPreview)
VTABLE_ADD_FUNC(winIVRChaperoneSetup_IVRChaperoneSetup_006_HideWorkingSetPreview)
VTABLE_ADD_FUNC(winIVRChaperoneSetup_IVRChaperoneSetup_006_RoomSetupStarting)
);
#ifndef __GNUC__
}
@ -206,8 +214,8 @@ void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_006(void *object)
winIVRChaperoneSetup_IVRChaperoneSetup_006 *create_winIVRChaperoneSetup_IVRChaperoneSetup_006_FnTable(void *linux_side)
{
winIVRChaperoneSetup_IVRChaperoneSetup_006 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRChaperoneSetup_IVRChaperoneSetup_006));
struct thunk *thunks = alloc_thunks(19);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 19 * sizeof(*vtable));
struct thunk *thunks = alloc_thunks(20);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 20 * sizeof(*vtable));
int i;
TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
@ -230,7 +238,8 @@ winIVRChaperoneSetup_IVRChaperoneSetup_006 *create_winIVRChaperoneSetup_IVRChape
init_thunk(&thunks[16], r, winIVRChaperoneSetup_IVRChaperoneSetup_006_ImportFromBufferToWorking, 2, FALSE, FALSE);
init_thunk(&thunks[17], r, winIVRChaperoneSetup_IVRChaperoneSetup_006_ShowWorkingSetPreview, 0, FALSE, FALSE);
init_thunk(&thunks[18], r, winIVRChaperoneSetup_IVRChaperoneSetup_006_HideWorkingSetPreview, 0, FALSE, FALSE);
for (i = 0; i < 19; i++)
init_thunk(&thunks[19], r, winIVRChaperoneSetup_IVRChaperoneSetup_006_RoomSetupStarting, 0, FALSE, FALSE);
for (i = 0; i < 20; i++)
vtable[i] = &thunks[i];
r->linux_side = linux_side;
r->vtable = (void *)vtable;

24
vrclient_x64/vrclient_x64/winIVRCompositor.c
View file

@ -335,6 +335,20 @@ bool __thiscall winIVRCompositor_IVRCompositor_022_IsMotionSmoothingEnabled(winI
return cppIVRCompositor_IVRCompositor_022_IsMotionSmoothingEnabled(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_022_IsMotionSmoothingSupported, 4)
bool __thiscall winIVRCompositor_IVRCompositor_022_IsMotionSmoothingSupported(winIVRCompositor_IVRCompositor_022 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_022_IsMotionSmoothingSupported(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_022_IsCurrentSceneFocusAppLoading, 4)
bool __thiscall winIVRCompositor_IVRCompositor_022_IsCurrentSceneFocusAppLoading(winIVRCompositor_IVRCompositor_022 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_022_IsCurrentSceneFocusAppLoading(_this->linux_side);
}
extern vtable_ptr winIVRCompositor_IVRCompositor_022_vtable;
#ifndef __GNUC__
@ -385,6 +399,8 @@ void __asm_dummy_vtables(void) {
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_022_SetExplicitTimingMode)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_022_SubmitExplicitTimingData)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_022_IsMotionSmoothingEnabled)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_022_IsMotionSmoothingSupported)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_022_IsCurrentSceneFocusAppLoading)
);
#ifndef __GNUC__
}
@ -410,8 +426,8 @@ void destroy_winIVRCompositor_IVRCompositor_022(void *object)
winIVRCompositor_IVRCompositor_022 *create_winIVRCompositor_IVRCompositor_022_FnTable(void *linux_side)
{
winIVRCompositor_IVRCompositor_022 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_022));
struct thunk *thunks = alloc_thunks(44);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 44 * sizeof(*vtable));
struct thunk *thunks = alloc_thunks(46);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 46 * sizeof(*vtable));
int i;
TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
@ -459,7 +475,9 @@ winIVRCompositor_IVRCompositor_022 *create_winIVRCompositor_IVRCompositor_022_Fn
init_thunk(&thunks[41], r, winIVRCompositor_IVRCompositor_022_SetExplicitTimingMode, 1, FALSE, FALSE);
init_thunk(&thunks[42], r, winIVRCompositor_IVRCompositor_022_SubmitExplicitTimingData, 0, FALSE, FALSE);
init_thunk(&thunks[43], r, winIVRCompositor_IVRCompositor_022_IsMotionSmoothingEnabled, 0, FALSE, FALSE);
for (i = 0; i < 44; i++)
init_thunk(&thunks[44], r, winIVRCompositor_IVRCompositor_022_IsMotionSmoothingSupported, 0, FALSE, FALSE);
init_thunk(&thunks[45], r, winIVRCompositor_IVRCompositor_022_IsCurrentSceneFocusAppLoading, 0, FALSE, FALSE);
for (i = 0; i < 46; i++)
vtable[i] = &thunks[i];
r->linux_side = linux_side;
r->vtable = (void *)vtable;

293
vrclient_x64/vrclient_x64/winIVRInput.c
View file

@ -18,6 +18,299 @@
WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
#include "cppIVRInput_IVRInput_006.h"
typedef struct __winIVRInput_IVRInput_006 {
vtable_ptr *vtable;
void *linux_side;
} winIVRInput_IVRInput_006;
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_SetActionManifestPath, 12)
EVRInputError __thiscall winIVRInput_IVRInput_006_SetActionManifestPath(winIVRInput_IVRInput_006 *_this, const char * pchActionManifestPath)
{
char lin_pchActionManifestPath[PATH_MAX];
vrclient_dos_path_to_unix_path(pchActionManifestPath, lin_pchActionManifestPath);
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_SetActionManifestPath(_this->linux_side, pchActionManifestPath ? lin_pchActionManifestPath : NULL);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetActionSetHandle, 20)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetActionSetHandle(winIVRInput_IVRInput_006 *_this, const char * pchActionSetName, VRActionSetHandle_t * pHandle)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetActionSetHandle(_this->linux_side, pchActionSetName, pHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetActionHandle, 20)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetActionHandle(winIVRInput_IVRInput_006 *_this, const char * pchActionName, VRActionHandle_t * pHandle)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetActionHandle(_this->linux_side, pchActionName, pHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetInputSourceHandle, 20)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetInputSourceHandle(winIVRInput_IVRInput_006 *_this, const char * pchInputSourcePath, VRInputValueHandle_t * pHandle)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetInputSourceHandle(_this->linux_side, pchInputSourcePath, pHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_UpdateActionState, 20)
EVRInputError __thiscall winIVRInput_IVRInput_006_UpdateActionState(winIVRInput_IVRInput_006 *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_UpdateActionState(_this->linux_side, pSets, unSizeOfVRSelectedActionSet_t, unSetCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetDigitalActionData, 32)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetDigitalActionData(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetDigitalActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetAnalogActionData, 32)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetAnalogActionData(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetAnalogActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow, 40)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(_this->linux_side, action, eOrigin, fPredictedSecondsFromNow, pActionData, unActionDataSize, ulRestrictToDevice);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetPoseActionDataForNextFrame, 36)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(_this->linux_side, action, eOrigin, pActionData, unActionDataSize, ulRestrictToDevice);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetSkeletalActionData, 24)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetSkeletalActionData(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetSkeletalActionData(_this->linux_side, action, pActionData, unActionDataSize);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetBoneCount, 20)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetBoneCount(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, uint32_t * pBoneCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetBoneCount(_this->linux_side, action, pBoneCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetBoneHierarchy, 24)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetBoneHierarchy(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetBoneHierarchy(_this->linux_side, action, pParentIndices, unIndexArayCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetBoneName, 28)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetBoneName(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetBoneName(_this->linux_side, action, nBoneIndex, pchBoneName, unNameBufferSize);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetSkeletalReferenceTransforms, 32)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetSkeletalReferenceTransforms(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetSkeletalReferenceTransforms(_this->linux_side, action, eTransformSpace, eReferencePose, pTransformArray, unTransformArrayCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetSkeletalTrackingLevel, 20)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetSkeletalTrackingLevel(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetSkeletalTrackingLevel(_this->linux_side, action, pSkeletalTrackingLevel);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetSkeletalBoneData, 32)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetSkeletalBoneData(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetSkeletalBoneData(_this->linux_side, action, eTransformSpace, eMotionRange, pTransformArray, unTransformArrayCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetSkeletalSummaryData, 24)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetSkeletalSummaryData(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetSkeletalSummaryData(_this->linux_side, action, eSummaryType, pSkeletalSummaryData);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetSkeletalBoneDataCompressed, 36)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetSkeletalBoneDataCompressed(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetSkeletalBoneDataCompressed(_this->linux_side, action, eMotionRange, pvCompressedData, unCompressedSize, punRequiredCompressedSize);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_DecompressSkeletalBoneData, 32)
EVRInputError __thiscall winIVRInput_IVRInput_006_DecompressSkeletalBoneData(winIVRInput_IVRInput_006 *_this, const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_DecompressSkeletalBoneData(_this->linux_side, pvCompressedBuffer, unCompressedBufferSize, eTransformSpace, pTransformArray, unTransformArrayCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_TriggerHapticVibrationAction, 36)
EVRInputError __thiscall winIVRInput_IVRInput_006_TriggerHapticVibrationAction(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_TriggerHapticVibrationAction(_this->linux_side, action, fStartSecondsFromNow, fDurationSeconds, fFrequency, fAmplitude, ulRestrictToDevice);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetActionOrigins, 32)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetActionOrigins(winIVRInput_IVRInput_006 *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetActionOrigins(_this->linux_side, actionSetHandle, digitalActionHandle, originsOut, originOutCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetOriginLocalizedName, 28)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetOriginLocalizedName(winIVRInput_IVRInput_006 *_this, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetOriginLocalizedName(_this->linux_side, origin, pchNameArray, unNameArraySize, unStringSectionsToInclude);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetOriginTrackedDeviceInfo, 24)
EVRInputError __thiscall winIVRInput_IVRInput_006_GetOriginTrackedDeviceInfo(winIVRInput_IVRInput_006 *_this, VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_GetOriginTrackedDeviceInfo(_this->linux_side, origin, pOriginInfo, unOriginInfoSize);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_ShowActionOrigins, 20)
EVRInputError __thiscall winIVRInput_IVRInput_006_ShowActionOrigins(winIVRInput_IVRInput_006 *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_ShowActionOrigins(_this->linux_side, actionSetHandle, ulActionHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_ShowBindingsForActionSet, 28)
EVRInputError __thiscall winIVRInput_IVRInput_006_ShowBindingsForActionSet(winIVRInput_IVRInput_006 *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_ShowBindingsForActionSet(_this->linux_side, pSets, unSizeOfVRSelectedActionSet_t, unSetCount, originToHighlight);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_IsUsingLegacyInput, 4)
bool __thiscall winIVRInput_IVRInput_006_IsUsingLegacyInput(winIVRInput_IVRInput_006 *_this)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_006_IsUsingLegacyInput(_this->linux_side);
}
extern vtable_ptr winIVRInput_IVRInput_006_vtable;
#ifndef __GNUC__
void __asm_dummy_vtables(void) {
#endif
__ASM_VTABLE(winIVRInput_IVRInput_006,
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_SetActionManifestPath)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetActionSetHandle)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetActionHandle)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetInputSourceHandle)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_UpdateActionState)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetDigitalActionData)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetAnalogActionData)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetPoseActionDataForNextFrame)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetSkeletalActionData)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetBoneCount)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetBoneHierarchy)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetBoneName)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetSkeletalReferenceTransforms)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetSkeletalTrackingLevel)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetSkeletalBoneData)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetSkeletalSummaryData)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetSkeletalBoneDataCompressed)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_DecompressSkeletalBoneData)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_TriggerHapticVibrationAction)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetActionOrigins)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetOriginLocalizedName)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_GetOriginTrackedDeviceInfo)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_ShowActionOrigins)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_ShowBindingsForActionSet)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_006_IsUsingLegacyInput)
);
#ifndef __GNUC__
}
#endif
winIVRInput_IVRInput_006 *create_winIVRInput_IVRInput_006(void *linux_side)
{
winIVRInput_IVRInput_006 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRInput_IVRInput_006));
TRACE("-> %p\n", r);
r->vtable = &winIVRInput_IVRInput_006_vtable;
r->linux_side = linux_side;
return r;
}
void destroy_winIVRInput_IVRInput_006(void *object)
{
TRACE("%p\n", object);
HeapFree(GetProcessHeap(), 0, object);
}
winIVRInput_IVRInput_006 *create_winIVRInput_IVRInput_006_FnTable(void *linux_side)
{
winIVRInput_IVRInput_006 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRInput_IVRInput_006));
struct thunk *thunks = alloc_thunks(26);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 26 * sizeof(*vtable));
int i;
TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
init_thunk(&thunks[0], r, winIVRInput_IVRInput_006_SetActionManifestPath, 1, FALSE, FALSE);
init_thunk(&thunks[1], r, winIVRInput_IVRInput_006_GetActionSetHandle, 2, FALSE, FALSE);
init_thunk(&thunks[2], r, winIVRInput_IVRInput_006_GetActionHandle, 2, FALSE, FALSE);
init_thunk(&thunks[3], r, winIVRInput_IVRInput_006_GetInputSourceHandle, 2, FALSE, FALSE);
init_thunk(&thunks[4], r, winIVRInput_IVRInput_006_UpdateActionState, 3, FALSE, FALSE);
init_thunk(&thunks[5], r, winIVRInput_IVRInput_006_GetDigitalActionData, 4, FALSE, FALSE);
init_thunk(&thunks[6], r, winIVRInput_IVRInput_006_GetAnalogActionData, 4, FALSE, FALSE);
init_thunk(&thunks[7], r, winIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow, 6, TRUE, FALSE);
init_thunk(&thunks[8], r, winIVRInput_IVRInput_006_GetPoseActionDataForNextFrame, 5, FALSE, FALSE);
init_thunk(&thunks[9], r, winIVRInput_IVRInput_006_GetSkeletalActionData, 3, FALSE, FALSE);
init_thunk(&thunks[10], r, winIVRInput_IVRInput_006_GetBoneCount, 2, FALSE, FALSE);
init_thunk(&thunks[11], r, winIVRInput_IVRInput_006_GetBoneHierarchy, 3, FALSE, FALSE);
init_thunk(&thunks[12], r, winIVRInput_IVRInput_006_GetBoneName, 4, FALSE, FALSE);
init_thunk(&thunks[13], r, winIVRInput_IVRInput_006_GetSkeletalReferenceTransforms, 5, FALSE, FALSE);
init_thunk(&thunks[14], r, winIVRInput_IVRInput_006_GetSkeletalTrackingLevel, 2, FALSE, FALSE);
init_thunk(&thunks[15], r, winIVRInput_IVRInput_006_GetSkeletalBoneData, 5, FALSE, FALSE);
init_thunk(&thunks[16], r, winIVRInput_IVRInput_006_GetSkeletalSummaryData, 3, FALSE, FALSE);
init_thunk(&thunks[17], r, winIVRInput_IVRInput_006_GetSkeletalBoneDataCompressed, 5, FALSE, FALSE);
init_thunk(&thunks[18], r, winIVRInput_IVRInput_006_DecompressSkeletalBoneData, 5, FALSE, FALSE);
init_thunk(&thunks[19], r, winIVRInput_IVRInput_006_TriggerHapticVibrationAction, 6, TRUE, TRUE);
init_thunk(&thunks[20], r, winIVRInput_IVRInput_006_GetActionOrigins, 4, FALSE, FALSE);
init_thunk(&thunks[21], r, winIVRInput_IVRInput_006_GetOriginLocalizedName, 4, FALSE, FALSE);
init_thunk(&thunks[22], r, winIVRInput_IVRInput_006_GetOriginTrackedDeviceInfo, 3, FALSE, FALSE);
init_thunk(&thunks[23], r, winIVRInput_IVRInput_006_ShowActionOrigins, 2, FALSE, FALSE);
init_thunk(&thunks[24], r, winIVRInput_IVRInput_006_ShowBindingsForActionSet, 4, FALSE, FALSE);
init_thunk(&thunks[25], r, winIVRInput_IVRInput_006_IsUsingLegacyInput, 0, FALSE, FALSE);
for (i = 0; i < 26; i++)
vtable[i] = &thunks[i];
r->linux_side = linux_side;
r->vtable = (void *)vtable;
return r;
}
void destroy_winIVRInput_IVRInput_006_FnTable(void *object)
{
winIVRInput_IVRInput_006 *win_object = object;
TRACE("%p\n", win_object);
VirtualFree(win_object->vtable[0], 0, MEM_RELEASE);
HeapFree(GetProcessHeap(), 0, win_object->vtable);
HeapFree(GetProcessHeap(), 0, win_object);
}
#include "cppIVRInput_IVRInput_005.h"
typedef struct __winIVRInput_IVRInput_005 {

2
vrclient_x64/vrclient_x64/winIVROverlay.c
View file

@ -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_1322 * pEvent, uint32_t uncbVREvent)
bool __thiscall winIVROverlay_IVROverlay_019_PollNextOverlayEvent(winIVROverlay_IVROverlay_019 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1418 * pEvent, uint32_t uncbVREvent)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(_this->linux_side, ulOverlayHandle, pEvent, uncbVREvent);

8
vrclient_x64/vrclient_x64/winIVRRenderModels.c
View file

@ -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_1322 ** ppRenderModel)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, winRenderModel_t_1418 ** 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_1322 * pRenderModel)
void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeRenderModel(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_t_1418 * 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_1322 ** ppTexture)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_1418 ** 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_1322 * pTexture)
void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeTexture(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_TextureMap_t_1418 * pTexture)
{
TRACE("%p\n", _this);
cppIVRRenderModels_IVRRenderModels_006_FreeTexture(_this->linux_side, pTexture);

8
vrclient_x64/vrclient_x64/winIVRSystem.c
View file

@ -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_1322 * pEvent, uint32_t uncbVREvent)
bool __thiscall winIVRSystem_IVRSystem_019_PollNextEvent(winIVRSystem_IVRSystem_019 *_this, winVREvent_t_1418 * 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_1322 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
bool __thiscall winIVRSystem_IVRSystem_019_PollNextEventWithPose(winIVRSystem_IVRSystem_019 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1418 * 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_1322 * pControllerState, uint32_t unControllerStateSize)
bool __thiscall winIVRSystem_IVRSystem_019_GetControllerState(winIVRSystem_IVRSystem_019 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1418 * 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_1322 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
bool __thiscall winIVRSystem_IVRSystem_019_GetControllerStateWithPose(winIVRSystem_IVRSystem_019 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1418 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(_this->linux_side, eOrigin, unControllerDeviceIndex, pControllerState, unControllerStateSize, pTrackedDevicePose);

6
vrclient_x64/vrclient_x64/win_constructors.h
View file

@ -26,12 +26,14 @@ 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_005(void *);
extern void *create_winIVRInput_IVRInput_005_FnTable(void *);
extern void *create_winIVRInput_IVRInput_006(void *);
extern void *create_winIVRInput_IVRInput_006_FnTable(void *);
extern void *create_winIVRIOBuffer_IVRIOBuffer_002(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_winIVRInput_IVRInput_005(void *);
extern void *create_winIVRInput_IVRInput_005_FnTable(void *);
extern void *create_winIVRIOBuffer_IVRIOBuffer_001(void *);
extern void *create_winIVRIOBuffer_IVRIOBuffer_001_FnTable(void *);
extern void *create_winIVRChaperoneSetup_IVRChaperoneSetup_005(void *);

6
vrclient_x64/vrclient_x64/win_constructors_table.dat
View file

@ -26,12 +26,14 @@
{"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_005", &create_winIVRInput_IVRInput_005, &destroy_winIVRInput_IVRInput_005},
{"FnTable:IVRInput_005", &create_winIVRInput_IVRInput_005_FnTable, &destroy_winIVRInput_IVRInput_005_FnTable},
{"IVRInput_006", &create_winIVRInput_IVRInput_006, &destroy_winIVRInput_IVRInput_006},
{"FnTable:IVRInput_006", &create_winIVRInput_IVRInput_006_FnTable, &destroy_winIVRInput_IVRInput_006_FnTable},
{"IVRIOBuffer_002", &create_winIVRIOBuffer_IVRIOBuffer_002, &destroy_winIVRIOBuffer_IVRIOBuffer_002},
{"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},
{"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},
{"FnTable:IVRIOBuffer_001", &create_winIVRIOBuffer_IVRIOBuffer_001_FnTable, &destroy_winIVRIOBuffer_IVRIOBuffer_001_FnTable},
{"IVRChaperoneSetup_005", &create_winIVRChaperoneSetup_IVRChaperoneSetup_005, &destroy_winIVRChaperoneSetup_IVRChaperoneSetup_005},

6
vrclient_x64/vrclient_x64/win_destructors.h
View file

@ -26,12 +26,14 @@ 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_005(void *);
extern void destroy_winIVRInput_IVRInput_005_FnTable(void *);
extern void destroy_winIVRInput_IVRInput_006(void *);
extern void destroy_winIVRInput_IVRInput_006_FnTable(void *);
extern void destroy_winIVRIOBuffer_IVRIOBuffer_002(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_winIVRInput_IVRInput_005(void *);
extern void destroy_winIVRInput_IVRInput_005_FnTable(void *);
extern void destroy_winIVRIOBuffer_IVRIOBuffer_001(void *);
extern void destroy_winIVRIOBuffer_IVRIOBuffer_001_FnTable(void *);
extern void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_005(void *);