Valve/Proton
1
0
Fork 0
mirror of https://github.com/ValveSoftware/Proton.git synced 2024-12-26 06:35:46 +03:00
Code Issues Packages Projects Releases Wiki Activity

vrclient: Import openvr v1.0.13, v1.0.14, and v1.0.15

Browse Source
This commit is contained in:
Andrew Eikum 2018-06-05 09:37:23 -05:00
parent d472d536cf
commit af59703d41
35 changed files with 12784 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
vrclient_x64/cppIVRApplications_IVRApplications_006.cpp
View File

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

2
vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_005.cpp
View File

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

2
vrclient_x64/cppIVRChaperone_IVRChaperone_003.cpp
View File

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

2
vrclient_x64/cppIVRClientCore_IVRClientCore_003.cpp
View File

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

2
vrclient_x64/cppIVRCompositor_IVRCompositor_022.cpp
View File

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

7
vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.0.12/ivrclientcore.h"
#include "openvr_v1.0.15/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
@ -19,6 +19,11 @@ uint32_t cppIVRDriverManager_IVRDriverManager_001_GetDriverName(void *linux_side
return ((IVRDriverManager*)linux_side)->GetDriverName((vr::DriverId_t)nDriver, (char *)pchValue, (uint32_t)unBufferSize);
}
vr::DriverHandle_t cppIVRDriverManager_IVRDriverManager_001_GetDriverHandle(void *linux_side, const char * pchDriverName)
{
return ((IVRDriverManager*)linux_side)->GetDriverHandle((const char *)pchDriverName);
}
#ifdef __cplusplus
}
#endif

1
vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.h
View File

@ -3,6 +3,7 @@ extern "C" {
#endif
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 *);
#ifdef __cplusplus
}
#endif

2
vrclient_x64/cppIVRExtendedDisplay_IVRExtendedDisplay_001.cpp
View File

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

2
vrclient_x64/cppIVRNotifications_IVRNotifications_002.cpp
View File

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

6
vrclient_x64/cppIVROverlay_IVROverlay_018.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.0.12/ivrclientcore.h"
#include "openvr_v1.0.15/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
@ -234,12 +234,12 @@ vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetTransformForOverlayCoordinat
return ((IVROverlay*)linux_side)->GetTransformForOverlayCoordinates((vr::VROverlayHandle_t)ulOverlayHandle, (vr::ETrackingUniverseOrigin)eTrackingOrigin, (vr::HmdVector2_t)coordinatesInOverlay, (vr::HmdMatrix34_t *)pmatTransform);
}
bool cppIVROverlay_IVROverlay_018_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1012 * pEvent, uint32_t uncbVREvent)
bool cppIVROverlay_IVROverlay_018_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1015 * pEvent, uint32_t uncbVREvent)
{
VREvent_t lin;
bool _ret;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, &lin, sizeof(lin));
struct_VREvent_t_1012_lin_to_win(&lin, pEvent);
struct_VREvent_t_1015_lin_to_win(&lin, pEvent);
return _ret;
}

2
vrclient_x64/cppIVROverlay_IVROverlay_018.h
View File

@ -46,7 +46,7 @@ extern EVROverlayError cppIVROverlay_IVROverlay_018_ShowOverlay(void *, VROverla
extern EVROverlayError cppIVROverlay_IVROverlay_018_HideOverlay(void *, VROverlayHandle_t);
extern bool cppIVROverlay_IVROverlay_018_IsOverlayVisible(void *, VROverlayHandle_t);
extern EVROverlayError cppIVROverlay_IVROverlay_018_GetTransformForOverlayCoordinates(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdVector2_t, HmdMatrix34_t *);
extern bool cppIVROverlay_IVROverlay_018_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1012 *, uint32_t);
extern bool cppIVROverlay_IVROverlay_018_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1015 *, uint32_t);
extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod *);
extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod);
extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);

