vrclient: Support intermediate version 1.0.3a

Used by The Lab.
This commit is contained in:
hdmap 2018-12-10 12:31:46 -05:00 committed by Andrew Eikum
parent 55b80e0c68
commit f260a2cb30
15 changed files with 4894 additions and 2 deletions

View file

@ -26,6 +26,7 @@ sdk_versions = [
"v1.0.6",
"v1.0.5",
"v1.0.4",
"v1.0.3a", #non-public build used by The Lab, see Proton github PR#2075
"v1.0.3",
"v1.0.2",
"v1.0.1",
@ -171,7 +172,7 @@ def ivrcompositor_post_present_handoff(cppname, method):
return "ivrcompositor_post_present_handoff"
def ivrcompositor_wait_get_poses(cppname, method):
for version in ["016", "018", "019", "020", "021", "022"]:
for version in ["016", "017", "018", "019", "020", "021", "022"]:
if version in cppname:
return "ivrcompositor_wait_get_poses"
return None
@ -564,7 +565,8 @@ WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
constructors.write(" {\"FnTable:%s\", &create_%s_FnTable, &destroy_%s_FnTable},\n" % (iface_version, winclassname, winclassname))
if iface_version in aliases.keys():
for alias in aliases[iface_version]:
constructors.write(" {\"%s\", &create_%s}, /* alias */\n" % (alias, winclassname))
constructors.write(" {\"%s\", &create_%s, &destroy_%s}, /* alias */\n" % (alias, winclassname, winclassname))
constructors.write(" {\"FnTable:%s\", &create_%s_FnTable, &destroy_%s_FnTable},\n" % (alias, winclassname, winclassname))
generate_c_api_thunk_tests(winclassname, methods, method_names)

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 ) = 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_002";
}

File diff suppressed because it is too large Load diff

View file

@ -8181,6 +8181,248 @@ EVROverlayError __thiscall IVROverlay_013_SetOverlayIntersectionMask(void *_this
return 0;
}
void __thiscall IVRCompositor_017_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
{
push_ptr_parameter(_this);
push_uint32_parameter(eOrigin);
}
ETrackingUniverseOrigin __thiscall IVRCompositor_017_GetTrackingSpace(void *_this)
{
push_ptr_parameter(_this);
return 0;
}
EVRCompositorError __thiscall IVRCompositor_017_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
{
push_ptr_parameter(_this);
push_ptr_parameter(pRenderPoseArray);
push_uint32_parameter(unRenderPoseArrayCount);
push_ptr_parameter(pGamePoseArray);
push_uint32_parameter(unGamePoseArrayCount);
return 0;
}
EVRCompositorError __thiscall IVRCompositor_017_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
{
push_ptr_parameter(_this);
push_ptr_parameter(pRenderPoseArray);
push_uint32_parameter(unRenderPoseArrayCount);
push_ptr_parameter(pGamePoseArray);
push_uint32_parameter(unGamePoseArrayCount);
return 0;
}
EVRCompositorError __thiscall IVRCompositor_017_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
{
push_ptr_parameter(_this);
push_uint32_parameter(unDeviceIndex);
push_ptr_parameter(pOutputPose);
push_ptr_parameter(pOutputGamePose);
return 0;
}
EVRCompositorError __thiscall IVRCompositor_017_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
{
push_ptr_parameter(_this);
push_uint32_parameter(eEye);
push_ptr_parameter(pTexture);
push_ptr_parameter(pBounds);
push_uint32_parameter(nSubmitFlags);
return 0;
}
void __thiscall IVRCompositor_017_ClearLastSubmittedFrame(void *_this)
{
push_ptr_parameter(_this);
}
void __thiscall IVRCompositor_017_PostPresentHandoff(void *_this)
{
push_ptr_parameter(_this);
}
bool __thiscall IVRCompositor_017_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
{
push_ptr_parameter(_this);
push_ptr_parameter(pTiming);
push_uint32_parameter(unFramesAgo);
return 0;
}
uint32_t __thiscall IVRCompositor_017_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
{
push_ptr_parameter(_this);
push_ptr_parameter(pTiming);
push_uint32_parameter(nFrames);
return 0;
}
float __thiscall IVRCompositor_017_GetFrameTimeRemaining(void *_this)
{
push_ptr_parameter(_this);
return 0;
}
void __thiscall IVRCompositor_017_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
{
push_ptr_parameter(_this);
push_ptr_parameter(pStats);
push_uint32_parameter(nStatsSizeInBytes);
}
void __thiscall IVRCompositor_017_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
{
push_ptr_parameter(_this);
push_float_parameter(fSeconds);
push_float_parameter(fRed);
push_float_parameter(fGreen);
push_float_parameter(fBlue);
push_float_parameter(fAlpha);
push_bool_parameter(bBackground);
}
void __thiscall IVRCompositor_017_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
{
push_ptr_parameter(_this);
push_float_parameter(fSeconds);
push_bool_parameter(bFadeIn);
}
EVRCompositorError __thiscall IVRCompositor_017_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
{
push_ptr_parameter(_this);
push_ptr_parameter(pTextures);
push_uint32_parameter(unTextureCount);
return 0;
}
void __thiscall IVRCompositor_017_ClearSkyboxOverride(void *_this)
{
push_ptr_parameter(_this);
}
void __thiscall IVRCompositor_017_CompositorBringToFront(void *_this)
{
push_ptr_parameter(_this);
}
void __thiscall IVRCompositor_017_CompositorGoToBack(void *_this)
{
push_ptr_parameter(_this);
}
void __thiscall IVRCompositor_017_CompositorQuit(void *_this)
{
push_ptr_parameter(_this);
}
bool __thiscall IVRCompositor_017_IsFullscreen(void *_this)
{
push_ptr_parameter(_this);
return 0;
}
uint32_t __thiscall IVRCompositor_017_GetCurrentSceneFocusProcess(void *_this)
{
push_ptr_parameter(_this);
return 0;
}
uint32_t __thiscall IVRCompositor_017_GetLastFrameRenderer(void *_this)
{
push_ptr_parameter(_this);
return 0;
}
bool __thiscall IVRCompositor_017_CanRenderScene(void *_this)
{
push_ptr_parameter(_this);
return 0;
}
void __thiscall IVRCompositor_017_ShowMirrorWindow(void *_this)
{
push_ptr_parameter(_this);
}
void __thiscall IVRCompositor_017_HideMirrorWindow(void *_this)
{
push_ptr_parameter(_this);
}
bool __thiscall IVRCompositor_017_IsMirrorWindowVisible(void *_this)
{
push_ptr_parameter(_this);
return 0;
}
void __thiscall IVRCompositor_017_CompositorDumpImages(void *_this)
{
push_ptr_parameter(_this);
}
bool __thiscall IVRCompositor_017_ShouldAppRenderWithLowResources(void *_this)
{
push_ptr_parameter(_this);
return 0;
}
void __thiscall IVRCompositor_017_ForceInterleavedReprojectionOn(void *_this, bool bOverride)
{
push_ptr_parameter(_this);
push_bool_parameter(bOverride);
}
void __thiscall IVRCompositor_017_ForceReconnectProcess(void *_this)
{
push_ptr_parameter(_this);
}
void __thiscall IVRCompositor_017_SuspendRendering(void *_this, bool bSuspend)
{
push_ptr_parameter(_this);
push_bool_parameter(bSuspend);
}
EVRCompositorError __thiscall IVRCompositor_017_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
{
push_ptr_parameter(_this);
push_uint32_parameter(eEye);
push_ptr_parameter(pD3D11DeviceOrResource);
push_ptr_parameter(ppD3D11ShaderResourceView);
return 0;
}
EVRCompositorError __thiscall IVRCompositor_017_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
{
push_ptr_parameter(_this);
push_uint32_parameter(eEye);
push_ptr_parameter(pglTextureId);
push_ptr_parameter(pglSharedTextureHandle);
return 0;
}
bool __thiscall IVRCompositor_017_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
{
push_ptr_parameter(_this);
push_uint32_parameter(glTextureId);
push_ptr_parameter(glSharedTextureHandle);
return 0;
}
void __thiscall IVRCompositor_017_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
{
push_ptr_parameter(_this);
push_ptr_parameter(glSharedTextureHandle);
}
void __thiscall IVRCompositor_017_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
{
push_ptr_parameter(_this);
push_ptr_parameter(glSharedTextureHandle);
}
void __thiscall IVRSystem_012_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
{
push_ptr_parameter(_this);

View file

@ -2131,6 +2131,80 @@ void __thiscall IVROverlay_013_SetKeyboardPositionForOverlay(void *_this, VROver
EVROverlayError __thiscall IVROverlay_013_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
void test_capi_thunks_IVRCompositor_017(void);
void __thiscall IVRCompositor_017_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
ETrackingUniverseOrigin __thiscall IVRCompositor_017_GetTrackingSpace(void *_this);
EVRCompositorError __thiscall IVRCompositor_017_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
EVRCompositorError __thiscall IVRCompositor_017_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
EVRCompositorError __thiscall IVRCompositor_017_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
EVRCompositorError __thiscall IVRCompositor_017_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
void __thiscall IVRCompositor_017_ClearLastSubmittedFrame(void *_this);
void __thiscall IVRCompositor_017_PostPresentHandoff(void *_this);
bool __thiscall IVRCompositor_017_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
uint32_t __thiscall IVRCompositor_017_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames);
float __thiscall IVRCompositor_017_GetFrameTimeRemaining(void *_this);
void __thiscall IVRCompositor_017_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
void __thiscall IVRCompositor_017_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
void __thiscall IVRCompositor_017_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
EVRCompositorError __thiscall IVRCompositor_017_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
void __thiscall IVRCompositor_017_ClearSkyboxOverride(void *_this);
void __thiscall IVRCompositor_017_CompositorBringToFront(void *_this);
void __thiscall IVRCompositor_017_CompositorGoToBack(void *_this);
void __thiscall IVRCompositor_017_CompositorQuit(void *_this);
bool __thiscall IVRCompositor_017_IsFullscreen(void *_this);
uint32_t __thiscall IVRCompositor_017_GetCurrentSceneFocusProcess(void *_this);
uint32_t __thiscall IVRCompositor_017_GetLastFrameRenderer(void *_this);
bool __thiscall IVRCompositor_017_CanRenderScene(void *_this);
void __thiscall IVRCompositor_017_ShowMirrorWindow(void *_this);
void __thiscall IVRCompositor_017_HideMirrorWindow(void *_this);
bool __thiscall IVRCompositor_017_IsMirrorWindowVisible(void *_this);
void __thiscall IVRCompositor_017_CompositorDumpImages(void *_this);
bool __thiscall IVRCompositor_017_ShouldAppRenderWithLowResources(void *_this);
void __thiscall IVRCompositor_017_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
void __thiscall IVRCompositor_017_ForceReconnectProcess(void *_this);
void __thiscall IVRCompositor_017_SuspendRendering(void *_this, bool bSuspend);
EVRCompositorError __thiscall IVRCompositor_017_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
EVRCompositorError __thiscall IVRCompositor_017_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
bool __thiscall IVRCompositor_017_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
void __thiscall IVRCompositor_017_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
void __thiscall IVRCompositor_017_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
void test_capi_thunks_IVRSystem_012(void);
void __thiscall IVRSystem_012_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);

