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

vrclient: Add openvr v1.5.17 support

Browse source
This commit is contained in:
Sophie Tauchert 2019-07-13 12:17:57 +02:00 committed by Andrew Eikum
parent 9b09ae5ff8
commit 99764d17b1
42 changed files with 8784 additions and 706 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
openvr

@ -1 +1 @@
Subproject commit 1fb1030f2ac238456dca7615a4408fb2bb42afb6
Subproject commit cdaf2b330c8df58986391b253cd8f04328139823

1
vrclient_x64/gen_wrapper.py
View file

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

36
vrclient_x64/openvr_v1.5.17/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";
}

5126
vrclient_x64/openvr_v1.5.17/openvr.h Normal file
View file

File diff suppressed because it is too large Load diff

933
vrclient_x64/tests/capi_thunks_autogen.c
View file

File diff suppressed because it is too large Load diff

310
vrclient_x64/tests/capi_thunks_autogen.h
View file

@ -11,101 +11,99 @@
#include "capi_thunks.h"
void test_capi_thunks_IVRSystem_019(void);
void test_capi_thunks_IVRSystem_020(void);
void __thiscall IVRSystem_019_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
void __thiscall IVRSystem_020_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
HmdMatrix44_t *__thiscall IVRSystem_019_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ);
HmdMatrix44_t *__thiscall IVRSystem_020_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ);
void __thiscall IVRSystem_019_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
void __thiscall IVRSystem_020_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
bool __thiscall IVRSystem_019_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates);
bool __thiscall IVRSystem_020_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates);
HmdMatrix34_t *__thiscall IVRSystem_019_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
HmdMatrix34_t *__thiscall IVRSystem_020_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
bool __thiscall IVRSystem_019_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
bool __thiscall IVRSystem_020_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
int32_t __thiscall IVRSystem_019_GetD3D9AdapterIndex(void *_this);
int32_t __thiscall IVRSystem_020_GetD3D9AdapterIndex(void *_this);
void __thiscall IVRSystem_019_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
void __thiscall IVRSystem_020_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
void __thiscall IVRSystem_019_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance);
void __thiscall IVRSystem_020_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance);
bool __thiscall IVRSystem_019_IsDisplayOnDesktop(void *_this);
bool __thiscall IVRSystem_020_IsDisplayOnDesktop(void *_this);
bool __thiscall IVRSystem_019_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
bool __thiscall IVRSystem_020_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
void __thiscall IVRSystem_019_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
void __thiscall IVRSystem_020_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
void __thiscall IVRSystem_019_ResetSeatedZeroPose(void *_this);
void __thiscall IVRSystem_020_ResetSeatedZeroPose(void *_this);
HmdMatrix34_t *__thiscall IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
HmdMatrix34_t *__thiscall IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
HmdMatrix34_t *__thiscall IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
HmdMatrix34_t *__thiscall IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
uint32_t __thiscall IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
uint32_t __thiscall IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
EDeviceActivityLevel __thiscall IVRSystem_019_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
EDeviceActivityLevel __thiscall IVRSystem_020_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
void __thiscall IVRSystem_019_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
void __thiscall IVRSystem_020_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
TrackedDeviceIndex_t __thiscall IVRSystem_019_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType);
TrackedDeviceIndex_t __thiscall IVRSystem_020_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType);
ETrackedControllerRole __thiscall IVRSystem_019_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex);
ETrackedControllerRole __thiscall IVRSystem_020_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex);
ETrackedDeviceClass __thiscall IVRSystem_019_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
ETrackedDeviceClass __thiscall IVRSystem_020_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
bool __thiscall IVRSystem_019_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
bool __thiscall IVRSystem_020_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
bool __thiscall IVRSystem_019_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
bool __thiscall IVRSystem_020_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
float __thiscall IVRSystem_019_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
float __thiscall IVRSystem_020_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
int32_t __thiscall IVRSystem_019_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
int32_t __thiscall IVRSystem_020_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
uint64_t __thiscall IVRSystem_019_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
uint64_t __thiscall IVRSystem_020_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
HmdMatrix34_t *__thiscall IVRSystem_019_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
HmdMatrix34_t *__thiscall IVRSystem_020_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
uint32_t __thiscall IVRSystem_019_GetArrayTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError);
uint32_t __thiscall IVRSystem_020_GetArrayTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError);
uint32_t __thiscall IVRSystem_019_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
uint32_t __thiscall IVRSystem_020_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
const char * __thiscall IVRSystem_019_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
const char * __thiscall IVRSystem_020_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
bool __thiscall IVRSystem_019_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent);
bool __thiscall IVRSystem_020_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent);
bool __thiscall IVRSystem_019_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
bool __thiscall IVRSystem_020_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
const char * __thiscall IVRSystem_019_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
const char * __thiscall IVRSystem_020_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
HiddenAreaMesh_t *__thiscall IVRSystem_019_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type);
HiddenAreaMesh_t *__thiscall IVRSystem_020_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type);
bool __thiscall IVRSystem_019_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize);
bool __thiscall IVRSystem_020_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize);
bool __thiscall IVRSystem_019_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose);
bool __thiscall IVRSystem_020_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose);
void __thiscall IVRSystem_019_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
void __thiscall IVRSystem_020_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
const char * __thiscall IVRSystem_019_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
const char * __thiscall IVRSystem_020_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
const char * __thiscall IVRSystem_019_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
const char * __thiscall IVRSystem_020_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
bool __thiscall IVRSystem_019_IsInputAvailable(void *_this);
bool __thiscall IVRSystem_020_IsInputAvailable(void *_this);
bool __thiscall IVRSystem_019_IsSteamVRDrawingControllers(void *_this);
bool __thiscall IVRSystem_020_IsSteamVRDrawingControllers(void *_this);
bool __thiscall IVRSystem_019_ShouldApplicationPause(void *_this);
bool __thiscall IVRSystem_020_ShouldApplicationPause(void *_this);
bool __thiscall IVRSystem_019_ShouldApplicationReduceRenderingWork(void *_this);
bool __thiscall IVRSystem_020_ShouldApplicationReduceRenderingWork(void *_this);
uint32_t __thiscall IVRSystem_019_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
EVRFirmwareError __thiscall IVRSystem_020_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
EVRFirmwareError __thiscall IVRSystem_019_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
void __thiscall IVRSystem_020_AcknowledgeQuit_Exiting(void *_this);
void __thiscall IVRSystem_019_AcknowledgeQuit_Exiting(void *_this);
void __thiscall IVRSystem_019_AcknowledgeQuit_UserPrompt(void *_this);
void __thiscall IVRSystem_020_AcknowledgeQuit_UserPrompt(void *_this);
void test_capi_thunks_IVRApplications_006(void);
@ -627,6 +625,190 @@ uint32_t __thiscall IVRDriverManager_001_GetDriverName(void *_this, DriverId_t n
DriverHandle_t __thiscall IVRDriverManager_001_GetDriverHandle(void *_this, const char * pchDriverName);
bool __thiscall IVRDriverManager_001_IsEnabled(void *_this, DriverId_t nDriver);
void test_capi_thunks_IVRInput_007(void);
EVRInputError __thiscall IVRInput_007_SetActionManifestPath(void *_this, const char * pchActionManifestPath);
EVRInputError __thiscall IVRInput_007_GetActionSetHandle(void *_this, const char * pchActionSetName, VRActionSetHandle_t * pHandle);
EVRInputError __thiscall IVRInput_007_GetActionHandle(void *_this, const char * pchActionName, VRActionHandle_t * pHandle);
EVRInputError __thiscall IVRInput_007_GetInputSourceHandle(void *_this, const char * pchInputSourcePath, VRInputValueHandle_t * pHandle);
EVRInputError __thiscall IVRInput_007_UpdateActionState(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount);
EVRInputError __thiscall IVRInput_007_GetDigitalActionData(void *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
EVRInputError __thiscall IVRInput_007_GetAnalogActionData(void *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
EVRInputError __thiscall IVRInput_007_GetPoseActionDataRelativeToNow(void *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
EVRInputError __thiscall IVRInput_007_GetPoseActionDataForNextFrame(void *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
EVRInputError __thiscall IVRInput_007_GetSkeletalActionData(void *_this, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize);
EVRInputError __thiscall IVRInput_007_GetBoneCount(void *_this, VRActionHandle_t action, uint32_t * pBoneCount);
EVRInputError __thiscall IVRInput_007_GetBoneHierarchy(void *_this, VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount);
EVRInputError __thiscall IVRInput_007_GetBoneName(void *_this, VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize);
EVRInputError __thiscall IVRInput_007_GetSkeletalReferenceTransforms(void *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
EVRInputError __thiscall IVRInput_007_GetSkeletalTrackingLevel(void *_this, VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel);
EVRInputError __thiscall IVRInput_007_GetSkeletalBoneData(void *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
EVRInputError __thiscall IVRInput_007_GetSkeletalSummaryData(void *_this, VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData);
EVRInputError __thiscall IVRInput_007_GetSkeletalBoneDataCompressed(void *_this, VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize);
EVRInputError __thiscall IVRInput_007_DecompressSkeletalBoneData(void *_this, const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
EVRInputError __thiscall IVRInput_007_TriggerHapticVibrationAction(void *_this, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice);
EVRInputError __thiscall IVRInput_007_GetActionOrigins(void *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount);
EVRInputError __thiscall IVRInput_007_GetOriginLocalizedName(void *_this, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude);
EVRInputError __thiscall IVRInput_007_GetOriginTrackedDeviceInfo(void *_this, VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize);
EVRInputError __thiscall IVRInput_007_GetActionBindingInfo(void *_this, VRActionHandle_t action, InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t * punReturnedBindingInfoCount);
EVRInputError __thiscall IVRInput_007_ShowActionOrigins(void *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle);
EVRInputError __thiscall IVRInput_007_ShowBindingsForActionSet(void *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight);
bool __thiscall IVRInput_007_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_IVRSystem_019(void);
void __thiscall IVRSystem_019_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
HmdMatrix44_t *__thiscall IVRSystem_019_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ);
void __thiscall IVRSystem_019_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
bool __thiscall IVRSystem_019_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates);
HmdMatrix34_t *__thiscall IVRSystem_019_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
bool __thiscall IVRSystem_019_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
int32_t __thiscall IVRSystem_019_GetD3D9AdapterIndex(void *_this);
void __thiscall IVRSystem_019_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
void __thiscall IVRSystem_019_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance);
bool __thiscall IVRSystem_019_IsDisplayOnDesktop(void *_this);
bool __thiscall IVRSystem_019_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
void __thiscall IVRSystem_019_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
void __thiscall IVRSystem_019_ResetSeatedZeroPose(void *_this);
HmdMatrix34_t *__thiscall IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
HmdMatrix34_t *__thiscall IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
uint32_t __thiscall IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
EDeviceActivityLevel __thiscall IVRSystem_019_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
void __thiscall IVRSystem_019_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
TrackedDeviceIndex_t __thiscall IVRSystem_019_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType);
ETrackedControllerRole __thiscall IVRSystem_019_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex);
ETrackedDeviceClass __thiscall IVRSystem_019_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
bool __thiscall IVRSystem_019_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
bool __thiscall IVRSystem_019_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
float __thiscall IVRSystem_019_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
int32_t __thiscall IVRSystem_019_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
uint64_t __thiscall IVRSystem_019_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
HmdMatrix34_t *__thiscall IVRSystem_019_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
uint32_t __thiscall IVRSystem_019_GetArrayTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError);
uint32_t __thiscall IVRSystem_019_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
const char * __thiscall IVRSystem_019_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
bool __thiscall IVRSystem_019_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent);
bool __thiscall IVRSystem_019_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
const char * __thiscall IVRSystem_019_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
HiddenAreaMesh_t *__thiscall IVRSystem_019_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type);
bool __thiscall IVRSystem_019_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize);
bool __thiscall IVRSystem_019_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose);
void __thiscall IVRSystem_019_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
const char * __thiscall IVRSystem_019_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
const char * __thiscall IVRSystem_019_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
bool __thiscall IVRSystem_019_IsInputAvailable(void *_this);
bool __thiscall IVRSystem_019_IsSteamVRDrawingControllers(void *_this);
bool __thiscall IVRSystem_019_ShouldApplicationPause(void *_this);
bool __thiscall IVRSystem_019_ShouldApplicationReduceRenderingWork(void *_this);
uint32_t __thiscall IVRSystem_019_DriverDebugRequest(void *_this, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
EVRFirmwareError __thiscall IVRSystem_019_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
void __thiscall IVRSystem_019_AcknowledgeQuit_Exiting(void *_this);
void __thiscall IVRSystem_019_AcknowledgeQuit_UserPrompt(void *_this);
void test_capi_thunks_IVRInput_006(void);
EVRInputError __thiscall IVRInput_006_SetActionManifestPath(void *_this, const char * pchActionManifestPath);
@ -681,36 +863,6 @@ EVRInputError __thiscall IVRInput_006_ShowBindingsForActionSet(void *_this, VRAc
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);

1549
vrclient_x64/tests/capi_thunks_tests_autogen.c
View file

File diff suppressed because it is too large Load diff

6
vrclient_x64/tests/main_autogen.c
View file

@ -5,7 +5,7 @@
int main(void)
{
test_capi_thunks_IVRSystem_019();
test_capi_thunks_IVRSystem_020();
test_capi_thunks_IVRApplications_006();
test_capi_thunks_IVRSettings_002();
test_capi_thunks_IVRChaperone_003();
@ -19,9 +19,11 @@ int main(void)
test_capi_thunks_IVRScreenshots_001();
test_capi_thunks_IVRResources_001();
test_capi_thunks_IVRDriverManager_001();
test_capi_thunks_IVRInput_006();
test_capi_thunks_IVRInput_007();
test_capi_thunks_IVRIOBuffer_002();
test_capi_thunks_IVRClientCore_003();
test_capi_thunks_IVRSystem_019();
test_capi_thunks_IVRInput_006();
test_capi_thunks_IVRInput_005();
test_capi_thunks_IVRIOBuffer_001();
test_capi_thunks_IVRChaperoneSetup_005();

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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

2
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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

2
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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

7
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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
@ -24,6 +24,11 @@ vr::DriverHandle_t cppIVRDriverManager_IVRDriverManager_001_GetDriverHandle(void
return ((IVRDriverManager*)linux_side)->GetDriverHandle((const char *)pchDriverName);
}
bool cppIVRDriverManager_IVRDriverManager_001_IsEnabled(void *linux_side, DriverId_t nDriver)
{
return ((IVRDriverManager*)linux_side)->IsEnabled((vr::DriverId_t)nDriver);
}
#ifdef __cplusplus
}
#endif

1
vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.h
View file

@ -4,6 +4,7 @@ extern "C" {
extern uint32_t cppIVRDriverManager_IVRDriverManager_001_GetDriverCount(void *);
extern uint32_t cppIVRDriverManager_IVRDriverManager_001_GetDriverName(void *, DriverId_t, char *, uint32_t);
extern DriverHandle_t cppIVRDriverManager_IVRDriverManager_001_GetDriverHandle(void *, const char *);
extern bool cppIVRDriverManager_IVRDriverManager_001_IsEnabled(void *, DriverId_t);
#ifdef __cplusplus
}
#endif

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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

149
vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.cpp Normal file
View file

@ -0,0 +1,149 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.5.17/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
}
#include "cppIVRInput_IVRInput_007.h"
#ifdef __cplusplus
extern "C" {
#endif
vr::EVRInputError cppIVRInput_IVRInput_007_SetActionManifestPath(void *linux_side, const char * pchActionManifestPath)
{
return ((IVRInput*)linux_side)->SetActionManifestPath((const char *)pchActionManifestPath);
}
vr::EVRInputError cppIVRInput_IVRInput_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_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_007_GetActionBindingInfo(void *linux_side, VRActionHandle_t action, InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t * punReturnedBindingInfoCount)
{
return ((IVRInput*)linux_side)->GetActionBindingInfo((vr::VRActionHandle_t)action, (vr::InputBindingInfo_t *)pOriginInfo, (uint32_t)unBindingInfoSize, (uint32_t)unBindingInfoCount, (uint32_t *)punReturnedBindingInfoCount);
}
vr::EVRInputError cppIVRInput_IVRInput_007_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_007_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_007_IsUsingLegacyInput(void *linux_side)
{
return ((IVRInput*)linux_side)->IsUsingLegacyInput();
}
#ifdef __cplusplus
}
#endif