18
vrclient_x64/cppIVRRenderModels_IVRRenderModels_005.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.0.12/ivrclientcore.h"
#include "openvr_v1.0.15/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_005_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1012 ** ppRenderModel)
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1015 ** ppRenderModel)
{
RenderModel_t *lin;
vr::EVRRenderModelError _ret;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, &lin);
if(_ret == 0)
*ppRenderModel = struct_RenderModel_t_1012_wrap(lin);
*ppRenderModel = struct_RenderModel_t_1015_wrap(lin);
return _ret;
}
void cppIVRRenderModels_IVRRenderModels_005_FreeRenderModel(void *linux_side, winRenderModel_t_1012 * pRenderModel)
void cppIVRRenderModels_IVRRenderModels_005_FreeRenderModel(void *linux_side, winRenderModel_t_1015 * pRenderModel)
{
((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1012_unwrap(pRenderModel));
((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1015_unwrap(pRenderModel));
}
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1012 ** ppTexture)
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1015 ** 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_1012_wrap(lin);
*ppTexture = struct_RenderModel_TextureMap_t_1015_wrap(lin);
return _ret;
}
void cppIVRRenderModels_IVRRenderModels_005_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1012 * pTexture)
void cppIVRRenderModels_IVRRenderModels_005_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1015 * pTexture)
{
((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1012_unwrap(pTexture));
((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1015_unwrap(pTexture));
}
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadTextureD3D11_Async(void *linux_side, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D)

8
vrclient_x64/cppIVRRenderModels_IVRRenderModels_005.h
View File

@ -1,10 +1,10 @@
#ifdef __cplusplus
extern "C" {
#endif
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1012 **);
extern void cppIVRRenderModels_IVRRenderModels_005_FreeRenderModel(void *, winRenderModel_t_1012 *);
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1012 **);
extern void cppIVRRenderModels_IVRRenderModels_005_FreeTexture(void *, winRenderModel_TextureMap_t_1012 *);
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1015 **);
extern void cppIVRRenderModels_IVRRenderModels_005_FreeRenderModel(void *, winRenderModel_t_1015 *);
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1015 **);
extern void cppIVRRenderModels_IVRRenderModels_005_FreeTexture(void *, winRenderModel_TextureMap_t_1015 *);
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadTextureD3D11_Async(void *, TextureID_t, void *, void **);
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadIntoTextureD3D11_Async(void *, TextureID_t, void *);
extern void cppIVRRenderModels_IVRRenderModels_005_FreeTextureD3D11(void *, void *);

2
vrclient_x64/cppIVRResources_IVRResources_001.cpp
View File

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

2
vrclient_x64/cppIVRScreenshots_IVRScreenshots_001.cpp
View File

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

2
vrclient_x64/cppIVRSettings_IVRSettings_002.cpp
View File

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

18
vrclient_x64/cppIVRSystem_IVRSystem_019.cpp
View File

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.0.12/ivrclientcore.h"
#include "openvr_v1.0.15/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
@ -159,21 +159,21 @@ const char * cppIVRSystem_IVRSystem_019_GetPropErrorNameFromEnum(void *linux_sid
return ((IVRSystem*)linux_side)->GetPropErrorNameFromEnum((vr::ETrackedPropertyError)error);
}
bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *linux_side, winVREvent_t_1012 * pEvent, uint32_t uncbVREvent)
bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *linux_side, winVREvent_t_1015 * pEvent, uint32_t uncbVREvent)
{
VREvent_t lin;
bool _ret;
_ret = ((IVRSystem*)linux_side)->PollNextEvent(&lin, sizeof(lin));
struct_VREvent_t_1012_lin_to_win(&lin, pEvent);
struct_VREvent_t_1015_lin_to_win(&lin, pEvent);
return _ret;
}
bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1012 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1015 * 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_1012_lin_to_win(&lin, pEvent);
struct_VREvent_t_1015_lin_to_win(&lin, pEvent);
return _ret;
}
@ -187,21 +187,21 @@ vr::HiddenAreaMesh_t cppIVRSystem_IVRSystem_019_GetHiddenAreaMesh(void *linux_si
return ((IVRSystem*)linux_side)->GetHiddenAreaMesh((vr::EVREye)eEye, (vr::EHiddenAreaMeshType)type);
}
bool cppIVRSystem_IVRSystem_019_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1012 * pControllerState, uint32_t unControllerStateSize)
bool cppIVRSystem_IVRSystem_019_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1015 * pControllerState, uint32_t unControllerStateSize)
{
VRControllerState001_t lin;
bool _ret;
_ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, &lin, sizeof(lin));
struct_VRControllerState001_t_1012_lin_to_win(&lin, pControllerState);
struct_VRControllerState001_t_1015_lin_to_win(&lin, pControllerState);
return _ret;
}
bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1012 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1015 * 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_1012_lin_to_win(&lin, pControllerState);
struct_VRControllerState001_t_1015_lin_to_win(&lin, pControllerState);
return _ret;
}

