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

vrclient: Support v1.6.10

Browse source
This commit is contained in:
Andrew Eikum 2019-08-16 09:10:37 -05:00
parent 63e14b5678
commit 81b9803214
33 changed files with 5446 additions and 62 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
openvr

@ -1 +1 @@
Subproject commit cdaf2b330c8df58986391b253cd8f04328139823
Subproject commit 52065df3d6f3af96300dac98cdf7397f26abfcd7

3
vrclient_x64/gen_wrapper.py
View file

@ -12,6 +12,7 @@ import os
import re
sdk_versions = [
"v1.6.10",
"v1.5.17",
"v1.4.18",
"v1.3.22",
@ -1103,7 +1104,7 @@ for sdkver in sdk_versions:
if not os.path.isfile(input_name):
continue
index = clang.cindex.Index.create()
tu = index.parse(input_name, args=['-x', 'c++', '-std=c++11', '-DGNUC', '-Iopenvr_%s/' % sdkver, '-I/usr/lib/clang/8.0.0/include/'])
tu = index.parse(input_name, args=['-x', 'c++', '-std=c++11', '-DGNUC', '-Iopenvr_%s/' % sdkver, '-I/usr/lib/clang/8.0.1/include/'])
diagnostics = list(tu.diagnostics)
if len(diagnostics) > 0:

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

5165
vrclient_x64/openvr_v1.6.10/openvr.h Normal file
View file

File diff suppressed because it is too large Load diff

14
vrclient_x64/tests/capi_thunks_autogen.c
View file

@ -361,6 +361,20 @@ void __thiscall IVRSystem_020_AcknowledgeQuit_UserPrompt(void *_this)
push_ptr_parameter(_this);
}
uint32_t __thiscall IVRSystem_020_GetAppContainerFilePaths(void *_this, char * pchBuffer, uint32_t unBufferSize)
{
push_ptr_parameter(_this);
push_ptr_parameter(pchBuffer);
push_uint32_parameter(unBufferSize);
return 0;
}
const char * __thiscall IVRSystem_020_GetRuntimeVersion(void *_this)
{
push_ptr_parameter(_this);
return 0;
}
EVRApplicationError __thiscall IVRApplications_006_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary)
{
push_ptr_parameter(_this);

4
vrclient_x64/tests/capi_thunks_autogen.h
View file

@ -105,6 +105,10 @@ void __thiscall IVRSystem_020_AcknowledgeQuit_Exiting(void *_this);
void __thiscall IVRSystem_020_AcknowledgeQuit_UserPrompt(void *_this);
uint32_t __thiscall IVRSystem_020_GetAppContainerFilePaths(void *_this, char * pchBuffer, uint32_t unBufferSize);
const char * __thiscall IVRSystem_020_GetRuntimeVersion(void *_this);
void test_capi_thunks_IVRApplications_006(void);
EVRApplicationError __thiscall IVRApplications_006_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary);

16
vrclient_x64/tests/capi_thunks_tests_autogen.c
View file

@ -420,6 +420,22 @@ void test_capi_thunks_IVRSystem_020(void)
clear_parameters();
capi_IVRSystem_020_AcknowledgeQuit_UserPrompt();
check_ptr_parameter("IVRSystem_020_AcknowledgeQuit_UserPrompt", this_ptr_value);
init_thunk(t, this_ptr_value, IVRSystem_020_GetAppContainerFilePaths, 2, FALSE, FALSE);
uint32_t (__stdcall *capi_IVRSystem_020_GetAppContainerFilePaths)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;
clear_parameters();
capi_IVRSystem_020_GetAppContainerFilePaths((void *)1, 2);
check_ptr_parameter("IVRSystem_020_GetAppContainerFilePaths", this_ptr_value);
check_ptr_parameter("IVRSystem_020_GetAppContainerFilePaths", (void *)1);
check_uint32_parameter("IVRSystem_020_GetAppContainerFilePaths", 2);
init_thunk(t, this_ptr_value, IVRSystem_020_GetRuntimeVersion, 0, FALSE, FALSE);
const char * (__stdcall *capi_IVRSystem_020_GetRuntimeVersion)() = (void *)t;
clear_parameters();
capi_IVRSystem_020_GetRuntimeVersion();
check_ptr_parameter("IVRSystem_020_GetRuntimeVersion", this_ptr_value);
VirtualFree(t, 0, MEM_RELEASE);
}

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