33
vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.h Normal file
View file

@ -0,0 +1,33 @@
#ifdef __cplusplus
extern "C" {
#endif
extern EVRInputError cppIVRInput_IVRInput_007_SetActionManifestPath(void *, const char *);
extern EVRInputError cppIVRInput_IVRInput_007_GetActionSetHandle(void *, const char *, VRActionSetHandle_t *);
extern EVRInputError cppIVRInput_IVRInput_007_GetActionHandle(void *, const char *, VRActionHandle_t *);
extern EVRInputError cppIVRInput_IVRInput_007_GetInputSourceHandle(void *, const char *, VRInputValueHandle_t *);
extern EVRInputError cppIVRInput_IVRInput_007_UpdateActionState(void *, VRActiveActionSet_t *, uint32_t, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_007_GetDigitalActionData(void *, VRActionHandle_t, InputDigitalActionData_t *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_007_GetAnalogActionData(void *, VRActionHandle_t, InputAnalogActionData_t *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, InputPoseActionData_t *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, InputPoseActionData_t *, uint32_t, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_007_GetSkeletalActionData(void *, VRActionHandle_t, InputSkeletalActionData_t *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_007_GetBoneCount(void *, VRActionHandle_t, uint32_t *);
extern EVRInputError cppIVRInput_IVRInput_007_GetBoneHierarchy(void *, VRActionHandle_t, BoneIndex_t *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_007_GetBoneName(void *, VRActionHandle_t, BoneIndex_t, char *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_007_GetSkeletalReferenceTransforms(void *, VRActionHandle_t, EVRSkeletalTransformSpace, EVRSkeletalReferencePose, VRBoneTransform_t *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_007_GetSkeletalTrackingLevel(void *, VRActionHandle_t, EVRSkeletalTrackingLevel *);
extern EVRInputError cppIVRInput_IVRInput_007_GetSkeletalBoneData(void *, VRActionHandle_t, EVRSkeletalTransformSpace, EVRSkeletalMotionRange, VRBoneTransform_t *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_007_GetSkeletalSummaryData(void *, VRActionHandle_t, EVRSummaryType, VRSkeletalSummaryData_t *);
extern EVRInputError cppIVRInput_IVRInput_007_GetSkeletalBoneDataCompressed(void *, VRActionHandle_t, EVRSkeletalMotionRange, void *, uint32_t, uint32_t *);
extern EVRInputError cppIVRInput_IVRInput_007_DecompressSkeletalBoneData(void *, const void *, uint32_t, EVRSkeletalTransformSpace, VRBoneTransform_t *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_007_TriggerHapticVibrationAction(void *, VRActionHandle_t, float, float, float, float, VRInputValueHandle_t);
extern EVRInputError cppIVRInput_IVRInput_007_GetActionOrigins(void *, VRActionSetHandle_t, VRActionHandle_t, VRInputValueHandle_t *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_007_GetOriginLocalizedName(void *, VRInputValueHandle_t, char *, uint32_t, int32_t);
extern EVRInputError cppIVRInput_IVRInput_007_GetOriginTrackedDeviceInfo(void *, VRInputValueHandle_t, InputOriginInfo_t *, uint32_t);
extern EVRInputError cppIVRInput_IVRInput_007_GetActionBindingInfo(void *, VRActionHandle_t, InputBindingInfo_t *, uint32_t, uint32_t, uint32_t *);
extern EVRInputError cppIVRInput_IVRInput_007_ShowActionOrigins(void *, VRActionSetHandle_t, VRActionHandle_t);
extern EVRInputError cppIVRInput_IVRInput_007_ShowBindingsForActionSet(void *, VRActiveActionSet_t *, uint32_t, uint32_t, VRInputValueHandle_t);
extern bool cppIVRInput_IVRInput_007_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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/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_1418 * pEvent, uint32_t uncbVREvent)
bool cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1517 * pEvent, uint32_t uncbVREvent)
{
VREvent_t lin;
bool _ret;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, &lin, sizeof(lin));
struct_VREvent_t_1418_lin_to_win(&lin, pEvent);
struct_VREvent_t_1517_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_1418 *, uint32_t);
extern bool cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1517 *, 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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/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_1418 ** ppRenderModel)
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1517 ** ppRenderModel)
{
RenderModel_t *lin;
vr::EVRRenderModelError _ret;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, &lin);
if(_ret == 0)
*ppRenderModel = struct_RenderModel_t_1418_wrap(lin);
*ppRenderModel = struct_RenderModel_t_1517_wrap(lin);
return _ret;
}
void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1418 * pRenderModel)
void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1517 * pRenderModel)
{
((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1418_unwrap(pRenderModel));
((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1517_unwrap(pRenderModel));
}
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1418 ** ppTexture)
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1517 ** 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_1418_wrap(lin);
*ppTexture = struct_RenderModel_TextureMap_t_1517_wrap(lin);
return _ret;
}
void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1418 * pTexture)
void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1517 * pTexture)
{
((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1418_unwrap(pTexture));
((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1517_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_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_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1517 **);
extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_1517 *);
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1517 **);
extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_1517 *);
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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

260
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_020.cpp Normal file
View file

@ -0,0 +1,260 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.5.17/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
}
#include "cppIVRSystem_IVRSystem_020.h"
#ifdef __cplusplus
extern "C" {
#endif
void cppIVRSystem_IVRSystem_020_GetRecommendedRenderTargetSize(void *linux_side, uint32_t * pnWidth, uint32_t * pnHeight)
{
((IVRSystem*)linux_side)->GetRecommendedRenderTargetSize((uint32_t *)pnWidth, (uint32_t *)pnHeight);
}
vr::HmdMatrix44_t cppIVRSystem_IVRSystem_020_GetProjectionMatrix(void *linux_side, EVREye eEye, float fNearZ, float fFarZ)
{
return ((IVRSystem*)linux_side)->GetProjectionMatrix((vr::EVREye)eEye, (float)fNearZ, (float)fFarZ);
}
void cppIVRSystem_IVRSystem_020_GetProjectionRaw(void *linux_side, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
{
((IVRSystem*)linux_side)->GetProjectionRaw((vr::EVREye)eEye, (float *)pfLeft, (float *)pfRight, (float *)pfTop, (float *)pfBottom);
}
bool cppIVRSystem_IVRSystem_020_ComputeDistortion(void *linux_side, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates)
{
return ((IVRSystem*)linux_side)->ComputeDistortion((vr::EVREye)eEye, (float)fU, (float)fV, (vr::DistortionCoordinates_t *)pDistortionCoordinates);
}
vr::HmdMatrix34_t cppIVRSystem_IVRSystem_020_GetEyeToHeadTransform(void *linux_side, EVREye eEye)
{
return ((IVRSystem*)linux_side)->GetEyeToHeadTransform((vr::EVREye)eEye);
}
bool cppIVRSystem_IVRSystem_020_GetTimeSinceLastVsync(void *linux_side, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
{
return ((IVRSystem*)linux_side)->GetTimeSinceLastVsync((float *)pfSecondsSinceLastVsync, (uint64_t *)pulFrameCounter);
}
int32_t cppIVRSystem_IVRSystem_020_GetD3D9AdapterIndex(void *linux_side)
{
return ((IVRSystem*)linux_side)->GetD3D9AdapterIndex();
}
void cppIVRSystem_IVRSystem_020_GetDXGIOutputInfo(void *linux_side, int32_t * pnAdapterIndex)
{
((IVRSystem*)linux_side)->GetDXGIOutputInfo((int32_t *)pnAdapterIndex);
}
void cppIVRSystem_IVRSystem_020_GetOutputDevice(void *linux_side, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance)
{
((IVRSystem*)linux_side)->GetOutputDevice((uint64_t *)pnDevice, (vr::ETextureType)textureType, (VkInstance_T *)pInstance);
}
bool cppIVRSystem_IVRSystem_020_IsDisplayOnDesktop(void *linux_side)
{
return ((IVRSystem*)linux_side)->IsDisplayOnDesktop();
}
bool cppIVRSystem_IVRSystem_020_SetDisplayVisibility(void *linux_side, bool bIsVisibleOnDesktop)
{
return ((IVRSystem*)linux_side)->SetDisplayVisibility((bool)bIsVisibleOnDesktop);
}
void cppIVRSystem_IVRSystem_020_GetDeviceToAbsoluteTrackingPose(void *linux_side, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
{
((IVRSystem*)linux_side)->GetDeviceToAbsoluteTrackingPose((vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsToPhotonsFromNow, (vr::TrackedDevicePose_t *)pTrackedDevicePoseArray, (uint32_t)unTrackedDevicePoseArrayCount);
}
void cppIVRSystem_IVRSystem_020_ResetSeatedZeroPose(void *linux_side)
{
((IVRSystem*)linux_side)->ResetSeatedZeroPose();
}
vr::HmdMatrix34_t cppIVRSystem_IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *linux_side)
{
return ((IVRSystem*)linux_side)->GetSeatedZeroPoseToStandingAbsoluteTrackingPose();
}
vr::HmdMatrix34_t cppIVRSystem_IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *linux_side)
{
return ((IVRSystem*)linux_side)->GetRawZeroPoseToStandingAbsoluteTrackingPose();
}
uint32_t cppIVRSystem_IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass(void *linux_side, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
{
return ((IVRSystem*)linux_side)->GetSortedTrackedDeviceIndicesOfClass((vr::ETrackedDeviceClass)eTrackedDeviceClass, (vr::TrackedDeviceIndex_t *)punTrackedDeviceIndexArray, (uint32_t)unTrackedDeviceIndexArrayCount, (vr::TrackedDeviceIndex_t)unRelativeToTrackedDeviceIndex);
}
vr::EDeviceActivityLevel cppIVRSystem_IVRSystem_020_GetTrackedDeviceActivityLevel(void *linux_side, TrackedDeviceIndex_t unDeviceId)
{
return ((IVRSystem*)linux_side)->GetTrackedDeviceActivityLevel((vr::TrackedDeviceIndex_t)unDeviceId);
}
void cppIVRSystem_IVRSystem_020_ApplyTransform(void *linux_side, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
{
((IVRSystem*)linux_side)->ApplyTransform((vr::TrackedDevicePose_t *)pOutputPose, (const vr::TrackedDevicePose_t *)pTrackedDevicePose, (const vr::HmdMatrix34_t *)pTransform);
}
vr::TrackedDeviceIndex_t cppIVRSystem_IVRSystem_020_GetTrackedDeviceIndexForControllerRole(void *linux_side, ETrackedControllerRole unDeviceType)
{
return ((IVRSystem*)linux_side)->GetTrackedDeviceIndexForControllerRole((vr::ETrackedControllerRole)unDeviceType);
}
vr::ETrackedControllerRole cppIVRSystem_IVRSystem_020_GetControllerRoleForTrackedDeviceIndex(void *linux_side, TrackedDeviceIndex_t unDeviceIndex)
{
return ((IVRSystem*)linux_side)->GetControllerRoleForTrackedDeviceIndex((vr::TrackedDeviceIndex_t)unDeviceIndex);
}
vr::ETrackedDeviceClass cppIVRSystem_IVRSystem_020_GetTrackedDeviceClass(void *linux_side, TrackedDeviceIndex_t unDeviceIndex)
{
return ((IVRSystem*)linux_side)->GetTrackedDeviceClass((vr::TrackedDeviceIndex_t)unDeviceIndex);
}
bool cppIVRSystem_IVRSystem_020_IsTrackedDeviceConnected(void *linux_side, TrackedDeviceIndex_t unDeviceIndex)
{
return ((IVRSystem*)linux_side)->IsTrackedDeviceConnected((vr::TrackedDeviceIndex_t)unDeviceIndex);
}
bool cppIVRSystem_IVRSystem_020_GetBoolTrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
{
return ((IVRSystem*)linux_side)->GetBoolTrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
}
float cppIVRSystem_IVRSystem_020_GetFloatTrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
{
return ((IVRSystem*)linux_side)->GetFloatTrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
}
int32_t cppIVRSystem_IVRSystem_020_GetInt32TrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
{
return ((IVRSystem*)linux_side)->GetInt32TrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
}
uint64_t cppIVRSystem_IVRSystem_020_GetUint64TrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
{
return ((IVRSystem*)linux_side)->GetUint64TrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
}
vr::HmdMatrix34_t cppIVRSystem_IVRSystem_020_GetMatrix34TrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
{
return ((IVRSystem*)linux_side)->GetMatrix34TrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
}
uint32_t cppIVRSystem_IVRSystem_020_GetArrayTrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError)
{
return ((IVRSystem*)linux_side)->GetArrayTrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::PropertyTypeTag_t)propType, (void *)pBuffer, (uint32_t)unBufferSize, (vr::ETrackedPropertyError *)pError);
}
uint32_t cppIVRSystem_IVRSystem_020_GetStringTrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
{
return ((IVRSystem*)linux_side)->GetStringTrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (char *)pchValue, (uint32_t)unBufferSize, (vr::ETrackedPropertyError *)pError);
}
const char * cppIVRSystem_IVRSystem_020_GetPropErrorNameFromEnum(void *linux_side, ETrackedPropertyError error)
{
return ((IVRSystem*)linux_side)->GetPropErrorNameFromEnum((vr::ETrackedPropertyError)error);
}
bool cppIVRSystem_IVRSystem_020_PollNextEvent(void *linux_side, winVREvent_t_1517 * pEvent, uint32_t uncbVREvent)
{
VREvent_t lin;
bool _ret;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(&lin, sizeof(lin));
struct_VREvent_t_1517_lin_to_win(&lin, pEvent);
return _ret;
}
bool cppIVRSystem_IVRSystem_020_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1517 * 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_1517_lin_to_win(&lin, pEvent);
return _ret;
}
const char * cppIVRSystem_IVRSystem_020_GetEventTypeNameFromEnum(void *linux_side, EVREventType eType)
{
return ((IVRSystem*)linux_side)->GetEventTypeNameFromEnum((vr::EVREventType)eType);
}
vr::HiddenAreaMesh_t cppIVRSystem_IVRSystem_020_GetHiddenAreaMesh(void *linux_side, EVREye eEye, EHiddenAreaMeshType type)
{
return ((IVRSystem*)linux_side)->GetHiddenAreaMesh((vr::EVREye)eEye, (vr::EHiddenAreaMeshType)type);
}
bool cppIVRSystem_IVRSystem_020_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1517 * pControllerState, uint32_t unControllerStateSize)
{
VRControllerState001_t lin;
bool _ret;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, &lin, sizeof(lin));
struct_VRControllerState001_t_1517_lin_to_win(&lin, pControllerState);
return _ret;
}
bool cppIVRSystem_IVRSystem_020_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1517 * 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_1517_lin_to_win(&lin, pControllerState);
return _ret;
}
void cppIVRSystem_IVRSystem_020_TriggerHapticPulse(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
{
((IVRSystem*)linux_side)->TriggerHapticPulse((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, (uint32_t)unAxisId, (unsigned short)usDurationMicroSec);
}
const char * cppIVRSystem_IVRSystem_020_GetButtonIdNameFromEnum(void *linux_side, EVRButtonId eButtonId)
{
return ((IVRSystem*)linux_side)->GetButtonIdNameFromEnum((vr::EVRButtonId)eButtonId);
}
const char * cppIVRSystem_IVRSystem_020_GetControllerAxisTypeNameFromEnum(void *linux_side, EVRControllerAxisType eAxisType)
{
return ((IVRSystem*)linux_side)->GetControllerAxisTypeNameFromEnum((vr::EVRControllerAxisType)eAxisType);
}
bool cppIVRSystem_IVRSystem_020_IsInputAvailable(void *linux_side)
{
return ((IVRSystem*)linux_side)->IsInputAvailable();
}
bool cppIVRSystem_IVRSystem_020_IsSteamVRDrawingControllers(void *linux_side)
{
return ((IVRSystem*)linux_side)->IsSteamVRDrawingControllers();
}
bool cppIVRSystem_IVRSystem_020_ShouldApplicationPause(void *linux_side)
{
return ((IVRSystem*)linux_side)->ShouldApplicationPause();
}
bool cppIVRSystem_IVRSystem_020_ShouldApplicationReduceRenderingWork(void *linux_side)
{
return ((IVRSystem*)linux_side)->ShouldApplicationReduceRenderingWork();
}
vr::EVRFirmwareError cppIVRSystem_IVRSystem_020_PerformFirmwareUpdate(void *linux_side, TrackedDeviceIndex_t unDeviceIndex)
{
return ((IVRSystem*)linux_side)->PerformFirmwareUpdate((vr::TrackedDeviceIndex_t)unDeviceIndex);
}
void cppIVRSystem_IVRSystem_020_AcknowledgeQuit_Exiting(void *linux_side)
{
((IVRSystem*)linux_side)->AcknowledgeQuit_Exiting();
}
void cppIVRSystem_IVRSystem_020_AcknowledgeQuit_UserPrompt(void *linux_side)
{
((IVRSystem*)linux_side)->AcknowledgeQuit_UserPrompt();
}
#ifdef __cplusplus
}
#endif

52
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_020.h Normal file
View file

@ -0,0 +1,52 @@
#ifdef __cplusplus
extern "C" {
#endif
extern void cppIVRSystem_IVRSystem_020_GetRecommendedRenderTargetSize(void *, uint32_t *, uint32_t *);
extern HmdMatrix44_t cppIVRSystem_IVRSystem_020_GetProjectionMatrix(void *, EVREye, float, float);
extern void cppIVRSystem_IVRSystem_020_GetProjectionRaw(void *, EVREye, float *, float *, float *, float *);
extern bool cppIVRSystem_IVRSystem_020_ComputeDistortion(void *, EVREye, float, float, DistortionCoordinates_t *);
extern HmdMatrix34_t cppIVRSystem_IVRSystem_020_GetEyeToHeadTransform(void *, EVREye);
extern bool cppIVRSystem_IVRSystem_020_GetTimeSinceLastVsync(void *, float *, uint64_t *);
extern int32_t cppIVRSystem_IVRSystem_020_GetD3D9AdapterIndex(void *);
extern void cppIVRSystem_IVRSystem_020_GetDXGIOutputInfo(void *, int32_t *);
extern void cppIVRSystem_IVRSystem_020_GetOutputDevice(void *, uint64_t *, ETextureType, VkInstance_T *);
extern bool cppIVRSystem_IVRSystem_020_IsDisplayOnDesktop(void *);
extern bool cppIVRSystem_IVRSystem_020_SetDisplayVisibility(void *, bool);
extern void cppIVRSystem_IVRSystem_020_GetDeviceToAbsoluteTrackingPose(void *, ETrackingUniverseOrigin, float, TrackedDevicePose_t *, uint32_t);
extern void cppIVRSystem_IVRSystem_020_ResetSeatedZeroPose(void *);
extern HmdMatrix34_t cppIVRSystem_IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *);
extern HmdMatrix34_t cppIVRSystem_IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *);
extern uint32_t cppIVRSystem_IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass(void *, ETrackedDeviceClass, TrackedDeviceIndex_t *, uint32_t, TrackedDeviceIndex_t);
extern EDeviceActivityLevel cppIVRSystem_IVRSystem_020_GetTrackedDeviceActivityLevel(void *, TrackedDeviceIndex_t);
extern void cppIVRSystem_IVRSystem_020_ApplyTransform(void *, TrackedDevicePose_t *, TrackedDevicePose_t *, HmdMatrix34_t *);
extern TrackedDeviceIndex_t cppIVRSystem_IVRSystem_020_GetTrackedDeviceIndexForControllerRole(void *, ETrackedControllerRole);
extern ETrackedControllerRole cppIVRSystem_IVRSystem_020_GetControllerRoleForTrackedDeviceIndex(void *, TrackedDeviceIndex_t);
extern ETrackedDeviceClass cppIVRSystem_IVRSystem_020_GetTrackedDeviceClass(void *, TrackedDeviceIndex_t);
extern bool cppIVRSystem_IVRSystem_020_IsTrackedDeviceConnected(void *, TrackedDeviceIndex_t);
extern bool cppIVRSystem_IVRSystem_020_GetBoolTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
extern float cppIVRSystem_IVRSystem_020_GetFloatTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
extern int32_t cppIVRSystem_IVRSystem_020_GetInt32TrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
extern uint64_t cppIVRSystem_IVRSystem_020_GetUint64TrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
extern HmdMatrix34_t cppIVRSystem_IVRSystem_020_GetMatrix34TrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
extern uint32_t cppIVRSystem_IVRSystem_020_GetArrayTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, PropertyTypeTag_t, void *, uint32_t, ETrackedPropertyError *);
extern uint32_t cppIVRSystem_IVRSystem_020_GetStringTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, char *, uint32_t, ETrackedPropertyError *);
extern const char * cppIVRSystem_IVRSystem_020_GetPropErrorNameFromEnum(void *, ETrackedPropertyError);
extern bool cppIVRSystem_IVRSystem_020_PollNextEvent(void *, winVREvent_t_1517 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_020_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1517 *, uint32_t, TrackedDevicePose_t *);
extern const char * cppIVRSystem_IVRSystem_020_GetEventTypeNameFromEnum(void *, EVREventType);
extern HiddenAreaMesh_t cppIVRSystem_IVRSystem_020_GetHiddenAreaMesh(void *, EVREye, EHiddenAreaMeshType);
extern bool cppIVRSystem_IVRSystem_020_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1517 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_020_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1517 *, uint32_t, TrackedDevicePose_t *);
extern void cppIVRSystem_IVRSystem_020_TriggerHapticPulse(void *, TrackedDeviceIndex_t, uint32_t, unsigned short);
extern const char * cppIVRSystem_IVRSystem_020_GetButtonIdNameFromEnum(void *, EVRButtonId);
extern const char * cppIVRSystem_IVRSystem_020_GetControllerAxisTypeNameFromEnum(void *, EVRControllerAxisType);
extern bool cppIVRSystem_IVRSystem_020_IsInputAvailable(void *);
extern bool cppIVRSystem_IVRSystem_020_IsSteamVRDrawingControllers(void *);
extern bool cppIVRSystem_IVRSystem_020_ShouldApplicationPause(void *);
extern bool cppIVRSystem_IVRSystem_020_ShouldApplicationReduceRenderingWork(void *);
extern EVRFirmwareError cppIVRSystem_IVRSystem_020_PerformFirmwareUpdate(void *, TrackedDeviceIndex_t);
extern void cppIVRSystem_IVRSystem_020_AcknowledgeQuit_Exiting(void *);
extern void cppIVRSystem_IVRSystem_020_AcknowledgeQuit_UserPrompt(void *);
#ifdef __cplusplus
}
#endif

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.4.18/ivrclientcore.h"
#include "openvr_v1.5.17/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_1517 winVREvent_t_1517;
extern void struct_VREvent_t_1517_lin_to_win(void *l, void *w);
typedef struct winVRControllerState001_t_1517 winVRControllerState001_t_1517;
extern void struct_VRControllerState001_t_1517_lin_to_win(void *l, void *w);
typedef struct winRenderModel_TextureMap_t_1517 winRenderModel_TextureMap_t_1517;
extern struct winRenderModel_TextureMap_t_1517 *struct_RenderModel_TextureMap_t_1517_wrap(void *l);
extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1517_unwrap(winRenderModel_TextureMap_t_1517 *w);
typedef struct winRenderModel_t_1517 winRenderModel_t_1517;
extern struct winRenderModel_t_1517 *struct_RenderModel_t_1517_wrap(void *l);
extern RenderModel_t *struct_RenderModel_t_1517_unwrap(winRenderModel_t_1517 *w);
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;