8
vrclient_x64/cppIVRSystem_IVRSystem_019.h
View File

@ -31,12 +31,12 @@ extern HmdMatrix34_t cppIVRSystem_IVRSystem_019_GetMatrix34TrackedDeviceProperty
extern uint32_t cppIVRSystem_IVRSystem_019_GetArrayTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, PropertyTypeTag_t, void *, uint32_t, ETrackedPropertyError *);
extern uint32_t cppIVRSystem_IVRSystem_019_GetStringTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, char *, uint32_t, ETrackedPropertyError *);
extern const char * cppIVRSystem_IVRSystem_019_GetPropErrorNameFromEnum(void *, ETrackedPropertyError);
extern bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *, winVREvent_t_1012 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1012 *, uint32_t, TrackedDevicePose_t *);
extern bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *, winVREvent_t_1015 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1015 *, uint32_t, TrackedDevicePose_t *);
extern const char * cppIVRSystem_IVRSystem_019_GetEventTypeNameFromEnum(void *, EVREventType);
extern HiddenAreaMesh_t cppIVRSystem_IVRSystem_019_GetHiddenAreaMesh(void *, EVREye, EHiddenAreaMeshType);
extern bool cppIVRSystem_IVRSystem_019_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1012 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1012 *, uint32_t, TrackedDevicePose_t *);
extern bool cppIVRSystem_IVRSystem_019_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1015 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1015 *, uint32_t, TrackedDevicePose_t *);
extern void cppIVRSystem_IVRSystem_019_TriggerHapticPulse(void *, TrackedDeviceIndex_t, uint32_t, unsigned short);
extern const char * cppIVRSystem_IVRSystem_019_GetButtonIdNameFromEnum(void *, EVRButtonId);
extern const char * cppIVRSystem_IVRSystem_019_GetControllerAxisTypeNameFromEnum(void *, EVRControllerAxisType);

2
vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_003.cpp
View File

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

3
vrclient_x64/gen_wrapper.py
View File