2
vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp
View file

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

2
vrclient_x64/vrclient_x64/cppIVRExtendedDisplay_IVRExtendedDisplay_001.cpp
View file

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

2
vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.cpp
View file

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

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.5.17/ivrclientcore.h"
#include "openvr_v1.6.10/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.5.17/ivrclientcore.h"
#include "openvr_v1.6.10/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
@ -234,12 +234,12 @@ vr::EVROverlayError cppIVROverlay_IVROverlay_019_GetTransformForOverlayCoordinat
return ((IVROverlay*)linux_side)->GetTransformForOverlayCoordinates((vr::VROverlayHandle_t)ulOverlayHandle, (vr::ETrackingUniverseOrigin)eTrackingOrigin, (vr::HmdVector2_t)coordinatesInOverlay, (vr::HmdMatrix34_t *)pmatTransform);
}
bool cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1517 * pEvent, uint32_t uncbVREvent)
bool cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1610 * pEvent, uint32_t uncbVREvent)
{
VREvent_t lin;
bool _ret;
_ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, &lin, sizeof(lin));
struct_VREvent_t_1517_lin_to_win(&lin, pEvent);
struct_VREvent_t_1610_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_1517 *, uint32_t);
extern bool cppIVROverlay_IVROverlay_019_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1610 *, 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.5.17/ivrclientcore.h"
#include "openvr_v1.6.10/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
@ -9,34 +9,34 @@ extern "C" {
#ifdef __cplusplus
extern "C" {
#endif
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1517 ** ppRenderModel)
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1610 ** ppRenderModel)
{
RenderModel_t *lin;
vr::EVRRenderModelError _ret;
_ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, &lin);
if(_ret == 0)
*ppRenderModel = struct_RenderModel_t_1517_wrap(lin);
*ppRenderModel = struct_RenderModel_t_1610_wrap(lin);
return _ret;
}
void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1517 * pRenderModel)
void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1610 * pRenderModel)
{
((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1517_unwrap(pRenderModel));
((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1610_unwrap(pRenderModel));
}
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1517 ** ppTexture)
vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1610 ** 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_1517_wrap(lin);
*ppTexture = struct_RenderModel_TextureMap_t_1610_wrap(lin);
return _ret;
}
void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1517 * pTexture)
void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1610 * pTexture)
{
((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1517_unwrap(pTexture));
((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1610_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_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_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1610 **);
extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_1610 *);
extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1610 **);
extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_1610 *);
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.5.17/ivrclientcore.h"
#include "openvr_v1.6.10/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.5.17/ivrclientcore.h"
#include "openvr_v1.6.10/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.5.17/ivrclientcore.h"
#include "openvr_v1.6.10/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"

28
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_020.cpp
View file

@ -1,6 +1,6 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.5.17/ivrclientcore.h"
#include "openvr_v1.6.10/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
@ -159,21 +159,21 @@ const char * cppIVRSystem_IVRSystem_020_GetPropErrorNameFromEnum(void *linux_sid
return ((IVRSystem*)linux_side)->GetPropErrorNameFromEnum((vr::ETrackedPropertyError)error);
}
bool cppIVRSystem_IVRSystem_020_PollNextEvent(void *linux_side, winVREvent_t_1517 * pEvent, uint32_t uncbVREvent)
bool cppIVRSystem_IVRSystem_020_PollNextEvent(void *linux_side, winVREvent_t_1610 * 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);
struct_VREvent_t_1610_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)
bool cppIVRSystem_IVRSystem_020_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1610 * 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);
struct_VREvent_t_1610_lin_to_win(&lin, pEvent);
return _ret;
}
@ -187,21 +187,21 @@ vr::HiddenAreaMesh_t cppIVRSystem_IVRSystem_020_GetHiddenAreaMesh(void *linux_si
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)
bool cppIVRSystem_IVRSystem_020_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1610 * 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);
struct_VRControllerState001_t_1610_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)
bool cppIVRSystem_IVRSystem_020_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1610 * 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);
struct_VRControllerState001_t_1610_lin_to_win(&lin, pControllerState);
return _ret;
}
@ -255,6 +255,16 @@ void cppIVRSystem_IVRSystem_020_AcknowledgeQuit_UserPrompt(void *linux_side)
((IVRSystem*)linux_side)->AcknowledgeQuit_UserPrompt();
}
uint32_t cppIVRSystem_IVRSystem_020_GetAppContainerFilePaths(void *linux_side, char * pchBuffer, uint32_t unBufferSize)
{
return ((IVRSystem*)linux_side)->GetAppContainerFilePaths((char *)pchBuffer, (uint32_t)unBufferSize);
}
const char * cppIVRSystem_IVRSystem_020_GetRuntimeVersion(void *linux_side)
{
return ((IVRSystem*)linux_side)->GetRuntimeVersion();
}
#ifdef __cplusplus
}
#endif