View file

@ -9605,6 +9605,308 @@ void test_capi_thunks_IVROverlay_013(void)
VirtualFree(t, 0, MEM_RELEASE);
}
void test_capi_thunks_IVRCompositor_017(void)
{
struct thunk *t = alloc_thunks(1);
init_thunk(t, this_ptr_value, IVRCompositor_017_SetTrackingSpace, 1, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_SetTrackingSpace(1);
check_ptr_parameter("IVRCompositor_017_SetTrackingSpace", this_ptr_value);
check_uint32_parameter("IVRCompositor_017_SetTrackingSpace", 1);
init_thunk(t, this_ptr_value, IVRCompositor_017_GetTrackingSpace, 0, FALSE, FALSE);
ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_017_GetTrackingSpace)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_GetTrackingSpace();
check_ptr_parameter("IVRCompositor_017_GetTrackingSpace", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_WaitGetPoses, 4, FALSE, FALSE);
EVRCompositorError (__stdcall *capi_IVRCompositor_017_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_WaitGetPoses((void *)1, 2, (void *)3, 4);
check_ptr_parameter("IVRCompositor_017_WaitGetPoses", this_ptr_value);
check_ptr_parameter("IVRCompositor_017_WaitGetPoses", (void *)1);
check_uint32_parameter("IVRCompositor_017_WaitGetPoses", 2);
check_ptr_parameter("IVRCompositor_017_WaitGetPoses", (void *)3);
check_uint32_parameter("IVRCompositor_017_WaitGetPoses", 4);
init_thunk(t, this_ptr_value, IVRCompositor_017_GetLastPoses, 4, FALSE, FALSE);
EVRCompositorError (__stdcall *capi_IVRCompositor_017_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_GetLastPoses((void *)1, 2, (void *)3, 4);
check_ptr_parameter("IVRCompositor_017_GetLastPoses", this_ptr_value);
check_ptr_parameter("IVRCompositor_017_GetLastPoses", (void *)1);
check_uint32_parameter("IVRCompositor_017_GetLastPoses", 2);
check_ptr_parameter("IVRCompositor_017_GetLastPoses", (void *)3);
check_uint32_parameter("IVRCompositor_017_GetLastPoses", 4);
init_thunk(t, this_ptr_value, IVRCompositor_017_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
EVRCompositorError (__stdcall *capi_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
check_ptr_parameter("IVRCompositor_017_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
check_uint32_parameter("IVRCompositor_017_GetLastPoseForTrackedDeviceIndex", 1);
check_ptr_parameter("IVRCompositor_017_GetLastPoseForTrackedDeviceIndex", (void *)2);
check_ptr_parameter("IVRCompositor_017_GetLastPoseForTrackedDeviceIndex", (void *)3);
init_thunk(t, this_ptr_value, IVRCompositor_017_Submit, 4, FALSE, FALSE);
EVRCompositorError (__stdcall *capi_IVRCompositor_017_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_Submit(1, (void *)2, (void *)3, 4);
check_ptr_parameter("IVRCompositor_017_Submit", this_ptr_value);
check_uint32_parameter("IVRCompositor_017_Submit", 1);
check_ptr_parameter("IVRCompositor_017_Submit", (void *)2);
check_ptr_parameter("IVRCompositor_017_Submit", (void *)3);
check_uint32_parameter("IVRCompositor_017_Submit", 4);
init_thunk(t, this_ptr_value, IVRCompositor_017_ClearLastSubmittedFrame, 0, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_ClearLastSubmittedFrame)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_ClearLastSubmittedFrame();
check_ptr_parameter("IVRCompositor_017_ClearLastSubmittedFrame", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_PostPresentHandoff, 0, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_PostPresentHandoff)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_PostPresentHandoff();
check_ptr_parameter("IVRCompositor_017_PostPresentHandoff", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_GetFrameTiming, 2, FALSE, FALSE);
bool (__stdcall *capi_IVRCompositor_017_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_GetFrameTiming((void *)1, 2);
check_ptr_parameter("IVRCompositor_017_GetFrameTiming", this_ptr_value);
check_ptr_parameter("IVRCompositor_017_GetFrameTiming", (void *)1);
check_uint32_parameter("IVRCompositor_017_GetFrameTiming", 2);
init_thunk(t, this_ptr_value, IVRCompositor_017_GetFrameTimings, 2, FALSE, FALSE);
uint32_t (__stdcall *capi_IVRCompositor_017_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_GetFrameTimings((void *)1, 2);
check_ptr_parameter("IVRCompositor_017_GetFrameTimings", this_ptr_value);
check_ptr_parameter("IVRCompositor_017_GetFrameTimings", (void *)1);
check_uint32_parameter("IVRCompositor_017_GetFrameTimings", 2);
init_thunk(t, this_ptr_value, IVRCompositor_017_GetFrameTimeRemaining, 0, FALSE, FALSE);
float (__stdcall *capi_IVRCompositor_017_GetFrameTimeRemaining)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_GetFrameTimeRemaining();
check_ptr_parameter("IVRCompositor_017_GetFrameTimeRemaining", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_GetCumulativeStats, 2, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_GetCumulativeStats((void *)1, 2);
check_ptr_parameter("IVRCompositor_017_GetCumulativeStats", this_ptr_value);
check_ptr_parameter("IVRCompositor_017_GetCumulativeStats", (void *)1);
check_uint32_parameter("IVRCompositor_017_GetCumulativeStats", 2);
init_thunk(t, this_ptr_value, IVRCompositor_017_FadeToColor, 6, TRUE, TRUE);
void (__stdcall *capi_IVRCompositor_017_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
check_ptr_parameter("IVRCompositor_017_FadeToColor", this_ptr_value);
check_float_parameter("IVRCompositor_017_FadeToColor", 1.0f);
check_float_parameter("IVRCompositor_017_FadeToColor", 2.0f);
check_float_parameter("IVRCompositor_017_FadeToColor", 3.0f);
check_float_parameter("IVRCompositor_017_FadeToColor", 4.0f);
check_float_parameter("IVRCompositor_017_FadeToColor", 5.0f);
check_bool_parameter("IVRCompositor_017_FadeToColor", 1);
init_thunk(t, this_ptr_value, IVRCompositor_017_FadeGrid, 2, TRUE, FALSE);
void (__stdcall *capi_IVRCompositor_017_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_FadeGrid(1.0f, 1);
check_ptr_parameter("IVRCompositor_017_FadeGrid", this_ptr_value);
check_float_parameter("IVRCompositor_017_FadeGrid", 1.0f);
check_bool_parameter("IVRCompositor_017_FadeGrid", 1);
init_thunk(t, this_ptr_value, IVRCompositor_017_SetSkyboxOverride, 2, FALSE, FALSE);
EVRCompositorError (__stdcall *capi_IVRCompositor_017_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_SetSkyboxOverride((void *)1, 2);
check_ptr_parameter("IVRCompositor_017_SetSkyboxOverride", this_ptr_value);
check_ptr_parameter("IVRCompositor_017_SetSkyboxOverride", (void *)1);
check_uint32_parameter("IVRCompositor_017_SetSkyboxOverride", 2);
init_thunk(t, this_ptr_value, IVRCompositor_017_ClearSkyboxOverride, 0, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_ClearSkyboxOverride)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_ClearSkyboxOverride();
check_ptr_parameter("IVRCompositor_017_ClearSkyboxOverride", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_CompositorBringToFront, 0, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_CompositorBringToFront)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_CompositorBringToFront();
check_ptr_parameter("IVRCompositor_017_CompositorBringToFront", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_CompositorGoToBack, 0, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_CompositorGoToBack)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_CompositorGoToBack();
check_ptr_parameter("IVRCompositor_017_CompositorGoToBack", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_CompositorQuit, 0, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_CompositorQuit)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_CompositorQuit();
check_ptr_parameter("IVRCompositor_017_CompositorQuit", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_IsFullscreen, 0, FALSE, FALSE);
bool (__stdcall *capi_IVRCompositor_017_IsFullscreen)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_IsFullscreen();
check_ptr_parameter("IVRCompositor_017_IsFullscreen", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
uint32_t (__stdcall *capi_IVRCompositor_017_GetCurrentSceneFocusProcess)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_GetCurrentSceneFocusProcess();
check_ptr_parameter("IVRCompositor_017_GetCurrentSceneFocusProcess", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_GetLastFrameRenderer, 0, FALSE, FALSE);
uint32_t (__stdcall *capi_IVRCompositor_017_GetLastFrameRenderer)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_GetLastFrameRenderer();
check_ptr_parameter("IVRCompositor_017_GetLastFrameRenderer", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_CanRenderScene, 0, FALSE, FALSE);
bool (__stdcall *capi_IVRCompositor_017_CanRenderScene)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_CanRenderScene();
check_ptr_parameter("IVRCompositor_017_CanRenderScene", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_ShowMirrorWindow, 0, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_ShowMirrorWindow)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_ShowMirrorWindow();
check_ptr_parameter("IVRCompositor_017_ShowMirrorWindow", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_HideMirrorWindow, 0, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_HideMirrorWindow)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_HideMirrorWindow();
check_ptr_parameter("IVRCompositor_017_HideMirrorWindow", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_IsMirrorWindowVisible, 0, FALSE, FALSE);
bool (__stdcall *capi_IVRCompositor_017_IsMirrorWindowVisible)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_IsMirrorWindowVisible();
check_ptr_parameter("IVRCompositor_017_IsMirrorWindowVisible", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_CompositorDumpImages, 0, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_CompositorDumpImages)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_CompositorDumpImages();
check_ptr_parameter("IVRCompositor_017_CompositorDumpImages", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
bool (__stdcall *capi_IVRCompositor_017_ShouldAppRenderWithLowResources)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_ShouldAppRenderWithLowResources();
check_ptr_parameter("IVRCompositor_017_ShouldAppRenderWithLowResources", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_ForceInterleavedReprojectionOn(1);
check_ptr_parameter("IVRCompositor_017_ForceInterleavedReprojectionOn", this_ptr_value);
check_bool_parameter("IVRCompositor_017_ForceInterleavedReprojectionOn", 1);
init_thunk(t, this_ptr_value, IVRCompositor_017_ForceReconnectProcess, 0, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_ForceReconnectProcess)() = (void *)t;
clear_parameters();
capi_IVRCompositor_017_ForceReconnectProcess();
check_ptr_parameter("IVRCompositor_017_ForceReconnectProcess", this_ptr_value);
init_thunk(t, this_ptr_value, IVRCompositor_017_SuspendRendering, 1, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_SuspendRendering)(bool bSuspend) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_SuspendRendering(1);
check_ptr_parameter("IVRCompositor_017_SuspendRendering", this_ptr_value);
check_bool_parameter("IVRCompositor_017_SuspendRendering", 1);
init_thunk(t, this_ptr_value, IVRCompositor_017_GetMirrorTextureD3D11, 3, FALSE, FALSE);
EVRCompositorError (__stdcall *capi_IVRCompositor_017_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
check_ptr_parameter("IVRCompositor_017_GetMirrorTextureD3D11", this_ptr_value);
check_uint32_parameter("IVRCompositor_017_GetMirrorTextureD3D11", 1);
check_ptr_parameter("IVRCompositor_017_GetMirrorTextureD3D11", (void *)2);
check_ptr_parameter("IVRCompositor_017_GetMirrorTextureD3D11", (void *)3);
init_thunk(t, this_ptr_value, IVRCompositor_017_GetMirrorTextureGL, 3, FALSE, FALSE);
EVRCompositorError (__stdcall *capi_IVRCompositor_017_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_GetMirrorTextureGL(1, (void *)2, (void *)3);
check_ptr_parameter("IVRCompositor_017_GetMirrorTextureGL", this_ptr_value);
check_uint32_parameter("IVRCompositor_017_GetMirrorTextureGL", 1);
check_ptr_parameter("IVRCompositor_017_GetMirrorTextureGL", (void *)2);
check_ptr_parameter("IVRCompositor_017_GetMirrorTextureGL", (void *)3);
init_thunk(t, this_ptr_value, IVRCompositor_017_ReleaseSharedGLTexture, 2, FALSE, FALSE);
bool (__stdcall *capi_IVRCompositor_017_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_ReleaseSharedGLTexture(1, (void *)2);
check_ptr_parameter("IVRCompositor_017_ReleaseSharedGLTexture", this_ptr_value);
check_uint32_parameter("IVRCompositor_017_ReleaseSharedGLTexture", 1);
check_ptr_parameter("IVRCompositor_017_ReleaseSharedGLTexture", (void *)2);
init_thunk(t, this_ptr_value, IVRCompositor_017_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_LockGLSharedTextureForAccess((void *)1);
check_ptr_parameter("IVRCompositor_017_LockGLSharedTextureForAccess", this_ptr_value);
check_ptr_parameter("IVRCompositor_017_LockGLSharedTextureForAccess", (void *)1);
init_thunk(t, this_ptr_value, IVRCompositor_017_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
void (__stdcall *capi_IVRCompositor_017_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
clear_parameters();
capi_IVRCompositor_017_UnlockGLSharedTextureForAccess((void *)1);
check_ptr_parameter("IVRCompositor_017_UnlockGLSharedTextureForAccess", this_ptr_value);
check_ptr_parameter("IVRCompositor_017_UnlockGLSharedTextureForAccess", (void *)1);
VirtualFree(t, 0, MEM_RELEASE);
}
void test_capi_thunks_IVRSystem_012(void)
{
struct thunk *t = alloc_thunks(1);

View file

@ -38,6 +38,7 @@ int main(void)
test_capi_thunks_IVRSystem_014();
test_capi_thunks_IVRCompositor_018();
test_capi_thunks_IVROverlay_013();
test_capi_thunks_IVRCompositor_017();
test_capi_thunks_IVRSystem_012();
test_capi_thunks_IVRCompositor_016();
test_capi_thunks_IVRSettings_001();

View file

@ -0,0 +1,194 @@
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.0.3a/ivrclientcore.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
}
#include "cppIVRCompositor_IVRCompositor_017.h"
#ifdef __cplusplus
extern "C" {
#endif
void cppIVRCompositor_IVRCompositor_017_SetTrackingSpace(void *linux_side, ETrackingUniverseOrigin eOrigin)
{
((IVRCompositor*)linux_side)->SetTrackingSpace((vr::ETrackingUniverseOrigin)eOrigin);
}
vr::ETrackingUniverseOrigin cppIVRCompositor_IVRCompositor_017_GetTrackingSpace(void *linux_side)
{
return ((IVRCompositor*)linux_side)->GetTrackingSpace();
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_017_WaitGetPoses(void *linux_side, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
{
return ((IVRCompositor*)linux_side)->WaitGetPoses((vr::TrackedDevicePose_t *)pRenderPoseArray, (uint32_t)unRenderPoseArrayCount, (vr::TrackedDevicePose_t *)pGamePoseArray, (uint32_t)unGamePoseArrayCount);
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_017_GetLastPoses(void *linux_side, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
{
return ((IVRCompositor*)linux_side)->GetLastPoses((vr::TrackedDevicePose_t *)pRenderPoseArray, (uint32_t)unRenderPoseArrayCount, (vr::TrackedDevicePose_t *)pGamePoseArray, (uint32_t)unGamePoseArrayCount);
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
{
return ((IVRCompositor*)linux_side)->GetLastPoseForTrackedDeviceIndex((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::TrackedDevicePose_t *)pOutputPose, (vr::TrackedDevicePose_t *)pOutputGamePose);
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_017_Submit(void *linux_side, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
{
return ((IVRCompositor*)linux_side)->Submit((vr::EVREye)eEye, (const vr::Texture_t *)pTexture, (const vr::VRTextureBounds_t *)pBounds, (vr::EVRSubmitFlags)nSubmitFlags);
}
void cppIVRCompositor_IVRCompositor_017_ClearLastSubmittedFrame(void *linux_side)
{
((IVRCompositor*)linux_side)->ClearLastSubmittedFrame();
}
void cppIVRCompositor_IVRCompositor_017_PostPresentHandoff(void *linux_side)
{
((IVRCompositor*)linux_side)->PostPresentHandoff();
}
bool cppIVRCompositor_IVRCompositor_017_GetFrameTiming(void *linux_side, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
{
return ((IVRCompositor*)linux_side)->GetFrameTiming((vr::Compositor_FrameTiming *)pTiming, (uint32_t)unFramesAgo);
}
uint32_t cppIVRCompositor_IVRCompositor_017_GetFrameTimings(void *linux_side, Compositor_FrameTiming * pTiming, uint32_t nFrames)
{
return ((IVRCompositor*)linux_side)->GetFrameTimings((vr::Compositor_FrameTiming *)pTiming, (uint32_t)nFrames);
}
float cppIVRCompositor_IVRCompositor_017_GetFrameTimeRemaining(void *linux_side)
{
return ((IVRCompositor*)linux_side)->GetFrameTimeRemaining();
}
void cppIVRCompositor_IVRCompositor_017_GetCumulativeStats(void *linux_side, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
{
((IVRCompositor*)linux_side)->GetCumulativeStats((vr::Compositor_CumulativeStats *)pStats, (uint32_t)nStatsSizeInBytes);
}
void cppIVRCompositor_IVRCompositor_017_FadeToColor(void *linux_side, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
{
((IVRCompositor*)linux_side)->FadeToColor((float)fSeconds, (float)fRed, (float)fGreen, (float)fBlue, (float)fAlpha, (bool)bBackground);
}
void cppIVRCompositor_IVRCompositor_017_FadeGrid(void *linux_side, float fSeconds, bool bFadeIn)
{
((IVRCompositor*)linux_side)->FadeGrid((float)fSeconds, (bool)bFadeIn);
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_017_SetSkyboxOverride(void *linux_side, Texture_t * pTextures, uint32_t unTextureCount)
{
return ((IVRCompositor*)linux_side)->SetSkyboxOverride((const vr::Texture_t *)pTextures, (uint32_t)unTextureCount);
}
void cppIVRCompositor_IVRCompositor_017_ClearSkyboxOverride(void *linux_side)
{
((IVRCompositor*)linux_side)->ClearSkyboxOverride();
}
void cppIVRCompositor_IVRCompositor_017_CompositorBringToFront(void *linux_side)
{
((IVRCompositor*)linux_side)->CompositorBringToFront();
}
void cppIVRCompositor_IVRCompositor_017_CompositorGoToBack(void *linux_side)
{
((IVRCompositor*)linux_side)->CompositorGoToBack();
}
void cppIVRCompositor_IVRCompositor_017_CompositorQuit(void *linux_side)
{
((IVRCompositor*)linux_side)->CompositorQuit();
}
bool cppIVRCompositor_IVRCompositor_017_IsFullscreen(void *linux_side)
{
return ((IVRCompositor*)linux_side)->IsFullscreen();
}
uint32_t cppIVRCompositor_IVRCompositor_017_GetCurrentSceneFocusProcess(void *linux_side)
{
return ((IVRCompositor*)linux_side)->GetCurrentSceneFocusProcess();
}
uint32_t cppIVRCompositor_IVRCompositor_017_GetLastFrameRenderer(void *linux_side)
{
return ((IVRCompositor*)linux_side)->GetLastFrameRenderer();
}
bool cppIVRCompositor_IVRCompositor_017_CanRenderScene(void *linux_side)
{
return ((IVRCompositor*)linux_side)->CanRenderScene();
}
void cppIVRCompositor_IVRCompositor_017_ShowMirrorWindow(void *linux_side)
{
((IVRCompositor*)linux_side)->ShowMirrorWindow();
}
void cppIVRCompositor_IVRCompositor_017_HideMirrorWindow(void *linux_side)
{
((IVRCompositor*)linux_side)->HideMirrorWindow();
}
bool cppIVRCompositor_IVRCompositor_017_IsMirrorWindowVisible(void *linux_side)
{
return ((IVRCompositor*)linux_side)->IsMirrorWindowVisible();
}
void cppIVRCompositor_IVRCompositor_017_CompositorDumpImages(void *linux_side)
{
((IVRCompositor*)linux_side)->CompositorDumpImages();
}
bool cppIVRCompositor_IVRCompositor_017_ShouldAppRenderWithLowResources(void *linux_side)
{
return ((IVRCompositor*)linux_side)->ShouldAppRenderWithLowResources();
}
void cppIVRCompositor_IVRCompositor_017_ForceInterleavedReprojectionOn(void *linux_side, bool bOverride)
{
((IVRCompositor*)linux_side)->ForceInterleavedReprojectionOn((bool)bOverride);
}
void cppIVRCompositor_IVRCompositor_017_ForceReconnectProcess(void *linux_side)
{
((IVRCompositor*)linux_side)->ForceReconnectProcess();
}
void cppIVRCompositor_IVRCompositor_017_SuspendRendering(void *linux_side, bool bSuspend)
{
((IVRCompositor*)linux_side)->SuspendRendering((bool)bSuspend);
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_017_GetMirrorTextureD3D11(void *linux_side, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
{
return ((IVRCompositor*)linux_side)->GetMirrorTextureD3D11((vr::EVREye)eEye, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView);
}
vr::EVRCompositorError cppIVRCompositor_IVRCompositor_017_GetMirrorTextureGL(void *linux_side, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
{
return ((IVRCompositor*)linux_side)->GetMirrorTextureGL((vr::EVREye)eEye, (vr::glUInt_t *)pglTextureId, (vr::glSharedTextureHandle_t *)pglSharedTextureHandle);
}
bool cppIVRCompositor_IVRCompositor_017_ReleaseSharedGLTexture(void *linux_side, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
{
return ((IVRCompositor*)linux_side)->ReleaseSharedGLTexture((vr::glUInt_t)glTextureId, (vr::glSharedTextureHandle_t)glSharedTextureHandle);
}
void cppIVRCompositor_IVRCompositor_017_LockGLSharedTextureForAccess(void *linux_side, glSharedTextureHandle_t glSharedTextureHandle)
{
((IVRCompositor*)linux_side)->LockGLSharedTextureForAccess((vr::glSharedTextureHandle_t)glSharedTextureHandle);
}
void cppIVRCompositor_IVRCompositor_017_UnlockGLSharedTextureForAccess(void *linux_side, glSharedTextureHandle_t glSharedTextureHandle)
{
((IVRCompositor*)linux_side)->UnlockGLSharedTextureForAccess((vr::glSharedTextureHandle_t)glSharedTextureHandle);
}
#ifdef __cplusplus
}
#endif

View file

@ -0,0 +1,42 @@
#ifdef __cplusplus
extern "C" {
#endif
extern void cppIVRCompositor_IVRCompositor_017_SetTrackingSpace(void *, ETrackingUniverseOrigin);
extern ETrackingUniverseOrigin cppIVRCompositor_IVRCompositor_017_GetTrackingSpace(void *);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_017_WaitGetPoses(void *, TrackedDevicePose_t *, uint32_t, TrackedDevicePose_t *, uint32_t);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_017_GetLastPoses(void *, TrackedDevicePose_t *, uint32_t, TrackedDevicePose_t *, uint32_t);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex(void *, TrackedDeviceIndex_t, TrackedDevicePose_t *, TrackedDevicePose_t *);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_017_Submit(void *, EVREye, Texture_t *, VRTextureBounds_t *, EVRSubmitFlags);
extern void cppIVRCompositor_IVRCompositor_017_ClearLastSubmittedFrame(void *);
extern void cppIVRCompositor_IVRCompositor_017_PostPresentHandoff(void *);
extern bool cppIVRCompositor_IVRCompositor_017_GetFrameTiming(void *, Compositor_FrameTiming *, uint32_t);
extern uint32_t cppIVRCompositor_IVRCompositor_017_GetFrameTimings(void *, Compositor_FrameTiming *, uint32_t);
extern float cppIVRCompositor_IVRCompositor_017_GetFrameTimeRemaining(void *);
extern void cppIVRCompositor_IVRCompositor_017_GetCumulativeStats(void *, Compositor_CumulativeStats *, uint32_t);
extern void cppIVRCompositor_IVRCompositor_017_FadeToColor(void *, float, float, float, float, float, bool);
extern void cppIVRCompositor_IVRCompositor_017_FadeGrid(void *, float, bool);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_017_SetSkyboxOverride(void *, Texture_t *, uint32_t);
extern void cppIVRCompositor_IVRCompositor_017_ClearSkyboxOverride(void *);
extern void cppIVRCompositor_IVRCompositor_017_CompositorBringToFront(void *);
extern void cppIVRCompositor_IVRCompositor_017_CompositorGoToBack(void *);
extern void cppIVRCompositor_IVRCompositor_017_CompositorQuit(void *);
extern bool cppIVRCompositor_IVRCompositor_017_IsFullscreen(void *);
extern uint32_t cppIVRCompositor_IVRCompositor_017_GetCurrentSceneFocusProcess(void *);
extern uint32_t cppIVRCompositor_IVRCompositor_017_GetLastFrameRenderer(void *);
extern bool cppIVRCompositor_IVRCompositor_017_CanRenderScene(void *);
extern void cppIVRCompositor_IVRCompositor_017_ShowMirrorWindow(void *);
extern void cppIVRCompositor_IVRCompositor_017_HideMirrorWindow(void *);
extern bool cppIVRCompositor_IVRCompositor_017_IsMirrorWindowVisible(void *);
extern void cppIVRCompositor_IVRCompositor_017_CompositorDumpImages(void *);
extern bool cppIVRCompositor_IVRCompositor_017_ShouldAppRenderWithLowResources(void *);
extern void cppIVRCompositor_IVRCompositor_017_ForceInterleavedReprojectionOn(void *, bool);
extern void cppIVRCompositor_IVRCompositor_017_ForceReconnectProcess(void *);
extern void cppIVRCompositor_IVRCompositor_017_SuspendRendering(void *, bool);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_017_GetMirrorTextureD3D11(void *, EVREye, void *, void **);
extern EVRCompositorError cppIVRCompositor_IVRCompositor_017_GetMirrorTextureGL(void *, EVREye, glUInt_t *, glSharedTextureHandle_t *);
extern bool cppIVRCompositor_IVRCompositor_017_ReleaseSharedGLTexture(void *, glUInt_t, glSharedTextureHandle_t);
extern void cppIVRCompositor_IVRCompositor_017_LockGLSharedTextureForAccess(void *, glSharedTextureHandle_t);
extern void cppIVRCompositor_IVRCompositor_017_UnlockGLSharedTextureForAccess(void *, glSharedTextureHandle_t);
#ifdef __cplusplus
}
#endif

View file

@ -138,6 +138,16 @@ extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_104_unwrap(winR
typedef struct winRenderModel_t_104 winRenderModel_t_104;
extern struct winRenderModel_t_104 *struct_RenderModel_t_104_wrap(void *l);
extern RenderModel_t *struct_RenderModel_t_104_unwrap(winRenderModel_t_104 *w);
typedef struct winVREvent_t_103a winVREvent_t_103a;
extern void struct_VREvent_t_103a_lin_to_win(void *l, void *w);
typedef struct winVRControllerState001_t_103a winVRControllerState001_t_103a;
extern void struct_VRControllerState001_t_103a_lin_to_win(void *l, void *w);
typedef struct winRenderModel_TextureMap_t_103a winRenderModel_TextureMap_t_103a;
extern struct winRenderModel_TextureMap_t_103a *struct_RenderModel_TextureMap_t_103a_wrap(void *l);
extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_103a_unwrap(winRenderModel_TextureMap_t_103a *w);
typedef struct winRenderModel_t_103a winRenderModel_t_103a;
extern struct winRenderModel_t_103a *struct_RenderModel_t_103a_wrap(void *l);
extern RenderModel_t *struct_RenderModel_t_103a_unwrap(winRenderModel_t_103a *w);
typedef struct winVREvent_t_103 winVREvent_t_103;
extern void struct_VREvent_t_103_lin_to_win(void *l, void *w);
typedef struct winVRControllerState001_t_103 winVRControllerState001_t_103;

View file

@ -0,0 +1,100 @@
#include <stdlib.h>
#include <string.h>
#include "vrclient_private.h"
#include "vrclient_defs.h"
#include "openvr_v1.0.3a/openvr.h"
using namespace vr;
extern "C" {
#include "struct_converters.h"
struct winVREvent_t_103a {
uint32_t eventType;
vr::TrackedDeviceIndex_t trackedDeviceIndex;
float eventAgeSeconds;
vr::VREvent_Data_t data;
} __attribute__ ((ms_struct));
void struct_VREvent_t_103a_lin_to_win(void *l, void *w)
{
struct winVREvent_t_103a *win = (struct winVREvent_t_103a *)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_103a {
uint32_t unPacketNum;
uint64_t ulButtonPressed;
uint64_t ulButtonTouched;
vr::VRControllerAxis_t rAxis[5];
} __attribute__ ((ms_struct));
void struct_VRControllerState001_t_103a_lin_to_win(void *l, void *w)
{
struct winVRControllerState001_t_103a *win = (struct winVRControllerState001_t_103a *)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_103a {
uint16_t unWidth;
uint16_t unHeight;
const uint8_t * rubTextureMapData;
RenderModel_TextureMap_t *linux_side;
} __attribute__ ((ms_struct));
struct winRenderModel_TextureMap_t_103a *struct_RenderModel_TextureMap_t_103a_wrap(void *l)
{
struct winRenderModel_TextureMap_t_103a *win = (struct winRenderModel_TextureMap_t_103a *)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_103a_unwrap(winRenderModel_TextureMap_t_103a *w)
{
RenderModel_TextureMap_t *ret = w->linux_side;
free(w);
return ret;
}
struct winRenderModel_t_103a {
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_103a *struct_RenderModel_t_103a_wrap(void *l)
{
struct winRenderModel_t_103a *win = (struct winRenderModel_t_103a *)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_103a_unwrap(winRenderModel_t_103a *w)
{
RenderModel_t *ret = w->linux_side;
free(w);
return ret;
}
}

View file

@ -2173,6 +2173,391 @@ void destroy_winIVRCompositor_IVRCompositor_018_FnTable(void *object)
HeapFree(GetProcessHeap(), 0, win_object);
}
#include "cppIVRCompositor_IVRCompositor_017.h"
typedef struct __winIVRCompositor_IVRCompositor_017 {
vtable_ptr *vtable;
void *linux_side;
struct compositor_data user_data;
} winIVRCompositor_IVRCompositor_017;
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_SetTrackingSpace, 8)
void __thiscall winIVRCompositor_IVRCompositor_017_SetTrackingSpace(winIVRCompositor_IVRCompositor_017 *_this, ETrackingUniverseOrigin eOrigin)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_SetTrackingSpace(_this->linux_side, eOrigin);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetTrackingSpace, 4)
ETrackingUniverseOrigin __thiscall winIVRCompositor_IVRCompositor_017_GetTrackingSpace(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_GetTrackingSpace(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_WaitGetPoses, 28)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_017_WaitGetPoses(winIVRCompositor_IVRCompositor_017 *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
{
TRACE("%p\n", _this);
return ivrcompositor_wait_get_poses(cppIVRCompositor_IVRCompositor_017_WaitGetPoses, _this->linux_side, pRenderPoseArray, unRenderPoseArrayCount, pGamePoseArray, unGamePoseArrayCount, 17, &_this->user_data);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetLastPoses, 28)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_017_GetLastPoses(winIVRCompositor_IVRCompositor_017 *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_GetLastPoses(_this->linux_side, pRenderPoseArray, unRenderPoseArrayCount, pGamePoseArray, unGamePoseArrayCount);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex, 24)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex(winIVRCompositor_IVRCompositor_017 *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex(_this->linux_side, unDeviceIndex, pOutputPose, pOutputGamePose);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_Submit, 28)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_017_Submit(winIVRCompositor_IVRCompositor_017 *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
{
TRACE("%p\n", _this);
return ivrcompositor_submit(cppIVRCompositor_IVRCompositor_017_Submit, _this->linux_side, eEye, pTexture, pBounds, nSubmitFlags, 17, &_this->user_data);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_ClearLastSubmittedFrame, 4)
void __thiscall winIVRCompositor_IVRCompositor_017_ClearLastSubmittedFrame(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_ClearLastSubmittedFrame(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_PostPresentHandoff, 4)
void __thiscall winIVRCompositor_IVRCompositor_017_PostPresentHandoff(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
ivrcompositor_post_present_handoff(cppIVRCompositor_IVRCompositor_017_PostPresentHandoff, _this->linux_side, 17, &_this->user_data);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetFrameTiming, 16)
bool __thiscall winIVRCompositor_IVRCompositor_017_GetFrameTiming(winIVRCompositor_IVRCompositor_017 *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_GetFrameTiming(_this->linux_side, pTiming, unFramesAgo);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetFrameTimings, 16)
uint32_t __thiscall winIVRCompositor_IVRCompositor_017_GetFrameTimings(winIVRCompositor_IVRCompositor_017 *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_GetFrameTimings(_this->linux_side, pTiming, nFrames);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetFrameTimeRemaining, 4)
float __thiscall winIVRCompositor_IVRCompositor_017_GetFrameTimeRemaining(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_GetFrameTimeRemaining(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetCumulativeStats, 16)
void __thiscall winIVRCompositor_IVRCompositor_017_GetCumulativeStats(winIVRCompositor_IVRCompositor_017 *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_GetCumulativeStats(_this->linux_side, pStats, nStatsSizeInBytes);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_FadeToColor, 25)
void __thiscall winIVRCompositor_IVRCompositor_017_FadeToColor(winIVRCompositor_IVRCompositor_017 *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_FadeToColor(_this->linux_side, fSeconds, fRed, fGreen, fBlue, fAlpha, bBackground);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_FadeGrid, 9)
void __thiscall winIVRCompositor_IVRCompositor_017_FadeGrid(winIVRCompositor_IVRCompositor_017 *_this, float fSeconds, bool bFadeIn)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_FadeGrid(_this->linux_side, fSeconds, bFadeIn);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_SetSkyboxOverride, 16)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_017_SetSkyboxOverride(winIVRCompositor_IVRCompositor_017 *_this, Texture_t * pTextures, uint32_t unTextureCount)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_SetSkyboxOverride(_this->linux_side, pTextures, unTextureCount);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_ClearSkyboxOverride, 4)
void __thiscall winIVRCompositor_IVRCompositor_017_ClearSkyboxOverride(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_ClearSkyboxOverride(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_CompositorBringToFront, 4)
void __thiscall winIVRCompositor_IVRCompositor_017_CompositorBringToFront(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_CompositorBringToFront(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_CompositorGoToBack, 4)
void __thiscall winIVRCompositor_IVRCompositor_017_CompositorGoToBack(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_CompositorGoToBack(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_CompositorQuit, 4)
void __thiscall winIVRCompositor_IVRCompositor_017_CompositorQuit(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_CompositorQuit(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_IsFullscreen, 4)
bool __thiscall winIVRCompositor_IVRCompositor_017_IsFullscreen(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_IsFullscreen(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetCurrentSceneFocusProcess, 4)
uint32_t __thiscall winIVRCompositor_IVRCompositor_017_GetCurrentSceneFocusProcess(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_GetCurrentSceneFocusProcess(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetLastFrameRenderer, 4)
uint32_t __thiscall winIVRCompositor_IVRCompositor_017_GetLastFrameRenderer(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_GetLastFrameRenderer(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_CanRenderScene, 4)
bool __thiscall winIVRCompositor_IVRCompositor_017_CanRenderScene(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_CanRenderScene(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_ShowMirrorWindow, 4)
void __thiscall winIVRCompositor_IVRCompositor_017_ShowMirrorWindow(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_ShowMirrorWindow(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_HideMirrorWindow, 4)
void __thiscall winIVRCompositor_IVRCompositor_017_HideMirrorWindow(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_HideMirrorWindow(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_IsMirrorWindowVisible, 4)
bool __thiscall winIVRCompositor_IVRCompositor_017_IsMirrorWindowVisible(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_IsMirrorWindowVisible(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_CompositorDumpImages, 4)
void __thiscall winIVRCompositor_IVRCompositor_017_CompositorDumpImages(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_CompositorDumpImages(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_ShouldAppRenderWithLowResources, 4)
bool __thiscall winIVRCompositor_IVRCompositor_017_ShouldAppRenderWithLowResources(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_ShouldAppRenderWithLowResources(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_ForceInterleavedReprojectionOn, 5)
void __thiscall winIVRCompositor_IVRCompositor_017_ForceInterleavedReprojectionOn(winIVRCompositor_IVRCompositor_017 *_this, bool bOverride)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_ForceInterleavedReprojectionOn(_this->linux_side, bOverride);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_ForceReconnectProcess, 4)
void __thiscall winIVRCompositor_IVRCompositor_017_ForceReconnectProcess(winIVRCompositor_IVRCompositor_017 *_this)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_ForceReconnectProcess(_this->linux_side);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_SuspendRendering, 5)
void __thiscall winIVRCompositor_IVRCompositor_017_SuspendRendering(winIVRCompositor_IVRCompositor_017 *_this, bool bSuspend)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_SuspendRendering(_this->linux_side, bSuspend);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetMirrorTextureD3D11, 24)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_017_GetMirrorTextureD3D11(winIVRCompositor_IVRCompositor_017 *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_GetMirrorTextureD3D11(_this->linux_side, eEye, pD3D11DeviceOrResource, ppD3D11ShaderResourceView);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_GetMirrorTextureGL, 24)
EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_017_GetMirrorTextureGL(winIVRCompositor_IVRCompositor_017 *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_GetMirrorTextureGL(_this->linux_side, eEye, pglTextureId, pglSharedTextureHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_ReleaseSharedGLTexture, 16)
bool __thiscall winIVRCompositor_IVRCompositor_017_ReleaseSharedGLTexture(winIVRCompositor_IVRCompositor_017 *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
{
TRACE("%p\n", _this);
return cppIVRCompositor_IVRCompositor_017_ReleaseSharedGLTexture(_this->linux_side, glTextureId, glSharedTextureHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_LockGLSharedTextureForAccess, 12)
void __thiscall winIVRCompositor_IVRCompositor_017_LockGLSharedTextureForAccess(winIVRCompositor_IVRCompositor_017 *_this, glSharedTextureHandle_t glSharedTextureHandle)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_LockGLSharedTextureForAccess(_this->linux_side, glSharedTextureHandle);
}
DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_017_UnlockGLSharedTextureForAccess, 12)
void __thiscall winIVRCompositor_IVRCompositor_017_UnlockGLSharedTextureForAccess(winIVRCompositor_IVRCompositor_017 *_this, glSharedTextureHandle_t glSharedTextureHandle)
{
TRACE("%p\n", _this);
cppIVRCompositor_IVRCompositor_017_UnlockGLSharedTextureForAccess(_this->linux_side, glSharedTextureHandle);
}
extern vtable_ptr winIVRCompositor_IVRCompositor_017_vtable;
#ifndef __GNUC__
void __asm_dummy_vtables(void) {
#endif
__ASM_VTABLE(winIVRCompositor_IVRCompositor_017,
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_SetTrackingSpace)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetTrackingSpace)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_WaitGetPoses)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetLastPoses)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_Submit)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_ClearLastSubmittedFrame)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_PostPresentHandoff)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetFrameTiming)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetFrameTimings)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetFrameTimeRemaining)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetCumulativeStats)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_FadeToColor)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_FadeGrid)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_SetSkyboxOverride)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_ClearSkyboxOverride)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_CompositorBringToFront)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_CompositorGoToBack)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_CompositorQuit)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_IsFullscreen)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetCurrentSceneFocusProcess)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetLastFrameRenderer)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_CanRenderScene)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_ShowMirrorWindow)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_HideMirrorWindow)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_IsMirrorWindowVisible)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_CompositorDumpImages)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_ShouldAppRenderWithLowResources)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_ForceInterleavedReprojectionOn)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_ForceReconnectProcess)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_SuspendRendering)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetMirrorTextureD3D11)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_GetMirrorTextureGL)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_ReleaseSharedGLTexture)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_LockGLSharedTextureForAccess)
VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_017_UnlockGLSharedTextureForAccess)
);
#ifndef __GNUC__
}
#endif
winIVRCompositor_IVRCompositor_017 *create_winIVRCompositor_IVRCompositor_017(void *linux_side)
{
winIVRCompositor_IVRCompositor_017 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_017));
TRACE("-> %p\n", r);
r->vtable = &winIVRCompositor_IVRCompositor_017_vtable;
r->linux_side = linux_side;
return r;
}
void destroy_winIVRCompositor_IVRCompositor_017(void *object)
{
TRACE("%p\n", object);
struct __winIVRCompositor_IVRCompositor_017 *win_object = object;
destroy_compositor_data(&win_object->user_data);
HeapFree(GetProcessHeap(), 0, object);
}
winIVRCompositor_IVRCompositor_017 *create_winIVRCompositor_IVRCompositor_017_FnTable(void *linux_side)
{
winIVRCompositor_IVRCompositor_017 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_017));
struct thunk *thunks = alloc_thunks(36);
struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 36 * sizeof(*vtable));
int i;
TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_017_SetTrackingSpace, 1, FALSE, FALSE);
init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_017_GetTrackingSpace, 0, FALSE, FALSE);
init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_017_WaitGetPoses, 4, FALSE, FALSE);
init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_017_GetLastPoses, 4, FALSE, FALSE);
init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_017_Submit, 4, FALSE, FALSE);
init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_017_ClearLastSubmittedFrame, 0, FALSE, FALSE);
init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_017_PostPresentHandoff, 0, FALSE, FALSE);
init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_017_GetFrameTiming, 2, FALSE, FALSE);
init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_017_GetFrameTimings, 2, FALSE, FALSE);
init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_017_GetFrameTimeRemaining, 0, FALSE, FALSE);
init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_017_GetCumulativeStats, 2, FALSE, FALSE);
init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_017_FadeToColor, 6, TRUE, TRUE);
init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_017_FadeGrid, 2, TRUE, FALSE);
init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_017_SetSkyboxOverride, 2, FALSE, FALSE);
init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_017_ClearSkyboxOverride, 0, FALSE, FALSE);
init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_017_CompositorBringToFront, 0, FALSE, FALSE);
init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_017_CompositorGoToBack, 0, FALSE, FALSE);
init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_017_CompositorQuit, 0, FALSE, FALSE);
init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_017_IsFullscreen, 0, FALSE, FALSE);
init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_017_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_017_GetLastFrameRenderer, 0, FALSE, FALSE);
init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_017_CanRenderScene, 0, FALSE, FALSE);
init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_017_ShowMirrorWindow, 0, FALSE, FALSE);
init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_017_HideMirrorWindow, 0, FALSE, FALSE);
init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_017_IsMirrorWindowVisible, 0, FALSE, FALSE);
init_thunk(&thunks[26], r, winIVRCompositor_IVRCompositor_017_CompositorDumpImages, 0, FALSE, FALSE);
init_thunk(&thunks[27], r, winIVRCompositor_IVRCompositor_017_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
init_thunk(&thunks[28], r, winIVRCompositor_IVRCompositor_017_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
init_thunk(&thunks[29], r, winIVRCompositor_IVRCompositor_017_ForceReconnectProcess, 0, FALSE, FALSE);
init_thunk(&thunks[30], r, winIVRCompositor_IVRCompositor_017_SuspendRendering, 1, FALSE, FALSE);
init_thunk(&thunks[31], r, winIVRCompositor_IVRCompositor_017_GetMirrorTextureD3D11, 3, FALSE, FALSE);
init_thunk(&thunks[32], r, winIVRCompositor_IVRCompositor_017_GetMirrorTextureGL, 3, FALSE, FALSE);
init_thunk(&thunks[33], r, winIVRCompositor_IVRCompositor_017_ReleaseSharedGLTexture, 2, FALSE, FALSE);
init_thunk(&thunks[34], r, winIVRCompositor_IVRCompositor_017_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
init_thunk(&thunks[35], r, winIVRCompositor_IVRCompositor_017_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
for (i = 0; i < 36; i++)
vtable[i] = &thunks[i];
r->linux_side = linux_side;
r->vtable = (void *)vtable;
return r;
}
void destroy_winIVRCompositor_IVRCompositor_017_FnTable(void *object)
{
winIVRCompositor_IVRCompositor_017 *win_object = object;
TRACE("%p\n", win_object);
destroy_compositor_data(&win_object->user_data);
VirtualFree(win_object->vtable[0], 0, MEM_RELEASE);
HeapFree(GetProcessHeap(), 0, win_object->vtable);
HeapFree(GetProcessHeap(), 0, win_object);
}
#include "cppIVRCompositor_IVRCompositor_016.h"
typedef struct __winIVRCompositor_IVRCompositor_016 {

View file

@ -64,6 +64,8 @@ extern void *create_winIVRCompositor_IVRCompositor_018(void *);
extern void *create_winIVRCompositor_IVRCompositor_018_FnTable(void *);
extern void *create_winIVROverlay_IVROverlay_013(void *);
extern void *create_winIVROverlay_IVROverlay_013_FnTable(void *);
extern void *create_winIVRCompositor_IVRCompositor_017(void *);
extern void *create_winIVRCompositor_IVRCompositor_017_FnTable(void *);
extern void *create_winIVRSystem_IVRSystem_012(void *);
extern void *create_winIVRSystem_IVRSystem_012_FnTable(void *);
extern void *create_winIVRCompositor_IVRCompositor_016(void *);

View file

@ -64,6 +64,8 @@
{"FnTable:IVRCompositor_018", &create_winIVRCompositor_IVRCompositor_018_FnTable, &destroy_winIVRCompositor_IVRCompositor_018_FnTable},
{"IVROverlay_013", &create_winIVROverlay_IVROverlay_013, &destroy_winIVROverlay_IVROverlay_013},
{"FnTable:IVROverlay_013", &create_winIVROverlay_IVROverlay_013_FnTable, &destroy_winIVROverlay_IVROverlay_013_FnTable},
{"IVRCompositor_017", &create_winIVRCompositor_IVRCompositor_017, &destroy_winIVRCompositor_IVRCompositor_017},
{"FnTable:IVRCompositor_017", &create_winIVRCompositor_IVRCompositor_017_FnTable, &destroy_winIVRCompositor_IVRCompositor_017_FnTable},
{"IVRSystem_012", &create_winIVRSystem_IVRSystem_012, &destroy_winIVRSystem_IVRSystem_012},
{"FnTable:IVRSystem_012", &create_winIVRSystem_IVRSystem_012_FnTable, &destroy_winIVRSystem_IVRSystem_012_FnTable},
{"IVRCompositor_016", &create_winIVRCompositor_IVRCompositor_016, &destroy_winIVRCompositor_IVRCompositor_016},

View file

@ -64,6 +64,8 @@ extern void destroy_winIVRCompositor_IVRCompositor_018(void *);
extern void destroy_winIVRCompositor_IVRCompositor_018_FnTable(void *);
extern void destroy_winIVROverlay_IVROverlay_013(void *);
extern void destroy_winIVROverlay_IVROverlay_013_FnTable(void *);
extern void destroy_winIVRCompositor_IVRCompositor_017(void *);
extern void destroy_winIVRCompositor_IVRCompositor_017_FnTable(void *);
extern void destroy_winIVRSystem_IVRSystem_012(void *);
extern void destroy_winIVRSystem_IVRSystem_012_FnTable(void *);
extern void destroy_winIVRCompositor_IVRCompositor_016(void *);