@ -10,6 +10,9 @@ import os
import re
sdk_versions = [
"v1.0.15",
"v1.0.14",
"v1.0.13",
"v1.0.12",
"v1.0.11",
"v1.0.10",

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

3959
vrclient_x64/openvr_v1.0.13/openvr.h Normal file
View File

File diff suppressed because it is too large Load Diff

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

3991
vrclient_x64/openvr_v1.0.14/openvr.h Normal file
View File

File diff suppressed because it is too large Load Diff

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

4322
vrclient_x64/openvr_v1.0.15/openvr.h Normal file
View File

File diff suppressed because it is too large Load Diff

30
vrclient_x64/struct_converters.h
View File

@ -1,3 +1,33 @@
typedef struct winVREvent_t_1015 winVREvent_t_1015;
extern void struct_VREvent_t_1015_lin_to_win(void *l, void *w);
typedef struct winVRControllerState001_t_1015 winVRControllerState001_t_1015;
extern void struct_VRControllerState001_t_1015_lin_to_win(void *l, void *w);
typedef struct winRenderModel_TextureMap_t_1015 winRenderModel_TextureMap_t_1015;
extern struct winRenderModel_TextureMap_t_1015 *struct_RenderModel_TextureMap_t_1015_wrap(void *l);
extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1015_unwrap(winRenderModel_TextureMap_t_1015 *w);
typedef struct winRenderModel_t_1015 winRenderModel_t_1015;
extern struct winRenderModel_t_1015 *struct_RenderModel_t_1015_wrap(void *l);
extern RenderModel_t *struct_RenderModel_t_1015_unwrap(winRenderModel_t_1015 *w);
typedef struct winVREvent_t_1014 winVREvent_t_1014;
extern void struct_VREvent_t_1014_lin_to_win(void *l, void *w);
typedef struct winVRControllerState001_t_1014 winVRControllerState001_t_1014;
extern void struct_VRControllerState001_t_1014_lin_to_win(void *l, void *w);
typedef struct winRenderModel_TextureMap_t_1014 winRenderModel_TextureMap_t_1014;
extern struct winRenderModel_TextureMap_t_1014 *struct_RenderModel_TextureMap_t_1014_wrap(void *l);
extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1014_unwrap(winRenderModel_TextureMap_t_1014 *w);
typedef struct winRenderModel_t_1014 winRenderModel_t_1014;
extern struct winRenderModel_t_1014 *struct_RenderModel_t_1014_wrap(void *l);
extern RenderModel_t *struct_RenderModel_t_1014_unwrap(winRenderModel_t_1014 *w);
typedef struct winVREvent_t_1013 winVREvent_t_1013;
extern void struct_VREvent_t_1013_lin_to_win(void *l, void *w);
typedef struct winVRControllerState001_t_1013 winVRControllerState001_t_1013;
extern void struct_VRControllerState001_t_1013_lin_to_win(void *l, void *w);
typedef struct winRenderModel_TextureMap_t_1013 winRenderModel_TextureMap_t_1013;
extern struct winRenderModel_TextureMap_t_1013 *struct_RenderModel_TextureMap_t_1013_wrap(void *l);
extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1013_unwrap(winRenderModel_TextureMap_t_1013 *w);
typedef struct winRenderModel_t_1013 winRenderModel_t_1013;
extern struct winRenderModel_t_1013 *struct_RenderModel_t_1013_wrap(void *l);
extern RenderModel_t *struct_RenderModel_t_1013_unwrap(winRenderModel_t_1013 *w);
typedef struct winVREvent_t_1012 winVREvent_t_1012;
extern void struct_VREvent_t_1012_lin_to_win(void *l, void *w);
typedef struct winVRControllerState001_t_1012 winVRControllerState001_t_1012;

100
vrclient_x64/struct_converters_1013.cpp Normal file
View File

@ -0,0 +1,100 @@
#include <stdlib.h>
#include <string.h>
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.0.13/openvr.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
struct winVREvent_t_1013 {
uint32_t eventType;
vr::TrackedDeviceIndex_t trackedDeviceIndex;
float eventAgeSeconds;
vr::VREvent_Data_t data;
} __attribute__ ((ms_struct));
void struct_VREvent_t_1013_lin_to_win(void *l, void *w)
{
struct winVREvent_t_1013 *win = (struct winVREvent_t_1013 *)w;
VREvent_t *lin = (VREvent_t *)l;
win->eventType = lin->eventType;
win->trackedDeviceIndex = lin->trackedDeviceIndex;
win->eventAgeSeconds = lin->eventAgeSeconds;
win->data = lin->data;
}
struct winVRControllerState001_t_1013 {
uint32_t unPacketNum;
uint64_t ulButtonPressed;
uint64_t ulButtonTouched;
vr::VRControllerAxis_t rAxis[5];
} __attribute__ ((ms_struct));
void struct_VRControllerState001_t_1013_lin_to_win(void *l, void *w)
{
struct winVRControllerState001_t_1013 *win = (struct winVRControllerState001_t_1013 *)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));
}
struct winRenderModel_TextureMap_t_1013 {
uint16_t unWidth;
uint16_t unHeight;
const uint8_t * rubTextureMapData;
RenderModel_TextureMap_t *linux_side;
} __attribute__ ((ms_struct));
struct winRenderModel_TextureMap_t_1013 *struct_RenderModel_TextureMap_t_1013_wrap(void *l)
{
struct winRenderModel_TextureMap_t_1013 *win = (struct winRenderModel_TextureMap_t_1013 *)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_1013_unwrap(winRenderModel_TextureMap_t_1013 *w)
{
RenderModel_TextureMap_t *ret = w->linux_side;
free(w);
return ret;
}
struct winRenderModel_t_1013 {
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));
struct winRenderModel_t_1013 *struct_RenderModel_t_1013_wrap(void *l)
{
struct winRenderModel_t_1013 *win = (struct winRenderModel_t_1013 *)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_1013_unwrap(winRenderModel_t_1013 *w)
{
RenderModel_t *ret = w->linux_side;
free(w);
return ret;
}
}

100
vrclient_x64/struct_converters_1014.cpp Normal file
View File

