644 lines
44 KiB
C++
644 lines
44 KiB
C++
/*
|
|
OpenVR for PyMOL Copyright Notice
|
|
=====================================
|
|
|
|
The OpenVR for PyMOL source code is copyrighted, but you can freely use and
|
|
copy it as long as you don't change or remove any of the Copyright notices.
|
|
OpenVR for PyMOL is made available under the following open-source license
|
|
terms:
|
|
|
|
------------------------------------------------------------------------------
|
|
Copyright (c) 2018 EPAM Systems, Inc.
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
SOFTWARE.
|
|
------------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#ifndef _H_OpenVRStub
|
|
#define _H_OpenVRStub
|
|
|
|
// system headers
|
|
#include "openvr.h"
|
|
|
|
namespace vr {
|
|
namespace stub {
|
|
|
|
void VR_StubEnable(bool on = true);
|
|
bool VR_IsStubEnabled(void);
|
|
|
|
/** Finds the active installation of the VR API and initializes it. The provided path must be absolute
|
|
* or relative to the current working directory. These are the local install versions of the equivalent
|
|
* functions in steamvr.h and will work without a local Steam install.
|
|
*
|
|
* This path is to the "root" of the VR API install. That's the directory with
|
|
* the "drivers" directory and a platform (i.e. "win32") directory in it, not the directory with the DLL itself.
|
|
*
|
|
* pStartupInfo is reserved for future use.
|
|
*/
|
|
IVRSystem *VR_Init(EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo = nullptr);
|
|
|
|
/** unloads vrclient.dll. Any interface pointers from the interface are
|
|
* invalid after this point */
|
|
void VR_Shutdown();
|
|
|
|
/** Returns true if there is an HMD attached. This check is as lightweight as possible and
|
|
* can be called outside of VR_Init/VR_Shutdown. It should be used when an application wants
|
|
* to know if initializing VR is a possibility but isn't ready to take that step yet.
|
|
*/
|
|
bool VR_IsHmdPresent();
|
|
|
|
/** Returns an English string for an EVRInitError. Applications should call VR_GetVRInitErrorAsSymbol instead and
|
|
* use that as a key to look up their own localized error message. This function may be called outside of VR_Init()/VR_Shutdown(). */
|
|
const char *VR_GetVRInitErrorAsEnglishDescription(EVRInitError error);
|
|
|
|
IVRSystem *VRSystem();
|
|
IVRCompositor *VRCompositor();
|
|
IVRInput *VRInput();
|
|
|
|
#define VRSTUB_NOT_IMPLEMENTED \
|
|
throw __FUNCTION__; // " not implemented";
|
|
|
|
class VRSystemStub: public IVRSystem {
|
|
public:
|
|
// ------------------------------------
|
|
// Display Methods
|
|
// ------------------------------------
|
|
|
|
/** Suggested size for the intermediate render target that the distortion pulls from. */
|
|
virtual void GetRecommendedRenderTargetSize( uint32_t *pnWidth, uint32_t *pnHeight );
|
|
|
|
/** The projection matrix for the specified eye */
|
|
virtual HmdMatrix44_t GetProjectionMatrix( EVREye eEye, float fNearZ, float fFarZ ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** The components necessary to build your own projection matrix in case your
|
|
* application is doing something fancy like infinite Z */
|
|
virtual void GetProjectionRaw( EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom );
|
|
|
|
/** Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in
|
|
* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
|
|
* Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. */
|
|
virtual bool ComputeDistortion( EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head
|
|
* space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection.
|
|
* Normally View and Eye^-1 will be multiplied together and treated as View in your application.
|
|
*/
|
|
virtual HmdMatrix34_t GetEyeToHeadTransform( EVREye eEye );
|
|
|
|
/** Returns the number of elapsed seconds since the last recorded vsync event. This
|
|
* will come from a vsync timer event in the timer if possible or from the application-reported
|
|
* time if that is not available. If no vsync times are available the function will
|
|
* return zero for vsync time and frame counter and return false from the method. */
|
|
virtual bool GetTimeSinceLastVsync( float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** [D3D9 Only]
|
|
* Returns the adapter index that the user should pass into CreateDevice to set up D3D9 in such
|
|
* a way that it can go full screen exclusive on the HMD. Returns -1 if there was an error.
|
|
*/
|
|
virtual int32_t GetD3D9AdapterIndex() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** [D3D10/11 Only]
|
|
* Returns the adapter index that the user should pass into EnumAdapters to create the device
|
|
* and swap chain in DX10 and DX11. If an error occurs the index will be set to -1.
|
|
*/
|
|
virtual void GetDXGIOutputInfo( int32_t *pnAdapterIndex ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/**
|
|
* Returns platform- and texture-type specific adapter identification so that applications and the
|
|
* compositor are creating textures and swap chains on the same GPU. If an error occurs the device
|
|
* will be set to 0.
|
|
* pInstance is an optional parameter that is required only when textureType is TextureType_Vulkan.
|
|
* [D3D10/11/12 Only (D3D9 Not Supported)]
|
|
* Returns the adapter LUID that identifies the GPU attached to the HMD. The user should
|
|
* enumerate all adapters using IDXGIFactory::EnumAdapters and IDXGIAdapter::GetDesc to find
|
|
* the adapter with the matching LUID, or use IDXGIFactory4::EnumAdapterByLuid.
|
|
* The discovered IDXGIAdapter should be used to create the device and swap chain.
|
|
* [Vulkan Only]
|
|
* Returns the VkPhysicalDevice that should be used by the application.
|
|
* pInstance must be the instance the application will use to query for the VkPhysicalDevice. The application
|
|
* must create the VkInstance with extensions returned by IVRCompositor::GetVulkanInstanceExtensionsRequired enabled.
|
|
* [macOS Only]
|
|
* For TextureType_IOSurface returns the id<MTLDevice> that should be used by the application.
|
|
* On 10.13+ for TextureType_OpenGL returns the 'registryId' of the renderer which should be used
|
|
* by the application. See Apple Technical Q&A QA1168 for information on enumerating GL Renderers, and the
|
|
* new kCGLRPRegistryIDLow and kCGLRPRegistryIDHigh CGLRendererProperty values in the 10.13 SDK.
|
|
* Pre 10.13 for TextureType_OpenGL returns 0, as there is no dependable way to correlate the HMDs MTLDevice
|
|
* with a GL Renderer.
|
|
*/
|
|
virtual void GetOutputDevice( uint64_t *pnDevice, ETextureType textureType, VkInstance_T *pInstance = nullptr ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
// ------------------------------------
|
|
// Display Mode methods
|
|
// ------------------------------------
|
|
|
|
/** Use to determine if the headset display is part of the desktop (i.e. extended) or hidden (i.e. direct mode). */
|
|
virtual bool IsDisplayOnDesktop() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Set the display visibility (true = extended, false = direct mode). Return value of true indicates that the change was successful. */
|
|
virtual bool SetDisplayVisibility( bool bIsVisibleOnDesktop ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
// ------------------------------------
|
|
// Tracking Methods
|
|
// ------------------------------------
|
|
|
|
/** The pose that the tracker thinks that the HMD will be in at the specified number of seconds into the
|
|
* future. Pass 0 to get the state at the instant the method is called. Most of the time the application should
|
|
* calculate the time until the photons will be emitted from the display and pass that time into the method.
|
|
*
|
|
* This is roughly analogous to the inverse of the view matrix in most applications, though
|
|
* many games will need to do some additional rotation or translation on top of the rotation
|
|
* and translation provided by the head pose.
|
|
*
|
|
* For devices where bPoseIsValid is true the application can use the pose to position the device
|
|
* in question. The provided array can be any size up to k_unMaxTrackedDeviceCount.
|
|
*
|
|
* Seated experiences should call this method with TrackingUniverseSeated and receive poses relative
|
|
* to the seated zero pose. Standing experiences should call this method with TrackingUniverseStanding
|
|
* and receive poses relative to the Chaperone Play Area. TrackingUniverseRawAndUncalibrated should
|
|
* probably not be used unless the application is the Chaperone calibration tool itself, but will provide
|
|
* poses relative to the hardware-specific coordinate system in the driver.
|
|
*/
|
|
virtual void GetDeviceToAbsoluteTrackingPose( ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount) TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Sets the zero pose for the seated tracker coordinate system to the current position and yaw of the HMD. After
|
|
* ResetSeatedZeroPose all GetDeviceToAbsoluteTrackingPose calls that pass TrackingUniverseSeated as the origin
|
|
* will be relative to this new zero pose. The new zero coordinate system will not change the fact that the Y axis
|
|
* is up in the real world, so the next pose returned from GetDeviceToAbsoluteTrackingPose after a call to
|
|
* ResetSeatedZeroPose may not be exactly an identity matrix.
|
|
*
|
|
* NOTE: This function overrides the user's previously saved seated zero pose and should only be called as the result of a user action.
|
|
* Users are also able to set their seated zero pose via the OpenVR Dashboard.
|
|
**/
|
|
virtual void ResetSeatedZeroPose() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns the transform from the seated zero pose to the standing absolute tracking system. This allows
|
|
* applications to represent the seated origin to used or transform object positions from one coordinate
|
|
* system to the other.
|
|
*
|
|
* The seated origin may or may not be inside the Play Area or Collision Bounds returned by IVRChaperone. Its position
|
|
* depends on what the user has set from the Dashboard settings and previous calls to ResetSeatedZeroPose. */
|
|
virtual HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns the transform from the tracking origin to the standing absolute tracking system. This allows
|
|
* applications to convert from raw tracking space to the calibrated standing coordinate system. */
|
|
virtual HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Get a sorted array of device indices of a given class of tracked devices (e.g. controllers). Devices are sorted right to left
|
|
* relative to the specified tracked device (default: hmd -- pass in -1 for absolute tracking space). Returns the number of devices
|
|
* in the list, or the size of the array needed if not large enough. */
|
|
virtual uint32_t GetSortedTrackedDeviceIndicesOfClass( ETrackedDeviceClass eTrackedDeviceClass, VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount) vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex = k_unTrackedDeviceIndex_Hmd ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns the level of activity on the device. */
|
|
virtual EDeviceActivityLevel GetTrackedDeviceActivityLevel( vr::TrackedDeviceIndex_t unDeviceId ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Convenience utility to apply the specified transform to the specified pose.
|
|
* This properly transforms all pose components, including velocity and angular velocity
|
|
*/
|
|
virtual void ApplyTransform( TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns the device index associated with a specific role, for example the left hand or the right hand. */
|
|
virtual vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForControllerRole( vr::ETrackedControllerRole unDeviceType ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns the controller type associated with a device index. */
|
|
virtual vr::ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex( vr::TrackedDeviceIndex_t unDeviceIndex ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
// ------------------------------------
|
|
// Property methods
|
|
// ------------------------------------
|
|
|
|
/** Returns the device class of a tracked device. If there has not been a device connected in this slot
|
|
* since the application started this function will return TrackedDevice_Invalid. For previous detected
|
|
* devices the function will return the previously observed device class.
|
|
*
|
|
* To determine which devices exist on the system, just loop from 0 to k_unMaxTrackedDeviceCount and check
|
|
* the device class. Every device with something other than TrackedDevice_Invalid is associated with an
|
|
* actual tracked device. */
|
|
virtual ETrackedDeviceClass GetTrackedDeviceClass( vr::TrackedDeviceIndex_t unDeviceIndex );
|
|
|
|
/** Returns true if there is a device connected in this slot. */
|
|
virtual bool IsTrackedDeviceConnected( vr::TrackedDeviceIndex_t unDeviceIndex ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false. */
|
|
virtual bool GetBoolTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns a float property. If the device index is not valid or the property is not a float type this function will return 0. */
|
|
virtual float GetFloatTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns an int property. If the device index is not valid or the property is not a int type this function will return 0. */
|
|
virtual int32_t GetInt32TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns a uint64 property. If the device index is not valid or the property is not a uint64 type this function will return 0. */
|
|
virtual uint64_t GetUint64TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns a matrix property. If the device index is not valid or the property is not a matrix type, this function will return identity. */
|
|
virtual HmdMatrix34_t GetMatrix34TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns an array of one type of property. If the device index is not valid or the property is not a single value or an array of the specified type,
|
|
* this function will return 0. Otherwise it returns the number of bytes necessary to hold the array of properties. If unBufferSize is
|
|
* greater than the returned size and pBuffer is non-NULL, pBuffer is filled with the contents of array of properties. */
|
|
virtual uint32_t GetArrayTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void *pBuffer, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns a string property. If the device index is not valid or the property is not a string type this function will
|
|
* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
|
|
* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
|
|
virtual uint32_t GetStringTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L );
|
|
|
|
/** returns a string that corresponds with the specified property error. The string will be the name
|
|
* of the error enum value for all valid error codes */
|
|
virtual const char *GetPropErrorNameFromEnum( ETrackedPropertyError error ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
// ------------------------------------
|
|
// Event methods
|
|
// ------------------------------------
|
|
|
|
/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
|
|
* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
|
|
virtual bool PollNextEvent( VREvent_t *pEvent, uint32_t uncbVREvent );
|
|
|
|
/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
|
|
* this method returns false. Fills in the pose of the associated tracked device in the provided pose struct.
|
|
* This pose will always be older than the call to this function and should not be used to render the device.
|
|
uncbVREvent should be the size in bytes of the VREvent_t struct */
|
|
virtual bool PollNextEventWithPose( ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** returns the name of an EVREvent enum value */
|
|
virtual const char *GetEventTypeNameFromEnum( EVREventType eType ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
// ------------------------------------
|
|
// Rendering helper methods
|
|
// ------------------------------------
|
|
|
|
/** Returns the hidden area mesh for the current HMD. The pixels covered by this mesh will never be seen by the user after the lens distortion is
|
|
* applied based on visibility to the panels. If this HMD does not have a hidden area mesh, the vertex data and count will be NULL and 0 respectively.
|
|
* This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering each eye's view.
|
|
* This will improve performance by letting the GPU early-reject pixels the user will never see before running the pixel shader.
|
|
* NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye.
|
|
* Setting the bInverse argument to true will produce the visible area mesh that is commonly used in place of full-screen quads. The visible area mesh covers all of the pixels the hidden area mesh does not cover.
|
|
* Setting the bLineLoop argument will return a line loop of vertices in HiddenAreaMesh_t->pVertexData with HiddenAreaMesh_t->unTriangleCount set to the number of vertices.
|
|
*/
|
|
virtual HiddenAreaMesh_t GetHiddenAreaMesh( EVREye eEye, EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
// ------------------------------------
|
|
// Controller methods
|
|
// ------------------------------------
|
|
|
|
/** Fills the supplied struct with the current state of the controller. Returns false if the controller index
|
|
* is invalid. */
|
|
virtual bool GetControllerState( vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** fills the supplied struct with the current state of the controller and the provided pose with the pose of
|
|
* the controller when the controller state was updated most recently. Use this form if you need a precise controller
|
|
* pose as input to your application when the user presses or releases a button. */
|
|
virtual bool GetControllerStateWithPose( ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
|
|
* and axis combination for 5ms. */
|
|
virtual void TriggerHapticPulse( vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** returns the name of an EVRButtonId enum value */
|
|
virtual const char *GetButtonIdNameFromEnum( EVRButtonId eButtonId ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** returns the name of an EVRControllerAxisType enum value */
|
|
virtual const char *GetControllerAxisTypeNameFromEnum( EVRControllerAxisType eAxisType ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns true if this application is receiving input from the system. This would return false if
|
|
* system-related functionality is consuming the input stream. */
|
|
virtual bool IsInputAvailable() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns true SteamVR is drawing controllers on top of the application. Applications should consider
|
|
* not drawing anything attached to the user's hands in this case. */
|
|
virtual bool IsSteamVRDrawingControllers() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns true if the user has put SteamVR into a mode that is distracting them from the application.
|
|
* For applications where this is appropriate, the application should pause ongoing activity. */
|
|
virtual bool ShouldApplicationPause() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns true if SteamVR is doing significant rendering work and the game should do what it can to reduce
|
|
* its own workload. One common way to do this is to reduce the size of the render target provided for each eye. */
|
|
virtual bool ShouldApplicationReduceRenderingWork() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
// ------------------------------------
|
|
// Debug Methods
|
|
// ------------------------------------
|
|
|
|
/** Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
|
|
* but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated.
|
|
* The size of the response including its terminating null is returned. */
|
|
virtual uint32_t DriverDebugRequest( vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest, VR_OUT_STRING() char *pchResponseBuffer, uint32_t unResponseBufferSize ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
// ------------------------------------
|
|
// Firmware methods
|
|
// ------------------------------------
|
|
|
|
/** Performs the actual firmware update if applicable.
|
|
* The following events will be sent, if VRFirmwareError_None was returned: VREvent_FirmwareUpdateStarted, VREvent_FirmwareUpdateFinished
|
|
* Use the properties Prop_Firmware_UpdateAvailable_Bool, Prop_Firmware_ManualUpdate_Bool, and Prop_Firmware_ManualUpdateURL_String
|
|
* to figure our whether a firmware update is available, and to figure out whether its a manual update
|
|
* Prop_Firmware_ManualUpdateURL_String should point to an URL describing the manual update process */
|
|
virtual vr::EVRFirmwareError PerformFirmwareUpdate( vr::TrackedDeviceIndex_t unDeviceIndex ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
// ------------------------------------
|
|
// Application life cycle methods
|
|
// ------------------------------------
|
|
|
|
/** Call this to acknowledge to the system that VREvent_Quit has been received and that the process is exiting.
|
|
* This extends the timeout until the process is killed. */
|
|
virtual void AcknowledgeQuit_Exiting() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Call this to tell the system that the user is being prompted to save data. This
|
|
* halts the timeout and dismisses the dashboard (if it was up). Applications should be sure to actually
|
|
* prompt the user to save and then exit afterward, otherwise the user will be left in a confusing state. */
|
|
virtual void AcknowledgeQuit_UserPrompt() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
};
|
|
|
|
class VRCompositorStub: public IVRCompositor {
|
|
public:
|
|
/** Sets tracking space returned by WaitGetPoses */
|
|
virtual void SetTrackingSpace( ETrackingUniverseOrigin eOrigin ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Gets current tracking space returned by WaitGetPoses */
|
|
virtual ETrackingUniverseOrigin GetTrackingSpace() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Scene applications should call this function to get poses to render with (and optionally poses predicted an additional frame out to use for gameplay).
|
|
* This function will block until "running start" milliseconds before the start of the frame, and should be called at the last moment before needing to
|
|
* start rendering.
|
|
*
|
|
* Return codes:
|
|
* - IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
|
|
* - DoNotHaveFocus (some other app has taken focus - this will throttle the call to 10hz to reduce the impact on that app)
|
|
*/
|
|
virtual EVRCompositorError WaitGetPoses( VR_ARRAY_COUNT(unRenderPoseArrayCount) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
|
|
VR_ARRAY_COUNT(unGamePoseArrayCount) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount );
|
|
|
|
/** Get the last set of poses returned by WaitGetPoses. */
|
|
virtual EVRCompositorError GetLastPoses( VR_ARRAY_COUNT( unRenderPoseArrayCount ) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
|
|
VR_ARRAY_COUNT( unGamePoseArrayCount ) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Interface for accessing last set of poses returned by WaitGetPoses one at a time.
|
|
* Returns VRCompositorError_IndexOutOfRange if unDeviceIndex not less than k_unMaxTrackedDeviceCount otherwise VRCompositorError_None.
|
|
* It is okay to pass NULL for either pose if you only want one of the values. */
|
|
virtual EVRCompositorError GetLastPoseForTrackedDeviceIndex( TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Updated scene texture to display. If pBounds is NULL the entire texture will be used. If called from an OpenGL app, consider adding a glFlush after
|
|
* Submitting both frames to signal the driver to start processing, otherwise it may wait until the command buffer fills up, causing the app to miss frames.
|
|
*
|
|
* OpenGL dirty state:
|
|
* glBindTexture
|
|
*
|
|
* Return codes:
|
|
* - IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
|
|
* - DoNotHaveFocus (some other app has taken focus)
|
|
* - TextureIsOnWrongDevice (application did not use proper AdapterIndex - see IVRSystem.GetDXGIOutputInfo)
|
|
* - SharedTexturesNotSupported (application needs to call CreateDXGIFactory1 or later before creating DX device)
|
|
* - TextureUsesUnsupportedFormat (scene textures must be compatible with DXGI sharing rules - e.g. uncompressed, no mips, etc.)
|
|
* - InvalidTexture (usually means bad arguments passed in)
|
|
* - AlreadySubmitted (app has submitted two left textures or two right textures in a single frame - i.e. before calling WaitGetPoses again)
|
|
*/
|
|
virtual EVRCompositorError Submit( EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t* pBounds = 0, EVRSubmitFlags nSubmitFlags = Submit_Default );
|
|
|
|
/** Clears the frame that was sent with the last call to Submit. This will cause the
|
|
* compositor to show the grid until Submit is called again. */
|
|
virtual void ClearLastSubmittedFrame() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Call immediately after presenting your app's window (i.e. companion window) to unblock the compositor.
|
|
* This is an optional call, which only needs to be used if you can't instead call WaitGetPoses immediately after Present.
|
|
* For example, if your engine's render and game loop are not on separate threads, or blocking the render thread until 3ms before the next vsync would
|
|
* introduce a deadlock of some sort. This function tells the compositor that you have finished all rendering after having Submitted buffers for both
|
|
* eyes, and it is free to start its rendering work. This should only be called from the same thread you are rendering on. */
|
|
virtual void PostPresentHandoff() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns true if timing data is filled it. Sets oldest timing info if nFramesAgo is larger than the stored history.
|
|
* Be sure to set timing.size = sizeof(Compositor_FrameTiming) on struct passed in before calling this function. */
|
|
virtual bool GetFrameTiming( Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0 ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Interface for copying a range of timing data. Frames are returned in ascending order (oldest to newest) with the last being the most recent frame.
|
|
* Only the first entry's m_nSize needs to be set, as the rest will be inferred from that. Returns total number of entries filled out. */
|
|
virtual uint32_t GetFrameTimings( Compositor_FrameTiming *pTiming, uint32_t nFrames ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns the time in seconds left in the current (as identified by FrameTiming's frameIndex) frame.
|
|
* Due to "running start", this value may roll over to the next frame before ever reaching 0.0. */
|
|
virtual float GetFrameTimeRemaining() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Fills out stats accumulated for the last connected application. Pass in sizeof( Compositor_CumulativeStats ) as second parameter. */
|
|
virtual void GetCumulativeStats( Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Fades the view on the HMD to the specified color. The fade will take fSeconds, and the color values are between
|
|
* 0.0 and 1.0. This color is faded on top of the scene based on the alpha parameter. Removing the fade color instantly
|
|
* would be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ). Values are in un-premultiplied alpha space. */
|
|
virtual void FadeToColor( float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Get current fade color value. */
|
|
virtual HmdColor_t GetCurrentFadeColor( bool bBackground = false ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Fading the Grid in or out in fSeconds */
|
|
virtual void FadeGrid( float fSeconds, bool bFadeIn ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Get current alpha value of grid. */
|
|
virtual float GetCurrentGridAlpha() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Override the skybox used in the compositor (e.g. for during level loads when the app can't feed scene images fast enough)
|
|
* Order is Front, Back, Left, Right, Top, Bottom. If only a single texture is passed, it is assumed in lat-long format.
|
|
* If two are passed, it is assumed a lat-long stereo pair. */
|
|
virtual EVRCompositorError SetSkyboxOverride( VR_ARRAY_COUNT( unTextureCount ) const Texture_t *pTextures, uint32_t unTextureCount ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Resets compositor skybox back to defaults. */
|
|
virtual void ClearSkyboxOverride() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Brings the compositor window to the front. This is useful for covering any other window that may be on the HMD
|
|
* and is obscuring the compositor window. */
|
|
virtual void CompositorBringToFront() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Pushes the compositor window to the back. This is useful for allowing other applications to draw directly to the HMD. */
|
|
virtual void CompositorGoToBack() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Tells the compositor process to clean up and exit. You do not need to call this function at shutdown. Under normal
|
|
* circumstances the compositor will manage its own life cycle based on what applications are running. */
|
|
virtual void CompositorQuit() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Return whether the compositor is fullscreen */
|
|
virtual bool IsFullscreen() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns the process ID of the process that is currently rendering the scene */
|
|
virtual uint32_t GetCurrentSceneFocusProcess() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns the process ID of the process that rendered the last frame (or 0 if the compositor itself rendered the frame.)
|
|
* Returns 0 when fading out from an app and the app's process Id when fading into an app. */
|
|
virtual uint32_t GetLastFrameRenderer() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns true if the current process has the scene focus */
|
|
virtual bool CanRenderScene() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Creates a window on the primary monitor to display what is being shown in the headset. */
|
|
virtual void ShowMirrorWindow() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Closes the mirror window. */
|
|
virtual void HideMirrorWindow() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Returns true if the mirror window is shown. */
|
|
virtual bool IsMirrorWindowVisible() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Writes all images that the compositor knows about (including overlays) to a 'screenshots' folder in the SteamVR runtime root. */
|
|
virtual void CompositorDumpImages() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Let an app know it should be rendering with low resources. */
|
|
virtual bool ShouldAppRenderWithLowResources() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Override interleaved reprojection logic to force on. */
|
|
virtual void ForceInterleavedReprojectionOn( bool bOverride ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Force reconnecting to the compositor process. */
|
|
virtual void ForceReconnectProcess() { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Temporarily suspends rendering (useful for finer control over scene transitions). */
|
|
virtual void SuspendRendering( bool bSuspend ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Opens a shared D3D11 texture with the undistorted composited image for each eye. Use ReleaseMirrorTextureD3D11 when finished
|
|
* instead of calling Release on the resource itself. */
|
|
virtual vr::EVRCompositorError GetMirrorTextureD3D11( vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView ) { VRSTUB_NOT_IMPLEMENTED }
|
|
virtual void ReleaseMirrorTextureD3D11( void *pD3D11ShaderResourceView ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Access to mirror textures from OpenGL. */
|
|
virtual vr::EVRCompositorError GetMirrorTextureGL( vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle ) { VRSTUB_NOT_IMPLEMENTED }
|
|
virtual bool ReleaseSharedGLTexture( vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle ) { VRSTUB_NOT_IMPLEMENTED }
|
|
virtual void LockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) { VRSTUB_NOT_IMPLEMENTED }
|
|
virtual void UnlockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** [Vulkan Only]
|
|
* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
|
|
* null. The string will be a space separated list of-required instance extensions to enable in VkCreateInstance */
|
|
virtual uint32_t GetVulkanInstanceExtensionsRequired( VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** [Vulkan only]
|
|
* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
|
|
* null. The string will be a space separated list of required device extensions to enable in VkCreateDevice */
|
|
virtual uint32_t GetVulkanDeviceExtensionsRequired( VkPhysicalDevice_T *pPhysicalDevice, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** [ Vulkan/D3D12 Only ]
|
|
* There are two purposes for SetExplicitTimingMode:
|
|
* 1. To get a more accurate GPU timestamp for when the frame begins in Vulkan/D3D12 applications.
|
|
* 2. (Optional) To avoid having WaitGetPoses access the Vulkan queue so that the queue can be accessed from
|
|
* another thread while WaitGetPoses is executing.
|
|
*
|
|
* More accurate GPU timestamp for the start of the frame is achieved by the application calling
|
|
* SubmitExplicitTimingData immediately before its first submission to the Vulkan/D3D12 queue.
|
|
* This is more accurate because normally this GPU timestamp is recorded during WaitGetPoses. In D3D11,
|
|
* WaitGetPoses queues a GPU timestamp write, but it does not actually get submitted to the GPU until the
|
|
* application flushes. By using SubmitExplicitTimingData, the timestamp is recorded at the same place for
|
|
* Vulkan/D3D12 as it is for D3D11, resulting in a more accurate GPU time measurement for the frame.
|
|
*
|
|
* Avoiding WaitGetPoses accessing the Vulkan queue can be achieved using SetExplicitTimingMode as well. If this is desired,
|
|
* the application should set the timing mode to Explicit_ApplicationPerformsPostPresentHandoff and *MUST* call PostPresentHandoff
|
|
* itself. If these conditions are met, then WaitGetPoses is guaranteed not to access the queue. Note that PostPresentHandoff
|
|
* and SubmitExplicitTimingData will access the queue, so only WaitGetPoses becomes safe for accessing the queue from another
|
|
* thread. */
|
|
virtual void SetExplicitTimingMode( EVRCompositorTimingMode eTimingMode ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** [ Vulkan/D3D12 Only ]
|
|
* Submit explicit timing data. When SetExplicitTimingMode is true, this must be called immediately before
|
|
* the application's first vkQueueSubmit (Vulkan) or ID3D12CommandQueue::ExecuteCommandLists (D3D12) of each frame.
|
|
* This function will insert a GPU timestamp write just before the application starts its rendering. This function
|
|
* will perform a vkQueueSubmit on Vulkan so must not be done simultaneously with VkQueue operations on another thread.
|
|
* Returns VRCompositorError_RequestFailed if SetExplicitTimingMode is not enabled. */
|
|
virtual EVRCompositorError SubmitExplicitTimingData() { VRSTUB_NOT_IMPLEMENTED }
|
|
};
|
|
|
|
class VRInputStub: public IVRInput {
|
|
public:
|
|
|
|
// --------------- Handle management --------------- //
|
|
|
|
/** Sets the path to the action manifest JSON file that is used by this application. If this information
|
|
* was set on the Steam partner site, calls to this function are ignored. If the Steam partner site
|
|
* setting and the path provided by this call are different, VRInputError_MismatchedActionManifest is returned.
|
|
* This call must be made before the first call to UpdateActionState or IVRSystem::PollNextEvent. */
|
|
virtual EVRInputError SetActionManifestPath( const char *pchActionManifestPath ) { return VRInputError_None; }
|
|
|
|
/** Returns a handle for an action set. This handle is used for all performance-sensitive calls. */
|
|
virtual EVRInputError GetActionSetHandle( const char *pchActionSetName, VRActionSetHandle_t *pHandle ) { *pHandle = (VRActionSetHandle_t)0xFACEFACE; return VRInputError_None; }
|
|
|
|
/** Returns a handle for an action. This handle is used for all performance-sensitive calls. */
|
|
virtual EVRInputError GetActionHandle( const char *pchActionName, VRActionHandle_t *pHandle ) { *pHandle = (VRActionHandle_t)0xFACEFACE; return VRInputError_None; }
|
|
|
|
/** Returns a handle for any path in the input system. E.g. /user/hand/right */
|
|
virtual EVRInputError GetInputSourceHandle( const char *pchInputSourcePath, VRInputValueHandle_t *pHandle ) { *pHandle = (VRInputValueHandle_t)0xFACEFACE; return VRInputError_None; }
|
|
|
|
// --------------- Reading action state ------------------- //
|
|
|
|
/** Reads the current state into all actions. After this call, the results of Get*Action calls
|
|
* will be the same until the next call to UpdateActionState. */
|
|
virtual EVRInputError UpdateActionState( VR_ARRAY_COUNT( unSetCount ) VRActiveActionSet_t *pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount ) { return VRInputError_None; }
|
|
|
|
/** Reads the state of a digital action given its handle. This will return VRInputError_WrongType if the type of
|
|
* action is something other than digital */
|
|
virtual EVRInputError GetDigitalActionData( VRActionHandle_t action, InputDigitalActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice );
|
|
|
|
/** Reads the state of an analog action given its handle. This will return VRInputError_WrongType if the type of
|
|
* action is something other than analog */
|
|
virtual EVRInputError GetAnalogActionData( VRActionHandle_t action, InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice );
|
|
|
|
/** Reads the state of a pose action given its handle. */
|
|
virtual EVRInputError GetPoseActionData( VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice );
|
|
|
|
/** Reads the state of a skeletal action given its handle. */
|
|
virtual EVRInputError GetSkeletalActionData( VRActionHandle_t action, InputSkeletalActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
// --------------- Skeletal Bone Data ------------------- //
|
|
|
|
/** Reads the state of the skeletal bone data associated with this action and copies it into the given buffer. */
|
|
virtual EVRInputError GetSkeletalBoneData( VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VR_ARRAY_COUNT( unTransformArrayCount ) VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount, VRInputValueHandle_t ulRestrictToDevice ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Reads the state of the skeletal bone data in a compressed form that is suitable for
|
|
* sending over the network. The required buffer size will never exceed ( sizeof(VR_BoneTransform_t)*boneCount + 2).
|
|
* Usually the size will be much smaller. */
|
|
virtual EVRInputError GetSkeletalBoneDataCompressed( VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VR_OUT_BUFFER_COUNT( unCompressedSize ) void *pvCompressedData, uint32_t unCompressedSize, uint32_t *punRequiredCompressedSize, VRInputValueHandle_t ulRestrictToDevice ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Turns a compressed buffer from GetSkeletalBoneDataCompressed and turns it back into a bone transform array. */
|
|
virtual EVRInputError DecompressSkeletalBoneData( void *pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace *peTransformSpace, VR_ARRAY_COUNT( unTransformArrayCount ) VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
// --------------- Haptics ------------------- //
|
|
|
|
/** Triggers a haptic event as described by the specified action */
|
|
virtual EVRInputError TriggerHapticVibrationAction( VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
// --------------- Action Origins ---------------- //
|
|
|
|
/** Retrieve origin handles for an action */
|
|
virtual EVRInputError GetActionOrigins( VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VR_ARRAY_COUNT( originOutCount ) VRInputValueHandle_t *originsOut, uint32_t originOutCount ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Retrieves the name of the origin in the current language */
|
|
virtual EVRInputError GetOriginLocalizedName( VRInputValueHandle_t origin, VR_OUT_STRING() char *pchNameArray, uint32_t unNameArraySize ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Retrieves useful information for the origin of this action */
|
|
virtual EVRInputError GetOriginTrackedDeviceInfo( VRInputValueHandle_t origin, InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Shows the current binding for the action in-headset */
|
|
virtual EVRInputError ShowActionOrigins( VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle ) { VRSTUB_NOT_IMPLEMENTED }
|
|
|
|
/** Shows the current binding all the actions in the specified action sets */
|
|
virtual EVRInputError ShowBindingsForActionSet( VR_ARRAY_COUNT( unSetCount ) VRActiveActionSet_t *pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight ) { VRSTUB_NOT_IMPLEMENTED }
|
|
};
|
|
|
|
|
|
} // stub
|
|
} // vr
|
|
|
|
#endif /* _H_OpenVRStub */
|