108
vrclient_x64/vrclient_x64/struct_converters_1517.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.5.17/openvr.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
#pragma pack(push, 8)
struct winVREvent_t_1517 {
uint32_t eventType;
vr::TrackedDeviceIndex_t trackedDeviceIndex;
float eventAgeSeconds;
vr::VREvent_Data_t data;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_VREvent_t_1517_lin_to_win(void *l, void *w)
{
struct winVREvent_t_1517 *win = (struct winVREvent_t_1517 *)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_1517 {
uint32_t unPacketNum;
uint64_t ulButtonPressed;
uint64_t ulButtonTouched;
vr::VRControllerAxis_t rAxis[5];
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_VRControllerState001_t_1517_lin_to_win(void *l, void *w)
{
struct winVRControllerState001_t_1517 *win = (struct winVRControllerState001_t_1517 *)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_1517 {
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_1517 *struct_RenderModel_TextureMap_t_1517_wrap(void *l)
{
struct winRenderModel_TextureMap_t_1517 *win = (struct winRenderModel_TextureMap_t_1517 *)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_1517_unwrap(winRenderModel_TextureMap_t_1517 *w)
{
RenderModel_TextureMap_t *ret = w->linux_side;
free(w);
return ret;
}
#pragma pack(push, 8)
struct winRenderModel_t_1517 {
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_1517 *struct_RenderModel_t_1517_wrap(void *l)
{
struct winRenderModel_t_1517 *win = (struct winRenderModel_t_1517 *)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_1517_unwrap(winRenderModel_t_1517 *w)
{
RenderModel_t *ret = w->linux_side;
free(w);
return ret;
}
}

1
vrclient_x64/vrclient_x64/vrclient_defs.h
View file

@ -122,6 +122,7 @@ typedef struct VRBoneTransform_t VRBoneTransform_t;
typedef struct InputOriginInfo_t InputOriginInfo_t;
typedef struct InputSkeletalActionData_t InputSkeletalActionData_t;
typedef struct VRSkeletalSummaryData_t VRSkeletalSummaryData_t;
typedef struct InputBindingInfo_t InputBindingInfo_t;
/* dereferenced structs */
typedef struct HmdMatrix34_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_1418 winRenderModel_t_1418;
typedef struct winRenderModel_TextureMap_t_1418 winRenderModel_TextureMap_t_1418;
typedef struct winRenderModel_t_1517 winRenderModel_t_1517;
typedef struct winRenderModel_TextureMap_t_1517 winRenderModel_TextureMap_t_1517;
#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_1418 **)&texture_map);
error = cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(linux_side, texture_id, (struct winRenderModel_TextureMap_t_1517 **)&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_1418 *)texture_map);
cppIVRRenderModels_IVRRenderModels_006_FreeTexture(linux_side, (struct winRenderModel_TextureMap_t_1517 *)texture_map);
break;
}
return error;

15
vrclient_x64/vrclient_x64/winIVRDriverManager.c
View file

@ -46,6 +46,13 @@ DriverHandle_t __thiscall winIVRDriverManager_IVRDriverManager_001_GetDriverHand
return cppIVRDriverManager_IVRDriverManager_001_GetDriverHandle(_this->linux_side, pchDriverName);
}
DEFINE_THISCALL_WRAPPER(winIVRDriverManager_IVRDriverManager_001_IsEnabled, 8)
bool __thiscall winIVRDriverManager_IVRDriverManager_001_IsEnabled(winIVRDriverManager_IVRDriverManager_001 *_this, DriverId_t nDriver)
{
TRACE("%p\n", _this);
return cppIVRDriverManager_IVRDriverManager_001_IsEnabled(_this->linux_side, nDriver);
}
extern vtable_ptr winIVRDriverManager_IVRDriverManager_001_vtable;
#ifndef __GNUC__
@ -55,6 +62,7 @@ void __asm_dummy_vtables(void) {
VTABLE_ADD_FUNC(winIVRDriverManager_IVRDriverManager_001_GetDriverCount)
VTABLE_ADD_FUNC(winIVRDriverManager_IVRDriverManager_001_GetDriverName)
VTABLE_ADD_FUNC(winIVRDriverManager_IVRDriverManager_001_GetDriverHandle)
VTABLE_ADD_FUNC(winIVRDriverManager_IVRDriverManager_001_IsEnabled)
);
#ifndef __GNUC__
}
@ -78,15 +86,16 @@ void destroy_winIVRDriverManager_IVRDriverManager_001(void *object)
winIVRDriverManager_IVRDriverManager_001 *create_winIVRDriverManager_IVRDriverManager_001_FnTable(void *linux_side)
{
winIVRDriverManager_IVRDriverManager_001 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRDriverManager_IVRDriverManager_001));
struct thunk *thunks = alloc_thunks(3);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 3 * sizeof(*vtable));
struct thunk *thunks = alloc_thunks(4);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 4 * sizeof(*vtable));
int i;
TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
init_thunk(&thunks[0], r, winIVRDriverManager_IVRDriverManager_001_GetDriverCount, 0, FALSE, FALSE);
init_thunk(&thunks[1], r, winIVRDriverManager_IVRDriverManager_001_GetDriverName, 3, FALSE, FALSE);
init_thunk(&thunks[2], r, winIVRDriverManager_IVRDriverManager_001_GetDriverHandle, 1, FALSE, FALSE);
for (i = 0; i < 3; i++)
init_thunk(&thunks[3], r, winIVRDriverManager_IVRDriverManager_001_IsEnabled, 1, FALSE, FALSE);
for (i = 0; i < 4; i++)
vtable[i] = &thunks[i];
r->linux_side = linux_side;
r->vtable = (void *)vtable;