@ -0,0 +1,100 @@
#include <stdlib.h>
#include <string.h>
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.0.14/openvr.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
struct winVREvent_t_1014 {
uint32_t eventType;
vr::TrackedDeviceIndex_t trackedDeviceIndex;
float eventAgeSeconds;
vr::VREvent_Data_t data;
} __attribute__ ((ms_struct));
void struct_VREvent_t_1014_lin_to_win(void *l, void *w)
{
struct winVREvent_t_1014 *win = (struct winVREvent_t_1014 *)w;
VREvent_t *lin = (VREvent_t *)l;
win->eventType = lin->eventType;
win->trackedDeviceIndex = lin->trackedDeviceIndex;
win->eventAgeSeconds = lin->eventAgeSeconds;
win->data = lin->data;
}
struct winVRControllerState001_t_1014 {
uint32_t unPacketNum;
uint64_t ulButtonPressed;
uint64_t ulButtonTouched;
vr::VRControllerAxis_t rAxis[5];
} __attribute__ ((ms_struct));
void struct_VRControllerState001_t_1014_lin_to_win(void *l, void *w)
{
struct winVRControllerState001_t_1014 *win = (struct winVRControllerState001_t_1014 *)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));
}
struct winRenderModel_TextureMap_t_1014 {
uint16_t unWidth;
uint16_t unHeight;
const uint8_t * rubTextureMapData;
RenderModel_TextureMap_t *linux_side;
} __attribute__ ((ms_struct));
struct winRenderModel_TextureMap_t_1014 *struct_RenderModel_TextureMap_t_1014_wrap(void *l)
{
struct winRenderModel_TextureMap_t_1014 *win = (struct winRenderModel_TextureMap_t_1014 *)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_1014_unwrap(winRenderModel_TextureMap_t_1014 *w)
{
RenderModel_TextureMap_t *ret = w->linux_side;
free(w);
return ret;
}
struct winRenderModel_t_1014 {
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));
struct winRenderModel_t_1014 *struct_RenderModel_t_1014_wrap(void *l)
{
struct winRenderModel_t_1014 *win = (struct winRenderModel_t_1014 *)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_1014_unwrap(winRenderModel_t_1014 *w)
{
RenderModel_t *ret = w->linux_side;
free(w);
return ret;
}
}

100
vrclient_x64/struct_converters_1015.cpp Normal file
View File

@ -0,0 +1,100 @@
#include <stdlib.h>
#include <string.h>
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.0.15/openvr.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
struct winVREvent_t_1015 {
uint32_t eventType;
vr::TrackedDeviceIndex_t trackedDeviceIndex;
float eventAgeSeconds;
vr::VREvent_Data_t data;
} __attribute__ ((ms_struct));
void struct_VREvent_t_1015_lin_to_win(void *l, void *w)
{
struct winVREvent_t_1015 *win = (struct winVREvent_t_1015 *)w;
VREvent_t *lin = (VREvent_t *)l;
win->eventType = lin->eventType;
win->trackedDeviceIndex = lin->trackedDeviceIndex;
win->eventAgeSeconds = lin->eventAgeSeconds;
win->data = lin->data;
}
struct winVRControllerState001_t_1015 {
uint32_t unPacketNum;
uint64_t ulButtonPressed;
uint64_t ulButtonTouched;
vr::VRControllerAxis_t rAxis[5];
} __attribute__ ((ms_struct));
void struct_VRControllerState001_t_1015_lin_to_win(void *l, void *w)
{
struct winVRControllerState001_t_1015 *win = (struct winVRControllerState001_t_1015 *)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));
}
struct winRenderModel_TextureMap_t_1015 {
uint16_t unWidth;
uint16_t unHeight;
const uint8_t * rubTextureMapData;
RenderModel_TextureMap_t *linux_side;
} __attribute__ ((ms_struct));
struct winRenderModel_TextureMap_t_1015 *struct_RenderModel_TextureMap_t_1015_wrap(void *l)
{
struct winRenderModel_TextureMap_t_1015 *win = (struct winRenderModel_TextureMap_t_1015 *)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_1015_unwrap(winRenderModel_TextureMap_t_1015 *w)
{
RenderModel_TextureMap_t *ret = w->linux_side;
free(w);
return ret;
}
struct winRenderModel_t_1015 {
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));
struct winRenderModel_t_1015 *struct_RenderModel_t_1015_wrap(void *l)
{
struct winRenderModel_t_1015 *win = (struct winRenderModel_t_1015 *)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_1015_unwrap(winRenderModel_t_1015 *w)
{
RenderModel_t *ret = w->linux_side;
free(w);
return ret;
}
}