10
vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_020.h
View file

@ -31,12 +31,12 @@ extern HmdMatrix34_t cppIVRSystem_IVRSystem_020_GetMatrix34TrackedDeviceProperty
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 bool cppIVRSystem_IVRSystem_020_PollNextEvent(void *, winVREvent_t_1610 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_020_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1610 *, 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 bool cppIVRSystem_IVRSystem_020_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1610 *, uint32_t);
extern bool cppIVRSystem_IVRSystem_020_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1610 *, 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);
@ -47,6 +47,8 @@ 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 *);
extern uint32_t cppIVRSystem_IVRSystem_020_GetAppContainerFilePaths(void *, char *, uint32_t);
extern const char * cppIVRSystem_IVRSystem_020_GetRuntimeVersion(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.5.17/ivrclientcore.h"
#include "openvr_v1.6.10/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_1610 winVREvent_t_1610;
extern void struct_VREvent_t_1610_lin_to_win(void *l, void *w);
typedef struct winVRControllerState001_t_1610 winVRControllerState001_t_1610;
extern void struct_VRControllerState001_t_1610_lin_to_win(void *l, void *w);
typedef struct winRenderModel_TextureMap_t_1610 winRenderModel_TextureMap_t_1610;
extern struct winRenderModel_TextureMap_t_1610 *struct_RenderModel_TextureMap_t_1610_wrap(void *l);
extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1610_unwrap(winRenderModel_TextureMap_t_1610 *w);
typedef struct winRenderModel_t_1610 winRenderModel_t_1610;
extern struct winRenderModel_t_1610 *struct_RenderModel_t_1610_wrap(void *l);
extern RenderModel_t *struct_RenderModel_t_1610_unwrap(winRenderModel_t_1610 *w);
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;

108
vrclient_x64/vrclient_x64/struct_converters_1610.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.6.10/openvr.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
#pragma pack(push, 8)
struct winVREvent_t_1610 {
uint32_t eventType;
vr::TrackedDeviceIndex_t trackedDeviceIndex;
float eventAgeSeconds;
vr::VREvent_Data_t data;
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_VREvent_t_1610_lin_to_win(void *l, void *w)
{
struct winVREvent_t_1610 *win = (struct winVREvent_t_1610 *)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_1610 {
uint32_t unPacketNum;
uint64_t ulButtonPressed;
uint64_t ulButtonTouched;
vr::VRControllerAxis_t rAxis[5];
} __attribute__ ((ms_struct));
#pragma pack(pop)
void struct_VRControllerState001_t_1610_lin_to_win(void *l, void *w)
{
struct winVRControllerState001_t_1610 *win = (struct winVRControllerState001_t_1610 *)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_1610 {
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_1610 *struct_RenderModel_TextureMap_t_1610_wrap(void *l)
{
struct winRenderModel_TextureMap_t_1610 *win = (struct winRenderModel_TextureMap_t_1610 *)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_1610_unwrap(winRenderModel_TextureMap_t_1610 *w)
{
RenderModel_TextureMap_t *ret = w->linux_side;
free(w);
return ret;
}
#pragma pack(push, 8)
struct winRenderModel_t_1610 {
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_1610 *struct_RenderModel_t_1610_wrap(void *l)
{
struct winRenderModel_t_1610 *win = (struct winRenderModel_t_1610 *)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_1610_unwrap(winRenderModel_t_1610 *w)
{
RenderModel_t *ret = w->linux_side;
free(w);
return ret;
}
}

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_1517 winRenderModel_t_1517;
typedef struct winRenderModel_TextureMap_t_1517 winRenderModel_TextureMap_t_1517;
typedef struct winRenderModel_t_1610 winRenderModel_t_1610;
typedef struct winRenderModel_TextureMap_t_1610 winRenderModel_TextureMap_t_1610;
#include "cppIVRRenderModels_IVRRenderModels_006.h"
WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
@ -1111,7 +1111,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_1517 **)&texture_map);
error = cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(linux_side, texture_id, (struct winRenderModel_TextureMap_t_1610 **)&texture_map);
break;
}
if (error == VRRenderModelError_Loading)
@ -1141,7 +1141,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_1517 *)texture_map);
cppIVRRenderModels_IVRRenderModels_006_FreeTexture(linux_side, (struct winRenderModel_TextureMap_t_1610 *)texture_map);
break;
}
return error;

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

32
vrclient_x64/vrclient_x64/winIVRSystem.c
View file

@ -241,14 +241,14 @@ const char * __thiscall winIVRSystem_IVRSystem_020_GetPropErrorNameFromEnum(winI
}
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)
bool __thiscall winIVRSystem_IVRSystem_020_PollNextEvent(winIVRSystem_IVRSystem_020 *_this, winVREvent_t_1610 * 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)
bool __thiscall winIVRSystem_IVRSystem_020_PollNextEventWithPose(winIVRSystem_IVRSystem_020 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1610 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_PollNextEventWithPose(_this->linux_side, eOrigin, pEvent, uncbVREvent, pTrackedDevicePose);
@ -270,14 +270,14 @@ HiddenAreaMesh_t *__thiscall winIVRSystem_IVRSystem_020_GetHiddenAreaMesh(winIVR
}
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)
bool __thiscall winIVRSystem_IVRSystem_020_GetControllerState(winIVRSystem_IVRSystem_020 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1610 * 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)
bool __thiscall winIVRSystem_IVRSystem_020_GetControllerStateWithPose(winIVRSystem_IVRSystem_020 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1610 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetControllerStateWithPose(_this->linux_side, eOrigin, unControllerDeviceIndex, pControllerState, unControllerStateSize, pTrackedDevicePose);
@ -353,6 +353,20 @@ void __thiscall winIVRSystem_IVRSystem_020_AcknowledgeQuit_UserPrompt(winIVRSyst
cppIVRSystem_IVRSystem_020_AcknowledgeQuit_UserPrompt(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetAppContainerFilePaths, 16)
uint32_t __thiscall winIVRSystem_IVRSystem_020_GetAppContainerFilePaths(winIVRSystem_IVRSystem_020 *_this, char * pchBuffer, uint32_t unBufferSize)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetAppContainerFilePaths(_this->linux_side, pchBuffer, unBufferSize);
}
DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_020_GetRuntimeVersion, 4)
const char * __thiscall winIVRSystem_IVRSystem_020_GetRuntimeVersion(winIVRSystem_IVRSystem_020 *_this)
{
TRACE("%p\n", _this);
return cppIVRSystem_IVRSystem_020_GetRuntimeVersion(_this->linux_side);
}
extern vtable_ptr winIVRSystem_IVRSystem_020_vtable;
#ifndef __GNUC__
@ -405,6 +419,8 @@ void __asm_dummy_vtables(void) {
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_PerformFirmwareUpdate)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_AcknowledgeQuit_Exiting)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_AcknowledgeQuit_UserPrompt)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetAppContainerFilePaths)
VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_020_GetRuntimeVersion)
);
#ifndef __GNUC__
}
@ -428,8 +444,8 @@ void destroy_winIVRSystem_IVRSystem_020(void *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));
struct thunk *thunks = alloc_thunks(48);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 48 * sizeof(*vtable));
int i;
TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
@ -479,7 +495,9 @@ winIVRSystem_IVRSystem_020 *create_winIVRSystem_IVRSystem_020_FnTable(void *linu
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++)
init_thunk(&thunks[46], r, winIVRSystem_IVRSystem_020_GetAppContainerFilePaths, 2, FALSE, FALSE);
init_thunk(&thunks[47], r, winIVRSystem_IVRSystem_020_GetRuntimeVersion, 0, FALSE, FALSE);
for (i = 0; i < 48; i++)
vtable[i] = &thunks[i];
r->linux_side = linux_side;
r->vtable = (void *)vtable;