302
vrclient_x64/vrclient_x64/winIVRInput.c
View file

@ -18,6 +18,308 @@
WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
#include "cppIVRInput_IVRInput_007.h"
typedef struct __winIVRInput_IVRInput_007 {
vtable_ptr *vtable;
void *linux_side;
} winIVRInput_IVRInput_007;
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_SetActionManifestPath, 12)
EVRInputError __thiscall winIVRInput_IVRInput_007_SetActionManifestPath(winIVRInput_IVRInput_007 *_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_007_SetActionManifestPath(_this->linux_side, pchActionManifestPath ? lin_pchActionManifestPath : NULL);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetActionSetHandle, 20)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetActionSetHandle(winIVRInput_IVRInput_007 *_this, const char * pchActionSetName, VRActionSetHandle_t * pHandle)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetActionSetHandle(_this->linux_side, pchActionSetName, pHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetActionHandle, 20)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetActionHandle(winIVRInput_IVRInput_007 *_this, const char * pchActionName, VRActionHandle_t * pHandle)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetActionHandle(_this->linux_side, pchActionName, pHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetInputSourceHandle, 20)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetInputSourceHandle(winIVRInput_IVRInput_007 *_this, const char * pchInputSourcePath, VRInputValueHandle_t * pHandle)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetInputSourceHandle(_this->linux_side, pchInputSourcePath, pHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_UpdateActionState, 20)
EVRInputError __thiscall winIVRInput_IVRInput_007_UpdateActionState(winIVRInput_IVRInput_007 *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_UpdateActionState(_this->linux_side, pSets, unSizeOfVRSelectedActionSet_t, unSetCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetDigitalActionData, 32)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetDigitalActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetDigitalActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetAnalogActionData, 32)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetAnalogActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetAnalogActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow, 40)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(_this->linux_side, action, eOrigin, fPredictedSecondsFromNow, pActionData, unActionDataSize, ulRestrictToDevice);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetPoseActionDataForNextFrame, 36)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(_this->linux_side, action, eOrigin, pActionData, unActionDataSize, ulRestrictToDevice);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetSkeletalActionData, 24)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetSkeletalActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetSkeletalActionData(_this->linux_side, action, pActionData, unActionDataSize);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetBoneCount, 20)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetBoneCount(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, uint32_t * pBoneCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetBoneCount(_this->linux_side, action, pBoneCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetBoneHierarchy, 24)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetBoneHierarchy(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetBoneHierarchy(_this->linux_side, action, pParentIndices, unIndexArayCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetBoneName, 28)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetBoneName(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetBoneName(_this->linux_side, action, nBoneIndex, pchBoneName, unNameBufferSize);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetSkeletalReferenceTransforms, 32)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetSkeletalReferenceTransforms(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetSkeletalReferenceTransforms(_this->linux_side, action, eTransformSpace, eReferencePose, pTransformArray, unTransformArrayCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetSkeletalTrackingLevel, 20)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetSkeletalTrackingLevel(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetSkeletalTrackingLevel(_this->linux_side, action, pSkeletalTrackingLevel);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetSkeletalBoneData, 32)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetSkeletalBoneData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetSkeletalBoneData(_this->linux_side, action, eTransformSpace, eMotionRange, pTransformArray, unTransformArrayCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetSkeletalSummaryData, 24)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetSkeletalSummaryData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetSkeletalSummaryData(_this->linux_side, action, eSummaryType, pSkeletalSummaryData);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetSkeletalBoneDataCompressed, 36)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetSkeletalBoneDataCompressed(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetSkeletalBoneDataCompressed(_this->linux_side, action, eMotionRange, pvCompressedData, unCompressedSize, punRequiredCompressedSize);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_DecompressSkeletalBoneData, 32)
EVRInputError __thiscall winIVRInput_IVRInput_007_DecompressSkeletalBoneData(winIVRInput_IVRInput_007 *_this, const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_DecompressSkeletalBoneData(_this->linux_side, pvCompressedBuffer, unCompressedBufferSize, eTransformSpace, pTransformArray, unTransformArrayCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_TriggerHapticVibrationAction, 36)
EVRInputError __thiscall winIVRInput_IVRInput_007_TriggerHapticVibrationAction(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_TriggerHapticVibrationAction(_this->linux_side, action, fStartSecondsFromNow, fDurationSeconds, fFrequency, fAmplitude, ulRestrictToDevice);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetActionOrigins, 32)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetActionOrigins(winIVRInput_IVRInput_007 *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetActionOrigins(_this->linux_side, actionSetHandle, digitalActionHandle, originsOut, originOutCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetOriginLocalizedName, 28)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetOriginLocalizedName(winIVRInput_IVRInput_007 *_this, VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetOriginLocalizedName(_this->linux_side, origin, pchNameArray, unNameArraySize, unStringSectionsToInclude);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetOriginTrackedDeviceInfo, 24)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetOriginTrackedDeviceInfo(winIVRInput_IVRInput_007 *_this, VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetOriginTrackedDeviceInfo(_this->linux_side, origin, pOriginInfo, unOriginInfoSize);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetActionBindingInfo, 36)
EVRInputError __thiscall winIVRInput_IVRInput_007_GetActionBindingInfo(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t * punReturnedBindingInfoCount)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_GetActionBindingInfo(_this->linux_side, action, pOriginInfo, unBindingInfoSize, unBindingInfoCount, punReturnedBindingInfoCount);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_ShowActionOrigins, 20)
EVRInputError __thiscall winIVRInput_IVRInput_007_ShowActionOrigins(winIVRInput_IVRInput_007 *_this, VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_ShowActionOrigins(_this->linux_side, actionSetHandle, ulActionHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_ShowBindingsForActionSet, 28)
EVRInputError __thiscall winIVRInput_IVRInput_007_ShowBindingsForActionSet(winIVRInput_IVRInput_007 *_this, VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_ShowBindingsForActionSet(_this->linux_side, pSets, unSizeOfVRSelectedActionSet_t, unSetCount, originToHighlight);
}
DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_IsUsingLegacyInput, 4)
bool __thiscall winIVRInput_IVRInput_007_IsUsingLegacyInput(winIVRInput_IVRInput_007 *_this)
{
TRACE("%p\n", _this);
return cppIVRInput_IVRInput_007_IsUsingLegacyInput(_this->linux_side);
}
extern vtable_ptr winIVRInput_IVRInput_007_vtable;
#ifndef __GNUC__
void __asm_dummy_vtables(void) {
#endif
__ASM_VTABLE(winIVRInput_IVRInput_007,
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_SetActionManifestPath)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetActionSetHandle)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetActionHandle)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetInputSourceHandle)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_UpdateActionState)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetDigitalActionData)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetAnalogActionData)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetPoseActionDataForNextFrame)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetSkeletalActionData)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetBoneCount)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetBoneHierarchy)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetBoneName)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetSkeletalReferenceTransforms)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetSkeletalTrackingLevel)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetSkeletalBoneData)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetSkeletalSummaryData)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetSkeletalBoneDataCompressed)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_DecompressSkeletalBoneData)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_TriggerHapticVibrationAction)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetActionOrigins)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetOriginLocalizedName)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetOriginTrackedDeviceInfo)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_GetActionBindingInfo)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_ShowActionOrigins)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_ShowBindingsForActionSet)
VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_IsUsingLegacyInput)
);
#ifndef __GNUC__
}
#endif
winIVRInput_IVRInput_007 *create_winIVRInput_IVRInput_007(void *linux_side)
{
winIVRInput_IVRInput_007 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRInput_IVRInput_007));
TRACE("-> %p\n", r);
r->vtable = &winIVRInput_IVRInput_007_vtable;
r->linux_side = linux_side;
return r;
}
void destroy_winIVRInput_IVRInput_007(void *object)
{
TRACE("%p\n", object);
HeapFree(GetProcessHeap(), 0, object);
}
winIVRInput_IVRInput_007 *create_winIVRInput_IVRInput_007_FnTable(void *linux_side)
{
winIVRInput_IVRInput_007 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRInput_IVRInput_007));
struct thunk *thunks = alloc_thunks(27);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 27 * sizeof(*vtable));
int i;
TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
init_thunk(&thunks[0], r, winIVRInput_IVRInput_007_SetActionManifestPath, 1, FALSE, FALSE);
init_thunk(&thunks[1], r, winIVRInput_IVRInput_007_GetActionSetHandle, 2, FALSE, FALSE);
init_thunk(&thunks[2], r, winIVRInput_IVRInput_007_GetActionHandle, 2, FALSE, FALSE);
init_thunk(&thunks[3], r, winIVRInput_IVRInput_007_GetInputSourceHandle, 2, FALSE, FALSE);
init_thunk(&thunks[4], r, winIVRInput_IVRInput_007_UpdateActionState, 3, FALSE, FALSE);
init_thunk(&thunks[5], r, winIVRInput_IVRInput_007_GetDigitalActionData, 4, FALSE, FALSE);
init_thunk(&thunks[6], r, winIVRInput_IVRInput_007_GetAnalogActionData, 4, FALSE, FALSE);
init_thunk(&thunks[7], r, winIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow, 6, TRUE, FALSE);
init_thunk(&thunks[8], r, winIVRInput_IVRInput_007_GetPoseActionDataForNextFrame, 5, FALSE, FALSE);
init_thunk(&thunks[9], r, winIVRInput_IVRInput_007_GetSkeletalActionData, 3, FALSE, FALSE);
init_thunk(&thunks[10], r, winIVRInput_IVRInput_007_GetBoneCount, 2, FALSE, FALSE);
init_thunk(&thunks[11], r, winIVRInput_IVRInput_007_GetBoneHierarchy, 3, FALSE, FALSE);
init_thunk(&thunks[12], r, winIVRInput_IVRInput_007_GetBoneName, 4, FALSE, FALSE);
init_thunk(&thunks[13], r, winIVRInput_IVRInput_007_GetSkeletalReferenceTransforms, 5, FALSE, FALSE);
init_thunk(&thunks[14], r, winIVRInput_IVRInput_007_GetSkeletalTrackingLevel, 2, FALSE, FALSE);
init_thunk(&thunks[15], r, winIVRInput_IVRInput_007_GetSkeletalBoneData, 5, FALSE, FALSE);
init_thunk(&thunks[16], r, winIVRInput_IVRInput_007_GetSkeletalSummaryData, 3, FALSE, FALSE);
init_thunk(&thunks[17], r, winIVRInput_IVRInput_007_GetSkeletalBoneDataCompressed, 5, FALSE, FALSE);
init_thunk(&thunks[18], r, winIVRInput_IVRInput_007_DecompressSkeletalBoneData, 5, FALSE, FALSE);
init_thunk(&thunks[19], r, winIVRInput_IVRInput_007_TriggerHapticVibrationAction, 6, TRUE, TRUE);
init_thunk(&thunks[20], r, winIVRInput_IVRInput_007_GetActionOrigins, 4, FALSE, FALSE);
init_thunk(&thunks[21], r, winIVRInput_IVRInput_007_GetOriginLocalizedName, 4, FALSE, FALSE);
init_thunk(&thunks[22], r, winIVRInput_IVRInput_007_GetOriginTrackedDeviceInfo, 3, FALSE, FALSE);
init_thunk(&thunks[23], r, winIVRInput_IVRInput_007_GetActionBindingInfo, 5, FALSE, FALSE);
init_thunk(&thunks[24], r, winIVRInput_IVRInput_007_ShowActionOrigins, 2, FALSE, FALSE);
init_thunk(&thunks[25], r, winIVRInput_IVRInput_007_ShowBindingsForActionSet, 4, FALSE, FALSE);
init_thunk(&thunks[26], r, winIVRInput_IVRInput_007_IsUsingLegacyInput, 0, FALSE, FALSE);
for (i = 0; i < 27; i++)
vtable[i] = &thunks[i];
r->linux_side = linux_side;
r->vtable = (void *)vtable;
return r;
}
void destroy_winIVRInput_IVRInput_007_FnTable(void *object)
{
winIVRInput_IVRInput_007 *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_006.h"
typedef struct __winIVRInput_IVRInput_006 {

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_1418 * pEvent, uint32_t uncbVREvent)
bool __thiscall winIVROverlay_IVROverlay_019_PollNextOverlayEvent(winIVROverlay_IVROverlay_019 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1517 * 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_1418 ** ppRenderModel)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, winRenderModel_t_1517 ** 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_1418 * pRenderModel)
void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeRenderModel(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_t_1517 * 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_1418 ** ppTexture)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_1517 ** 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_1418 * pTexture)
void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeTexture(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_TextureMap_t_1517 * pTexture)
{
TRACE("%p\n", _this);
cppIVRRenderModels_IVRRenderModels_006_FreeTexture(_this->linux_side, pTexture);

477
vrclient_x64/vrclient_x64/winIVRSystem.c
View file

@ -18,6 +18,483 @@
WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
#include "cppIVRSystem_IVRSystem_020.h"
typedef struct __winIVRSystem_IVRSystem_020 {
vtable_ptr *vtable;
void *linux_side;
} winIVRSystem_IVRSystem_020;
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetRecommendedRenderTargetSize, 20)
void __thiscall winIVRSystem_IVRSystem_020_GetRecommendedRenderTargetSize(winIVRSystem_IVRSystem_020 *_this, uint32_t * pnWidth, uint32_t * pnHeight)
{
TRACE("%p\n", _this);
cppIVRSystem_IVRSystem_020_GetRecommendedRenderTargetSize(_this->linux_side, pnWidth, pnHeight);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetProjectionMatrix, 20)
HmdMatrix44_t *__thiscall winIVRSystem_IVRSystem_020_GetProjectionMatrix(winIVRSystem_IVRSystem_020 *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ)
{
TRACE("%p\n", _this);
*_r = cppIVRSystem_IVRSystem_020_GetProjectionMatrix(_this->linux_side, eEye, fNearZ, fFarZ);
return _r;
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetProjectionRaw, 40)
void __thiscall winIVRSystem_IVRSystem_020_GetProjectionRaw(winIVRSystem_IVRSystem_020 *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
{
TRACE("%p\n", _this);
cppIVRSystem_IVRSystem_020_GetProjectionRaw(_this->linux_side, eEye, pfLeft, pfRight, pfTop, pfBottom);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_ComputeDistortion, 24)
bool __thiscall winIVRSystem_IVRSystem_020_ComputeDistortion(winIVRSystem_IVRSystem_020 *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_ComputeDistortion(_this->linux_side, eEye, fU, fV, pDistortionCoordinates);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetEyeToHeadTransform, 12)
HmdMatrix34_t *__thiscall winIVRSystem_IVRSystem_020_GetEyeToHeadTransform(winIVRSystem_IVRSystem_020 *_this, HmdMatrix34_t *_r, EVREye eEye)
{
TRACE("%p\n", _this);
*_r = cppIVRSystem_IVRSystem_020_GetEyeToHeadTransform(_this->linux_side, eEye);
return _r;
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetTimeSinceLastVsync, 20)
bool __thiscall winIVRSystem_IVRSystem_020_GetTimeSinceLastVsync(winIVRSystem_IVRSystem_020 *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetTimeSinceLastVsync(_this->linux_side, pfSecondsSinceLastVsync, pulFrameCounter);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetD3D9AdapterIndex, 4)
int32_t __thiscall winIVRSystem_IVRSystem_020_GetD3D9AdapterIndex(winIVRSystem_IVRSystem_020 *_this)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetD3D9AdapterIndex(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetDXGIOutputInfo, 12)
void __thiscall winIVRSystem_IVRSystem_020_GetDXGIOutputInfo(winIVRSystem_IVRSystem_020 *_this, int32_t * pnAdapterIndex)
{
TRACE("%p\n", _this);
get_dxgi_output_info(cppIVRSystem_IVRSystem_020_GetDXGIOutputInfo, _this->linux_side, pnAdapterIndex, 20);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetOutputDevice, 24)
void __thiscall winIVRSystem_IVRSystem_020_GetOutputDevice(winIVRSystem_IVRSystem_020 *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance)
{
TRACE("%p\n", _this);
ivrsystem_get_output_device(cppIVRSystem_IVRSystem_020_GetOutputDevice, _this->linux_side, pnDevice, textureType, pInstance, 20);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_IsDisplayOnDesktop, 4)
bool __thiscall winIVRSystem_IVRSystem_020_IsDisplayOnDesktop(winIVRSystem_IVRSystem_020 *_this)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_IsDisplayOnDesktop(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_SetDisplayVisibility, 5)
bool __thiscall winIVRSystem_IVRSystem_020_SetDisplayVisibility(winIVRSystem_IVRSystem_020 *_this, bool bIsVisibleOnDesktop)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_SetDisplayVisibility(_this->linux_side, bIsVisibleOnDesktop);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetDeviceToAbsoluteTrackingPose, 24)
void __thiscall winIVRSystem_IVRSystem_020_GetDeviceToAbsoluteTrackingPose(winIVRSystem_IVRSystem_020 *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
{
TRACE("%p\n", _this);
cppIVRSystem_IVRSystem_020_GetDeviceToAbsoluteTrackingPose(_this->linux_side, eOrigin, fPredictedSecondsToPhotonsFromNow, pTrackedDevicePoseArray, unTrackedDevicePoseArrayCount);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_ResetSeatedZeroPose, 4)
void __thiscall winIVRSystem_IVRSystem_020_ResetSeatedZeroPose(winIVRSystem_IVRSystem_020 *_this)
{
TRACE("%p\n", _this);
cppIVRSystem_IVRSystem_020_ResetSeatedZeroPose(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 8)
HmdMatrix34_t *__thiscall winIVRSystem_IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(winIVRSystem_IVRSystem_020 *_this, HmdMatrix34_t *_r)
{
TRACE("%p\n", _this);
*_r = cppIVRSystem_IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(_this->linux_side);
return _r;
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose, 8)
HmdMatrix34_t *__thiscall winIVRSystem_IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose(winIVRSystem_IVRSystem_020 *_this, HmdMatrix34_t *_r)
{
TRACE("%p\n", _this);
*_r = cppIVRSystem_IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose(_this->linux_side);
return _r;
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass, 24)
uint32_t __thiscall winIVRSystem_IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass(winIVRSystem_IVRSystem_020 *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass(_this->linux_side, eTrackedDeviceClass, punTrackedDeviceIndexArray, unTrackedDeviceIndexArrayCount, unRelativeToTrackedDeviceIndex);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetTrackedDeviceActivityLevel, 8)
EDeviceActivityLevel __thiscall winIVRSystem_IVRSystem_020_GetTrackedDeviceActivityLevel(winIVRSystem_IVRSystem_020 *_this, TrackedDeviceIndex_t unDeviceId)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetTrackedDeviceActivityLevel(_this->linux_side, unDeviceId);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_ApplyTransform, 28)
void __thiscall winIVRSystem_IVRSystem_020_ApplyTransform(winIVRSystem_IVRSystem_020 *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
{
TRACE("%p\n", _this);
cppIVRSystem_IVRSystem_020_ApplyTransform(_this->linux_side, pOutputPose, pTrackedDevicePose, pTransform);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetTrackedDeviceIndexForControllerRole, 8)
TrackedDeviceIndex_t __thiscall winIVRSystem_IVRSystem_020_GetTrackedDeviceIndexForControllerRole(winIVRSystem_IVRSystem_020 *_this, ETrackedControllerRole unDeviceType)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetTrackedDeviceIndexForControllerRole(_this->linux_side, unDeviceType);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetControllerRoleForTrackedDeviceIndex, 8)
ETrackedControllerRole __thiscall winIVRSystem_IVRSystem_020_GetControllerRoleForTrackedDeviceIndex(winIVRSystem_IVRSystem_020 *_this, TrackedDeviceIndex_t unDeviceIndex)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetControllerRoleForTrackedDeviceIndex(_this->linux_side, unDeviceIndex);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetTrackedDeviceClass, 8)
ETrackedDeviceClass __thiscall winIVRSystem_IVRSystem_020_GetTrackedDeviceClass(winIVRSystem_IVRSystem_020 *_this, TrackedDeviceIndex_t unDeviceIndex)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetTrackedDeviceClass(_this->linux_side, unDeviceIndex);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_IsTrackedDeviceConnected, 8)
bool __thiscall winIVRSystem_IVRSystem_020_IsTrackedDeviceConnected(winIVRSystem_IVRSystem_020 *_this, TrackedDeviceIndex_t unDeviceIndex)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_IsTrackedDeviceConnected(_this->linux_side, unDeviceIndex);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetBoolTrackedDeviceProperty, 20)
bool __thiscall winIVRSystem_IVRSystem_020_GetBoolTrackedDeviceProperty(winIVRSystem_IVRSystem_020 *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetBoolTrackedDeviceProperty(_this->linux_side, unDeviceIndex, prop, pError);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetFloatTrackedDeviceProperty, 20)
float __thiscall winIVRSystem_IVRSystem_020_GetFloatTrackedDeviceProperty(winIVRSystem_IVRSystem_020 *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetFloatTrackedDeviceProperty(_this->linux_side, unDeviceIndex, prop, pError);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetInt32TrackedDeviceProperty, 20)
int32_t __thiscall winIVRSystem_IVRSystem_020_GetInt32TrackedDeviceProperty(winIVRSystem_IVRSystem_020 *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetInt32TrackedDeviceProperty(_this->linux_side, unDeviceIndex, prop, pError);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetUint64TrackedDeviceProperty, 20)
uint64_t __thiscall winIVRSystem_IVRSystem_020_GetUint64TrackedDeviceProperty(winIVRSystem_IVRSystem_020 *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetUint64TrackedDeviceProperty(_this->linux_side, unDeviceIndex, prop, pError);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetMatrix34TrackedDeviceProperty, 24)
HmdMatrix34_t *__thiscall winIVRSystem_IVRSystem_020_GetMatrix34TrackedDeviceProperty(winIVRSystem_IVRSystem_020 *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
{
TRACE("%p\n", _this);
*_r = cppIVRSystem_IVRSystem_020_GetMatrix34TrackedDeviceProperty(_this->linux_side, unDeviceIndex, prop, pError);
return _r;
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetArrayTrackedDeviceProperty, 36)
uint32_t __thiscall winIVRSystem_IVRSystem_020_GetArrayTrackedDeviceProperty(winIVRSystem_IVRSystem_020 *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetArrayTrackedDeviceProperty(_this->linux_side, unDeviceIndex, prop, propType, pBuffer, unBufferSize, pError);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetStringTrackedDeviceProperty, 32)
uint32_t __thiscall winIVRSystem_IVRSystem_020_GetStringTrackedDeviceProperty(winIVRSystem_IVRSystem_020 *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetStringTrackedDeviceProperty(_this->linux_side, unDeviceIndex, prop, pchValue, unBufferSize, pError);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetPropErrorNameFromEnum, 8)
const char * __thiscall winIVRSystem_IVRSystem_020_GetPropErrorNameFromEnum(winIVRSystem_IVRSystem_020 *_this, ETrackedPropertyError error)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetPropErrorNameFromEnum(_this->linux_side, error);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_PollNextEvent, 16)
bool __thiscall winIVRSystem_IVRSystem_020_PollNextEvent(winIVRSystem_IVRSystem_020 *_this, winVREvent_t_1517 * pEvent, uint32_t uncbVREvent)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_PollNextEvent(_this->linux_side, pEvent, uncbVREvent);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_PollNextEventWithPose, 28)
bool __thiscall winIVRSystem_IVRSystem_020_PollNextEventWithPose(winIVRSystem_IVRSystem_020 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1517 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_PollNextEventWithPose(_this->linux_side, eOrigin, pEvent, uncbVREvent, pTrackedDevicePose);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetEventTypeNameFromEnum, 8)
const char * __thiscall winIVRSystem_IVRSystem_020_GetEventTypeNameFromEnum(winIVRSystem_IVRSystem_020 *_this, EVREventType eType)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetEventTypeNameFromEnum(_this->linux_side, eType);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetHiddenAreaMesh, 16)
HiddenAreaMesh_t *__thiscall winIVRSystem_IVRSystem_020_GetHiddenAreaMesh(winIVRSystem_IVRSystem_020 *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type)
{
TRACE("%p\n", _this);
*_r = cppIVRSystem_IVRSystem_020_GetHiddenAreaMesh(_this->linux_side, eEye, type);
return _r;
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetControllerState, 20)
bool __thiscall winIVRSystem_IVRSystem_020_GetControllerState(winIVRSystem_IVRSystem_020 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1517 * pControllerState, uint32_t unControllerStateSize)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetControllerState(_this->linux_side, unControllerDeviceIndex, pControllerState, unControllerStateSize);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetControllerStateWithPose, 32)
bool __thiscall winIVRSystem_IVRSystem_020_GetControllerStateWithPose(winIVRSystem_IVRSystem_020 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1517 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetControllerStateWithPose(_this->linux_side, eOrigin, unControllerDeviceIndex, pControllerState, unControllerStateSize, pTrackedDevicePose);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_TriggerHapticPulse, 14)
void __thiscall winIVRSystem_IVRSystem_020_TriggerHapticPulse(winIVRSystem_IVRSystem_020 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
{
TRACE("%p\n", _this);
cppIVRSystem_IVRSystem_020_TriggerHapticPulse(_this->linux_side, unControllerDeviceIndex, unAxisId, usDurationMicroSec);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetButtonIdNameFromEnum, 8)
const char * __thiscall winIVRSystem_IVRSystem_020_GetButtonIdNameFromEnum(winIVRSystem_IVRSystem_020 *_this, EVRButtonId eButtonId)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetButtonIdNameFromEnum(_this->linux_side, eButtonId);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetControllerAxisTypeNameFromEnum, 8)
const char * __thiscall winIVRSystem_IVRSystem_020_GetControllerAxisTypeNameFromEnum(winIVRSystem_IVRSystem_020 *_this, EVRControllerAxisType eAxisType)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetControllerAxisTypeNameFromEnum(_this->linux_side, eAxisType);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_IsInputAvailable, 4)
bool __thiscall winIVRSystem_IVRSystem_020_IsInputAvailable(winIVRSystem_IVRSystem_020 *_this)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_IsInputAvailable(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_IsSteamVRDrawingControllers, 4)
bool __thiscall winIVRSystem_IVRSystem_020_IsSteamVRDrawingControllers(winIVRSystem_IVRSystem_020 *_this)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_IsSteamVRDrawingControllers(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_ShouldApplicationPause, 4)
bool __thiscall winIVRSystem_IVRSystem_020_ShouldApplicationPause(winIVRSystem_IVRSystem_020 *_this)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_ShouldApplicationPause(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_ShouldApplicationReduceRenderingWork, 4)
bool __thiscall winIVRSystem_IVRSystem_020_ShouldApplicationReduceRenderingWork(winIVRSystem_IVRSystem_020 *_this)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_ShouldApplicationReduceRenderingWork(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_PerformFirmwareUpdate, 8)
EVRFirmwareError __thiscall winIVRSystem_IVRSystem_020_PerformFirmwareUpdate(winIVRSystem_IVRSystem_020 *_this, TrackedDeviceIndex_t unDeviceIndex)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_PerformFirmwareUpdate(_this->linux_side, unDeviceIndex);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_AcknowledgeQuit_Exiting, 4)
void __thiscall winIVRSystem_IVRSystem_020_AcknowledgeQuit_Exiting(winIVRSystem_IVRSystem_020 *_this)
{
TRACE("%p\n", _this);
cppIVRSystem_IVRSystem_020_AcknowledgeQuit_Exiting(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_AcknowledgeQuit_UserPrompt, 4)
void __thiscall winIVRSystem_IVRSystem_020_AcknowledgeQuit_UserPrompt(winIVRSystem_IVRSystem_020 *_this)
{
TRACE("%p\n", _this);
cppIVRSystem_IVRSystem_020_AcknowledgeQuit_UserPrompt(_this->linux_side);
}
extern vtable_ptr winIVRSystem_IVRSystem_020_vtable;
#ifndef __GNUC__
void __asm_dummy_vtables(void) {
#endif
__ASM_VTABLE(winIVRSystem_IVRSystem_020,
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetRecommendedRenderTargetSize)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetProjectionMatrix)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetProjectionRaw)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_ComputeDistortion)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetEyeToHeadTransform)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetTimeSinceLastVsync)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetD3D9AdapterIndex)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetDXGIOutputInfo)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetOutputDevice)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_IsDisplayOnDesktop)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_SetDisplayVisibility)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetDeviceToAbsoluteTrackingPose)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_ResetSeatedZeroPose)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetTrackedDeviceActivityLevel)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_ApplyTransform)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetTrackedDeviceIndexForControllerRole)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetControllerRoleForTrackedDeviceIndex)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetTrackedDeviceClass)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_IsTrackedDeviceConnected)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetBoolTrackedDeviceProperty)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetFloatTrackedDeviceProperty)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetInt32TrackedDeviceProperty)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetUint64TrackedDeviceProperty)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetMatrix34TrackedDeviceProperty)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetArrayTrackedDeviceProperty)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetStringTrackedDeviceProperty)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetPropErrorNameFromEnum)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_PollNextEvent)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_PollNextEventWithPose)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetEventTypeNameFromEnum)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetHiddenAreaMesh)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetControllerState)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetControllerStateWithPose)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_TriggerHapticPulse)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetButtonIdNameFromEnum)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetControllerAxisTypeNameFromEnum)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_IsInputAvailable)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_IsSteamVRDrawingControllers)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_ShouldApplicationPause)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_ShouldApplicationReduceRenderingWork)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_PerformFirmwareUpdate)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_AcknowledgeQuit_Exiting)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_AcknowledgeQuit_UserPrompt)
);
#ifndef __GNUC__
}
#endif
winIVRSystem_IVRSystem_020 *create_winIVRSystem_IVRSystem_020(void *linux_side)
{
winIVRSystem_IVRSystem_020 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_020));
TRACE("-> %p\n", r);
r->vtable = &winIVRSystem_IVRSystem_020_vtable;
r->linux_side = linux_side;
return r;
}
void destroy_winIVRSystem_IVRSystem_020(void *object)
{
TRACE("%p\n", object);
HeapFree(GetProcessHeap(), 0, object);
}
winIVRSystem_IVRSystem_020 *create_winIVRSystem_IVRSystem_020_FnTable(void *linux_side)
{
winIVRSystem_IVRSystem_020 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_020));
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);
init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_020_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_020_GetProjectionMatrix, 4, TRUE, TRUE);
init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_020_GetProjectionRaw, 5, FALSE, FALSE);
init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_020_ComputeDistortion, 4, TRUE, FALSE);
init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_020_GetEyeToHeadTransform, 2, FALSE, FALSE);
init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_020_GetTimeSinceLastVsync, 2, FALSE, FALSE);
init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_020_GetD3D9AdapterIndex, 0, FALSE, FALSE);
init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_020_GetDXGIOutputInfo, 1, FALSE, FALSE);
init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_020_GetOutputDevice, 3, FALSE, FALSE);
init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_020_IsDisplayOnDesktop, 0, FALSE, FALSE);
init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_020_SetDisplayVisibility, 1, FALSE, FALSE);
init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_020_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_020_ResetSeatedZeroPose, 0, FALSE, FALSE);
init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_020_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_020_ApplyTransform, 3, FALSE, FALSE);
init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_020_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_020_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_020_GetTrackedDeviceClass, 1, FALSE, FALSE);
init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_020_IsTrackedDeviceConnected, 1, FALSE, FALSE);
init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_020_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_020_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_020_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_020_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_020_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_020_GetArrayTrackedDeviceProperty, 6, FALSE, FALSE);
init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_020_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_020_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_020_PollNextEvent, 2, FALSE, FALSE);
init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_020_PollNextEventWithPose, 4, FALSE, FALSE);
init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_020_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_020_GetHiddenAreaMesh, 3, FALSE, FALSE);
init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_020_GetControllerState, 3, FALSE, FALSE);
init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_020_GetControllerStateWithPose, 5, FALSE, FALSE);
init_thunk(&thunks[36], r, winIVRSystem_IVRSystem_020_TriggerHapticPulse, 3, FALSE, FALSE);
init_thunk(&thunks[37], r, winIVRSystem_IVRSystem_020_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
init_thunk(&thunks[38], r, winIVRSystem_IVRSystem_020_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
init_thunk(&thunks[39], r, winIVRSystem_IVRSystem_020_IsInputAvailable, 0, FALSE, FALSE);
init_thunk(&thunks[40], r, winIVRSystem_IVRSystem_020_IsSteamVRDrawingControllers, 0, FALSE, FALSE);
init_thunk(&thunks[41], r, winIVRSystem_IVRSystem_020_ShouldApplicationPause, 0, FALSE, FALSE);
init_thunk(&thunks[42], r, winIVRSystem_IVRSystem_020_ShouldApplicationReduceRenderingWork, 0, FALSE, FALSE);
init_thunk(&thunks[43], r, winIVRSystem_IVRSystem_020_PerformFirmwareUpdate, 1, FALSE, FALSE);
init_thunk(&thunks[44], r, winIVRSystem_IVRSystem_020_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
init_thunk(&thunks[45], r, winIVRSystem_IVRSystem_020_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
for (i = 0; i < 46; i++)
vtable[i] = &thunks[i];
r->linux_side = linux_side;
r->vtable = (void *)vtable;
return r;
}
void destroy_winIVRSystem_IVRSystem_020_FnTable(void *object)
{
winIVRSystem_IVRSystem_020 *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 "cppIVRSystem_IVRSystem_019.h"
typedef struct __winIVRSystem_IVRSystem_019 {

12
vrclient_x64/vrclient_x64/win_constructors.h
View file

@ -1,5 +1,5 @@
extern void *create_winIVRSystem_IVRSystem_019(void *);
extern void *create_winIVRSystem_IVRSystem_019_FnTable(void *);
extern void *create_winIVRSystem_IVRSystem_020(void *);
extern void *create_winIVRSystem_IVRSystem_020_FnTable(void *);
extern void *create_winIVRApplications_IVRApplications_006(void *);
extern void *create_winIVRApplications_IVRApplications_006_FnTable(void *);
extern void *create_winIVRSettings_IVRSettings_002(void *);
@ -26,12 +26,16 @@ 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_006(void *);
extern void *create_winIVRInput_IVRInput_006_FnTable(void *);
extern void *create_winIVRInput_IVRInput_007(void *);
extern void *create_winIVRInput_IVRInput_007_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_winIVRSystem_IVRSystem_019(void *);
extern void *create_winIVRSystem_IVRSystem_019_FnTable(void *);
extern void *create_winIVRInput_IVRInput_006(void *);
extern void *create_winIVRInput_IVRInput_006_FnTable(void *);
extern void *create_winIVRInput_IVRInput_005(void *);
extern void *create_winIVRInput_IVRInput_005_FnTable(void *);
extern void *create_winIVRIOBuffer_IVRIOBuffer_001(void *);

12
vrclient_x64/vrclient_x64/win_constructors_table.dat
View file

@ -1,5 +1,5 @@
{"IVRSystem_019", &create_winIVRSystem_IVRSystem_019, &destroy_winIVRSystem_IVRSystem_019},
{"FnTable:IVRSystem_019", &create_winIVRSystem_IVRSystem_019_FnTable, &destroy_winIVRSystem_IVRSystem_019_FnTable},
{"IVRSystem_020", &create_winIVRSystem_IVRSystem_020, &destroy_winIVRSystem_IVRSystem_020},
{"FnTable:IVRSystem_020", &create_winIVRSystem_IVRSystem_020_FnTable, &destroy_winIVRSystem_IVRSystem_020_FnTable},
{"IVRApplications_006", &create_winIVRApplications_IVRApplications_006, &destroy_winIVRApplications_IVRApplications_006},
{"FnTable:IVRApplications_006", &create_winIVRApplications_IVRApplications_006_FnTable, &destroy_winIVRApplications_IVRApplications_006_FnTable},
{"IVRSettings_002", &create_winIVRSettings_IVRSettings_002, &destroy_winIVRSettings_IVRSettings_002},
@ -26,12 +26,16 @@
{"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_006", &create_winIVRInput_IVRInput_006, &destroy_winIVRInput_IVRInput_006},
{"FnTable:IVRInput_006", &create_winIVRInput_IVRInput_006_FnTable, &destroy_winIVRInput_IVRInput_006_FnTable},
{"IVRInput_007", &create_winIVRInput_IVRInput_007, &destroy_winIVRInput_IVRInput_007},
{"FnTable:IVRInput_007", &create_winIVRInput_IVRInput_007_FnTable, &destroy_winIVRInput_IVRInput_007_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},
{"IVRSystem_019", &create_winIVRSystem_IVRSystem_019, &destroy_winIVRSystem_IVRSystem_019},
{"FnTable:IVRSystem_019", &create_winIVRSystem_IVRSystem_019_FnTable, &destroy_winIVRSystem_IVRSystem_019_FnTable},
{"IVRInput_006", &create_winIVRInput_IVRInput_006, &destroy_winIVRInput_IVRInput_006},
{"FnTable:IVRInput_006", &create_winIVRInput_IVRInput_006_FnTable, &destroy_winIVRInput_IVRInput_006_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},

12
vrclient_x64/vrclient_x64/win_destructors.h
View file

@ -1,5 +1,5 @@
extern void destroy_winIVRSystem_IVRSystem_019(void *);
extern void destroy_winIVRSystem_IVRSystem_019_FnTable(void *);
extern void destroy_winIVRSystem_IVRSystem_020(void *);
extern void destroy_winIVRSystem_IVRSystem_020_FnTable(void *);
extern void destroy_winIVRApplications_IVRApplications_006(void *);
extern void destroy_winIVRApplications_IVRApplications_006_FnTable(void *);
extern void destroy_winIVRSettings_IVRSettings_002(void *);
@ -26,12 +26,16 @@ 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_006(void *);
extern void destroy_winIVRInput_IVRInput_006_FnTable(void *);
extern void destroy_winIVRInput_IVRInput_007(void *);
extern void destroy_winIVRInput_IVRInput_007_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_winIVRSystem_IVRSystem_019(void *);
extern void destroy_winIVRSystem_IVRSystem_019_FnTable(void *);
extern void destroy_winIVRInput_IVRInput_006(void *);
extern void destroy_winIVRInput_IVRInput_006_FnTable(void *);
extern void destroy_winIVRInput_IVRInput_005(void *);
extern void destroy_winIVRInput_IVRInput_005_FnTable(void *);
extern void destroy_winIVRIOBuffer_IVRIOBuffer_001(void *);