2
vrclient_x64/vrclient_defs.h
View File

@ -71,6 +71,8 @@ typedef void *glSharedTextureHandle_t;
typedef uint64_t VROverlayHandle_t;
typedef uint64_t TrackedCameraHandle_t;
typedef uint32_t PropertyTypeTag_t;
typedef uint64_t PropertyContainerHandle_t;
typedef PropertyContainerHandle_t DriverHandle_t;
/* never dereferenced */
typedef struct VROverlayIntersectionParams_t VROverlayIntersectionParams_t;

15
vrclient_x64/winIVRDriverManager.c
View File

@ -39,6 +39,13 @@ uint32_t __thiscall winIVRDriverManager_IVRDriverManager_001_GetDriverName(winIV
return cppIVRDriverManager_IVRDriverManager_001_GetDriverName(_this->linux_side, nDriver, pchValue, unBufferSize);
}
DEFINE_THISCALL_WRAPPER(winIVRDriverManager_IVRDriverManager_001_GetDriverHandle, 12)
DriverHandle_t __thiscall winIVRDriverManager_IVRDriverManager_001_GetDriverHandle(winIVRDriverManager_IVRDriverManager_001 *_this, const char * pchDriverName)
{
TRACE("%p\n", _this);
return cppIVRDriverManager_IVRDriverManager_001_GetDriverHandle(_this->linux_side, pchDriverName);
}
extern vtable_ptr winIVRDriverManager_IVRDriverManager_001_vtable;
#ifndef __GNUC__
@ -47,6 +54,7 @@ void __asm_dummy_vtables(void) {
__ASM_VTABLE(winIVRDriverManager_IVRDriverManager_001,
VTABLE_ADD_FUNC(winIVRDriverManager_IVRDriverManager_001_GetDriverCount)
VTABLE_ADD_FUNC(winIVRDriverManager_IVRDriverManager_001_GetDriverName)
VTABLE_ADD_FUNC(winIVRDriverManager_IVRDriverManager_001_GetDriverHandle)
);
#ifndef __GNUC__
}
@ -70,14 +78,15 @@ 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(2);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 2 * sizeof(*vtable));
struct thunk *thunks = alloc_thunks(3);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 3 * sizeof(*vtable));
int i;
TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
init_thunk(&thunks[0], r, winIVRDriverManager_IVRDriverManager_001_GetDriverCount);
init_thunk(&thunks[1], r, winIVRDriverManager_IVRDriverManager_001_GetDriverName);
for (i = 0; i < 2; i++)
init_thunk(&thunks[2], r, winIVRDriverManager_IVRDriverManager_001_GetDriverHandle);
for (i = 0; i < 3; i++)
vtable[i] = &thunks[i];
r->linux_side = linux_side;
r->vtable = (void *)vtable;

2
vrclient_x64/winIVROverlay.c
View File

@ -341,7 +341,7 @@ EVROverlayError __thiscall winIVROverlay_IVROverlay_018_GetTransformForOverlayCo
}
DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_018_PollNextOverlayEvent, 24)
bool __thiscall winIVROverlay_IVROverlay_018_PollNextOverlayEvent(winIVROverlay_IVROverlay_018 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1012 * pEvent, uint32_t uncbVREvent)
bool __thiscall winIVROverlay_IVROverlay_018_PollNextOverlayEvent(winIVROverlay_IVROverlay_018 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1015 * pEvent, uint32_t uncbVREvent)
{
TRACE("%p\n", _this);
return cppIVROverlay_IVROverlay_018_PollNextOverlayEvent(_this->linux_side, ulOverlayHandle, pEvent, uncbVREvent);

8
vrclient_x64/winIVRRenderModels.c
View File

@ -26,28 +26,28 @@ typedef struct __winIVRRenderModels_IVRRenderModels_005 {
} winIVRRenderModels_IVRRenderModels_005;
DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_005_LoadRenderModel_Async, 20)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_005_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_005 *_this, const char * pchRenderModelName, winRenderModel_t_1012 ** ppRenderModel)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_005_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_005 *_this, const char * pchRenderModelName, winRenderModel_t_1015 ** ppRenderModel)
{
TRACE("%p\n", _this);
return cppIVRRenderModels_IVRRenderModels_005_LoadRenderModel_Async(_this->linux_side, pchRenderModelName, ppRenderModel);
}
DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_005_FreeRenderModel, 12)
void __thiscall winIVRRenderModels_IVRRenderModels_005_FreeRenderModel(winIVRRenderModels_IVRRenderModels_005 *_this, winRenderModel_t_1012 * pRenderModel)
void __thiscall winIVRRenderModels_IVRRenderModels_005_FreeRenderModel(winIVRRenderModels_IVRRenderModels_005 *_this, winRenderModel_t_1015 * pRenderModel)
{
TRACE("%p\n", _this);
cppIVRRenderModels_IVRRenderModels_005_FreeRenderModel(_this->linux_side, pRenderModel);
}
DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_005_LoadTexture_Async, 16)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_005 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_1012 ** ppTexture)
EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_005 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_1015 ** ppTexture)
{
TRACE("%p\n", _this);
return cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(_this->linux_side, textureId, ppTexture);
}
DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_005_FreeTexture, 12)
void __thiscall winIVRRenderModels_IVRRenderModels_005_FreeTexture(winIVRRenderModels_IVRRenderModels_005 *_this, winRenderModel_TextureMap_t_1012 * pTexture)
void __thiscall winIVRRenderModels_IVRRenderModels_005_FreeTexture(winIVRRenderModels_IVRRenderModels_005 *_this, winRenderModel_TextureMap_t_1015 * pTexture)
{
TRACE("%p\n", _this);
cppIVRRenderModels_IVRRenderModels_005_FreeTexture(_this->linux_side, pTexture);

8
vrclient_x64/winIVRSystem.c
View File

@ -241,14 +241,14 @@ const char * __thiscall winIVRSystem_IVRSystem_019_GetPropErrorNameFromEnum(winI
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_019_PollNextEvent, 16)
bool __thiscall winIVRSystem_IVRSystem_019_PollNextEvent(winIVRSystem_IVRSystem_019 *_this, winVREvent_t_1012 * pEvent, uint32_t uncbVREvent)
bool __thiscall winIVRSystem_IVRSystem_019_PollNextEvent(winIVRSystem_IVRSystem_019 *_this, winVREvent_t_1015 * pEvent, uint32_t uncbVREvent)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_019_PollNextEvent(_this->linux_side, pEvent, uncbVREvent);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_019_PollNextEventWithPose, 28)
bool __thiscall winIVRSystem_IVRSystem_019_PollNextEventWithPose(winIVRSystem_IVRSystem_019 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1012 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
bool __thiscall winIVRSystem_IVRSystem_019_PollNextEventWithPose(winIVRSystem_IVRSystem_019 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1015 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_019_PollNextEventWithPose(_this->linux_side, eOrigin, pEvent, uncbVREvent, pTrackedDevicePose);
@ -270,14 +270,14 @@ HiddenAreaMesh_t *__thiscall winIVRSystem_IVRSystem_019_GetHiddenAreaMesh(winIVR
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_019_GetControllerState, 20)
bool __thiscall winIVRSystem_IVRSystem_019_GetControllerState(winIVRSystem_IVRSystem_019 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1012 * pControllerState, uint32_t unControllerStateSize)
bool __thiscall winIVRSystem_IVRSystem_019_GetControllerState(winIVRSystem_IVRSystem_019 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1015 * pControllerState, uint32_t unControllerStateSize)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_019_GetControllerState(_this->linux_side, unControllerDeviceIndex, pControllerState, unControllerStateSize);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_019_GetControllerStateWithPose, 32)
bool __thiscall winIVRSystem_IVRSystem_019_GetControllerStateWithPose(winIVRSystem_IVRSystem_019 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1012 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
bool __thiscall winIVRSystem_IVRSystem_019_GetControllerStateWithPose(winIVRSystem_IVRSystem_019 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1015 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(_this->linux_side, eOrigin, unControllerDeviceIndex, pControllerState, unControllerStateSize, pTrackedDevicePose);