| Index: third_party/openvr/src/headers/openvr_driver.h
|
| diff --git a/third_party/openvr/src/headers/openvr_driver.h b/third_party/openvr/src/headers/openvr_driver.h
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..bbdbd7486d470ee9c45be69e4e0c8342d83f57fc
|
| --- /dev/null
|
| +++ b/third_party/openvr/src/headers/openvr_driver.h
|
| @@ -0,0 +1,2541 @@
|
| +#pragma once
|
| +
|
| +// openvr_driver.h
|
| +//========= Copyright Valve Corporation ============//
|
| +// Dynamically generated file. Do not modify this file directly.
|
| +
|
| +#ifndef _OPENVR_DRIVER_API
|
| +#define _OPENVR_DRIVER_API
|
| +
|
| +#include <stdint.h>
|
| +
|
| +
|
| +
|
| +// vrtypes.h
|
| +#ifndef _INCLUDE_VRTYPES_H
|
| +#define _INCLUDE_VRTYPES_H
|
| +
|
| +// Forward declarations to avoid requiring vulkan.h
|
| +struct VkDevice_T;
|
| +struct VkPhysicalDevice_T;
|
| +struct VkInstance_T;
|
| +struct VkQueue_T;
|
| +
|
| +// Forward declarations to avoid requiring d3d12.h
|
| +struct ID3D12Resource;
|
| +struct ID3D12CommandQueue;
|
| +
|
| +namespace vr
|
| +{
|
| +
|
| +#if defined(__linux__) || defined(__APPLE__)
|
| + // The 32-bit version of gcc has the alignment requirement for uint64 and double set to
|
| + // 4 meaning that even with #pragma pack(8) these types will only be four-byte aligned.
|
| + // The 64-bit version of gcc has the alignment requirement for these types set to
|
| + // 8 meaning that unless we use #pragma pack(4) our structures will get bigger.
|
| + // The 64-bit structure packing has to match the 32-bit structure packing for each platform.
|
| + #pragma pack( push, 4 )
|
| +#else
|
| + #pragma pack( push, 8 )
|
| +#endif
|
| +
|
| +typedef void* glSharedTextureHandle_t;
|
| +typedef int32_t glInt_t;
|
| +typedef uint32_t glUInt_t;
|
| +
|
| +// right-handed system
|
| +// +y is up
|
| +// +x is to the right
|
| +// -z is going away from you
|
| +// Distance unit is meters
|
| +struct HmdMatrix34_t
|
| +{
|
| + float m[3][4];
|
| +};
|
| +
|
| +struct HmdMatrix44_t
|
| +{
|
| + float m[4][4];
|
| +};
|
| +
|
| +struct HmdVector3_t
|
| +{
|
| + float v[3];
|
| +};
|
| +
|
| +struct HmdVector4_t
|
| +{
|
| + float v[4];
|
| +};
|
| +
|
| +struct HmdVector3d_t
|
| +{
|
| + double v[3];
|
| +};
|
| +
|
| +struct HmdVector2_t
|
| +{
|
| + float v[2];
|
| +};
|
| +
|
| +struct HmdQuaternion_t
|
| +{
|
| + double w, x, y, z;
|
| +};
|
| +
|
| +struct HmdColor_t
|
| +{
|
| + float r, g, b, a;
|
| +};
|
| +
|
| +struct HmdQuad_t
|
| +{
|
| + HmdVector3_t vCorners[ 4 ];
|
| +};
|
| +
|
| +struct HmdRect2_t
|
| +{
|
| + HmdVector2_t vTopLeft;
|
| + HmdVector2_t vBottomRight;
|
| +};
|
| +
|
| +/** Used to return the post-distortion UVs for each color channel.
|
| +* UVs range from 0 to 1 with 0,0 in the upper left corner of the
|
| +* source render target. The 0,0 to 1,1 range covers a single eye. */
|
| +struct DistortionCoordinates_t
|
| +{
|
| + float rfRed[2];
|
| + float rfGreen[2];
|
| + float rfBlue[2];
|
| +};
|
| +
|
| +enum EVREye
|
| +{
|
| + Eye_Left = 0,
|
| + Eye_Right = 1
|
| +};
|
| +
|
| +enum ETextureType
|
| +{
|
| + TextureType_DirectX = 0, // Handle is an ID3D11Texture
|
| + TextureType_OpenGL = 1, // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
|
| + TextureType_Vulkan = 2, // Handle is a pointer to a VRVulkanTextureData_t structure
|
| + TextureType_IOSurface = 3, // Handle is a macOS cross-process-sharable IOSurface
|
| + TextureType_DirectX12 = 4, // Handle is a pointer to a D3D12TextureData_t structure
|
| +};
|
| +
|
| +enum EColorSpace
|
| +{
|
| + ColorSpace_Auto = 0, // Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'. This mirrors the DXGI formats which have _SRGB variants.
|
| + ColorSpace_Gamma = 1, // Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
|
| + ColorSpace_Linear = 2, // Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
|
| +};
|
| +
|
| +struct Texture_t
|
| +{
|
| + void* handle; // See ETextureType definition above
|
| + ETextureType eType;
|
| + EColorSpace eColorSpace;
|
| +};
|
| +
|
| +// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
|
| +typedef uint64_t SharedTextureHandle_t;
|
| +#define INVALID_SHARED_TEXTURE_HANDLE ((vr::SharedTextureHandle_t)0)
|
| +
|
| +enum ETrackingResult
|
| +{
|
| + TrackingResult_Uninitialized = 1,
|
| +
|
| + TrackingResult_Calibrating_InProgress = 100,
|
| + TrackingResult_Calibrating_OutOfRange = 101,
|
| +
|
| + TrackingResult_Running_OK = 200,
|
| + TrackingResult_Running_OutOfRange = 201,
|
| +};
|
| +
|
| +static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
|
| +
|
| +/** Used to pass device IDs to API calls */
|
| +typedef uint32_t TrackedDeviceIndex_t;
|
| +static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
|
| +static const uint32_t k_unMaxTrackedDeviceCount = 16;
|
| +static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
|
| +static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
|
| +
|
| +/** Describes what kind of object is being tracked at a given ID */
|
| +enum ETrackedDeviceClass
|
| +{
|
| + TrackedDeviceClass_Invalid = 0, // the ID was not valid.
|
| + TrackedDeviceClass_HMD = 1, // Head-Mounted Displays
|
| + TrackedDeviceClass_Controller = 2, // Tracked controllers
|
| + TrackedDeviceClass_GenericTracker = 3, // Generic trackers, similar to controllers
|
| + TrackedDeviceClass_TrackingReference = 4, // Camera and base stations that serve as tracking reference points
|
| +};
|
| +
|
| +
|
| +/** Describes what specific role associated with a tracked device */
|
| +enum ETrackedControllerRole
|
| +{
|
| + TrackedControllerRole_Invalid = 0, // Invalid value for controller type
|
| + TrackedControllerRole_LeftHand = 1, // Tracked device associated with the left hand
|
| + TrackedControllerRole_RightHand = 2, // Tracked device associated with the right hand
|
| +};
|
| +
|
| +
|
| +/** describes a single pose for a tracked object */
|
| +struct TrackedDevicePose_t
|
| +{
|
| + HmdMatrix34_t mDeviceToAbsoluteTracking;
|
| + HmdVector3_t vVelocity; // velocity in tracker space in m/s
|
| + HmdVector3_t vAngularVelocity; // angular velocity in radians/s (?)
|
| + ETrackingResult eTrackingResult;
|
| + bool bPoseIsValid;
|
| +
|
| + // This indicates that there is a device connected for this spot in the pose array.
|
| + // It could go from true to false if the user unplugs the device.
|
| + bool bDeviceIsConnected;
|
| +};
|
| +
|
| +/** Identifies which style of tracking origin the application wants to use
|
| +* for the poses it is requesting */
|
| +enum ETrackingUniverseOrigin
|
| +{
|
| + TrackingUniverseSeated = 0, // Poses are provided relative to the seated zero pose
|
| + TrackingUniverseStanding = 1, // Poses are provided relative to the safe bounds configured by the user
|
| + TrackingUniverseRawAndUncalibrated = 2, // Poses are provided in the coordinate system defined by the driver. It has Y up and is unified for devices of the same driver. You usually don't want this one.
|
| +};
|
| +
|
| +// Refers to a single container of properties
|
| +typedef uint64_t PropertyContainerHandle_t;
|
| +typedef uint32_t PropertyTypeTag_t;
|
| +
|
| +static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
|
| +static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
|
| +
|
| +// Use these tags to set/get common types as struct properties
|
| +static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
|
| +static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
|
| +static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
|
| +static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
|
| +static const PropertyTypeTag_t k_unStringPropertyTag = 5;
|
| +
|
| +static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
|
| +static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
|
| +static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
|
| +static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
|
| +
|
| +static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
|
| +
|
| +static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
|
| +static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
|
| +
|
| +
|
| +/** Each entry in this enum represents a property that can be retrieved about a
|
| +* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
|
| +enum ETrackedDeviceProperty
|
| +{
|
| + Prop_Invalid = 0,
|
| +
|
| + // general properties that apply to all device classes
|
| + Prop_TrackingSystemName_String = 1000,
|
| + Prop_ModelNumber_String = 1001,
|
| + Prop_SerialNumber_String = 1002,
|
| + Prop_RenderModelName_String = 1003,
|
| + Prop_WillDriftInYaw_Bool = 1004,
|
| + Prop_ManufacturerName_String = 1005,
|
| + Prop_TrackingFirmwareVersion_String = 1006,
|
| + Prop_HardwareRevision_String = 1007,
|
| + Prop_AllWirelessDongleDescriptions_String = 1008,
|
| + Prop_ConnectedWirelessDongle_String = 1009,
|
| + Prop_DeviceIsWireless_Bool = 1010,
|
| + Prop_DeviceIsCharging_Bool = 1011,
|
| + Prop_DeviceBatteryPercentage_Float = 1012, // 0 is empty, 1 is full
|
| + Prop_StatusDisplayTransform_Matrix34 = 1013,
|
| + Prop_Firmware_UpdateAvailable_Bool = 1014,
|
| + Prop_Firmware_ManualUpdate_Bool = 1015,
|
| + Prop_Firmware_ManualUpdateURL_String = 1016,
|
| + Prop_HardwareRevision_Uint64 = 1017,
|
| + Prop_FirmwareVersion_Uint64 = 1018,
|
| + Prop_FPGAVersion_Uint64 = 1019,
|
| + Prop_VRCVersion_Uint64 = 1020,
|
| + Prop_RadioVersion_Uint64 = 1021,
|
| + Prop_DongleVersion_Uint64 = 1022,
|
| + Prop_BlockServerShutdown_Bool = 1023,
|
| + Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
|
| + Prop_ContainsProximitySensor_Bool = 1025,
|
| + Prop_DeviceProvidesBatteryStatus_Bool = 1026,
|
| + Prop_DeviceCanPowerOff_Bool = 1027,
|
| + Prop_Firmware_ProgrammingTarget_String = 1028,
|
| + Prop_DeviceClass_Int32 = 1029,
|
| + Prop_HasCamera_Bool = 1030,
|
| + Prop_DriverVersion_String = 1031,
|
| + Prop_Firmware_ForceUpdateRequired_Bool = 1032,
|
| + Prop_ViveSystemButtonFixRequired_Bool = 1033,
|
| + Prop_ParentDriver_Uint64 = 1034,
|
| +
|
| +
|
| + // Properties that are unique to TrackedDeviceClass_HMD
|
| + Prop_ReportsTimeSinceVSync_Bool = 2000,
|
| + Prop_SecondsFromVsyncToPhotons_Float = 2001,
|
| + Prop_DisplayFrequency_Float = 2002,
|
| + Prop_UserIpdMeters_Float = 2003,
|
| + Prop_CurrentUniverseId_Uint64 = 2004,
|
| + Prop_PreviousUniverseId_Uint64 = 2005,
|
| + Prop_DisplayFirmwareVersion_Uint64 = 2006,
|
| + Prop_IsOnDesktop_Bool = 2007,
|
| + Prop_DisplayMCType_Int32 = 2008,
|
| + Prop_DisplayMCOffset_Float = 2009,
|
| + Prop_DisplayMCScale_Float = 2010,
|
| + Prop_EdidVendorID_Int32 = 2011,
|
| + Prop_DisplayMCImageLeft_String = 2012,
|
| + Prop_DisplayMCImageRight_String = 2013,
|
| + Prop_DisplayGCBlackClamp_Float = 2014,
|
| + Prop_EdidProductID_Int32 = 2015,
|
| + Prop_CameraToHeadTransform_Matrix34 = 2016,
|
| + Prop_DisplayGCType_Int32 = 2017,
|
| + Prop_DisplayGCOffset_Float = 2018,
|
| + Prop_DisplayGCScale_Float = 2019,
|
| + Prop_DisplayGCPrescale_Float = 2020,
|
| + Prop_DisplayGCImage_String = 2021,
|
| + Prop_LensCenterLeftU_Float = 2022,
|
| + Prop_LensCenterLeftV_Float = 2023,
|
| + Prop_LensCenterRightU_Float = 2024,
|
| + Prop_LensCenterRightV_Float = 2025,
|
| + Prop_UserHeadToEyeDepthMeters_Float = 2026,
|
| + Prop_CameraFirmwareVersion_Uint64 = 2027,
|
| + Prop_CameraFirmwareDescription_String = 2028,
|
| + Prop_DisplayFPGAVersion_Uint64 = 2029,
|
| + Prop_DisplayBootloaderVersion_Uint64 = 2030,
|
| + Prop_DisplayHardwareVersion_Uint64 = 2031,
|
| + Prop_AudioFirmwareVersion_Uint64 = 2032,
|
| + Prop_CameraCompatibilityMode_Int32 = 2033,
|
| + Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
|
| + Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
|
| + Prop_DisplaySuppressed_Bool = 2036,
|
| + Prop_DisplayAllowNightMode_Bool = 2037,
|
| + Prop_DisplayMCImageWidth_Int32 = 2038,
|
| + Prop_DisplayMCImageHeight_Int32 = 2039,
|
| + Prop_DisplayMCImageNumChannels_Int32 = 2040,
|
| + Prop_DisplayMCImageData_Binary = 2041,
|
| + Prop_UsesDriverDirectMode_Bool = 2042,
|
| +
|
| + // Properties that are unique to TrackedDeviceClass_Controller
|
| + Prop_AttachedDeviceId_String = 3000,
|
| + Prop_SupportedButtons_Uint64 = 3001,
|
| + Prop_Axis0Type_Int32 = 3002, // Return value is of type EVRControllerAxisType
|
| + Prop_Axis1Type_Int32 = 3003, // Return value is of type EVRControllerAxisType
|
| + Prop_Axis2Type_Int32 = 3004, // Return value is of type EVRControllerAxisType
|
| + Prop_Axis3Type_Int32 = 3005, // Return value is of type EVRControllerAxisType
|
| + Prop_Axis4Type_Int32 = 3006, // Return value is of type EVRControllerAxisType
|
| + Prop_ControllerRoleHint_Int32 = 3007, // Return value is of type ETrackedControllerRole
|
| +
|
| + // Properties that are unique to TrackedDeviceClass_TrackingReference
|
| + Prop_FieldOfViewLeftDegrees_Float = 4000,
|
| + Prop_FieldOfViewRightDegrees_Float = 4001,
|
| + Prop_FieldOfViewTopDegrees_Float = 4002,
|
| + Prop_FieldOfViewBottomDegrees_Float = 4003,
|
| + Prop_TrackingRangeMinimumMeters_Float = 4004,
|
| + Prop_TrackingRangeMaximumMeters_Float = 4005,
|
| + Prop_ModeLabel_String = 4006,
|
| +
|
| + // Properties that are used for user interface like icons names
|
| + Prop_IconPathName_String = 5000, // usually a directory named "icons"
|
| + Prop_NamedIconPathDeviceOff_String = 5001, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
|
| + Prop_NamedIconPathDeviceSearching_String = 5002, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
|
| + Prop_NamedIconPathDeviceSearchingAlert_String = 5003, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
|
| + Prop_NamedIconPathDeviceReady_String = 5004, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
|
| + Prop_NamedIconPathDeviceReadyAlert_String = 5005, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
|
| + Prop_NamedIconPathDeviceNotReady_String = 5006, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
|
| + Prop_NamedIconPathDeviceStandby_String = 5007, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
|
| + Prop_NamedIconPathDeviceAlertLow_String = 5008, // PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
|
| +
|
| + // Properties that are used by helpers, but are opaque to applications
|
| + Prop_DisplayHiddenArea_Binary_Start = 5100,
|
| + Prop_DisplayHiddenArea_Binary_End = 5150,
|
| +
|
| + // Properties that are unique to drivers
|
| + Prop_UserConfigPath_String = 6000,
|
| + Prop_InstallPath_String = 6001,
|
| +
|
| + // Vendors are free to expose private debug data in this reserved region
|
| + Prop_VendorSpecific_Reserved_Start = 10000,
|
| + Prop_VendorSpecific_Reserved_End = 10999,
|
| +};
|
| +
|
| +/** No string property will ever be longer than this length */
|
| +static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
|
| +
|
| +/** Used to return errors that occur when reading properties. */
|
| +enum ETrackedPropertyError
|
| +{
|
| + TrackedProp_Success = 0,
|
| + TrackedProp_WrongDataType = 1,
|
| + TrackedProp_WrongDeviceClass = 2,
|
| + TrackedProp_BufferTooSmall = 3,
|
| + TrackedProp_UnknownProperty = 4, // Driver has not set the property (and may not ever).
|
| + TrackedProp_InvalidDevice = 5,
|
| + TrackedProp_CouldNotContactServer = 6,
|
| + TrackedProp_ValueNotProvidedByDevice = 7,
|
| + TrackedProp_StringExceedsMaximumLength = 8,
|
| + TrackedProp_NotYetAvailable = 9, // The property value isn't known yet, but is expected soon. Call again later.
|
| + TrackedProp_PermissionDenied = 10,
|
| + TrackedProp_InvalidOperation = 11,
|
| +};
|
| +
|
| +/** Allows the application to control what part of the provided texture will be used in the
|
| +* frame buffer. */
|
| +struct VRTextureBounds_t
|
| +{
|
| + float uMin, vMin;
|
| + float uMax, vMax;
|
| +};
|
| +
|
| +
|
| +/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
|
| +enum EVRSubmitFlags
|
| +{
|
| + // Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
|
| + Submit_Default = 0x00,
|
| +
|
| + // App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
|
| + // barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
|
| + // vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
|
| + Submit_LensDistortionAlreadyApplied = 0x01,
|
| +
|
| + // If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
|
| + Submit_GlRenderBuffer = 0x02,
|
| +
|
| + // Do not use
|
| + Submit_Reserved = 0x04,
|
| +};
|
| +
|
| +/** Data required for passing Vulkan textures to IVRCompositor::Submit.
|
| +* Be sure to call OpenVR_Shutdown before destroying these resources. */
|
| +struct VRVulkanTextureData_t
|
| +{
|
| + uint64_t m_nImage; // VkImage
|
| + VkDevice_T *m_pDevice;
|
| + VkPhysicalDevice_T *m_pPhysicalDevice;
|
| + VkInstance_T *m_pInstance;
|
| + VkQueue_T *m_pQueue;
|
| + uint32_t m_nQueueFamilyIndex;
|
| + uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
|
| +};
|
| +
|
| +/** Data required for passing D3D12 textures to IVRCompositor::Submit.
|
| +* Be sure to call OpenVR_Shutdown before destroying these resources. */
|
| +struct D3D12TextureData_t
|
| +{
|
| + ID3D12Resource *m_pResource;
|
| + ID3D12CommandQueue *m_pCommandQueue;
|
| + uint32_t m_nNodeMask;
|
| +};
|
| +
|
| +/** Status of the overall system or tracked objects */
|
| +enum EVRState
|
| +{
|
| + VRState_Undefined = -1,
|
| + VRState_Off = 0,
|
| + VRState_Searching = 1,
|
| + VRState_Searching_Alert = 2,
|
| + VRState_Ready = 3,
|
| + VRState_Ready_Alert = 4,
|
| + VRState_NotReady = 5,
|
| + VRState_Standby = 6,
|
| + VRState_Ready_Alert_Low = 7,
|
| +};
|
| +
|
| +/** The types of events that could be posted (and what the parameters mean for each event type) */
|
| +enum EVREventType
|
| +{
|
| + VREvent_None = 0,
|
| +
|
| + VREvent_TrackedDeviceActivated = 100,
|
| + VREvent_TrackedDeviceDeactivated = 101,
|
| + VREvent_TrackedDeviceUpdated = 102,
|
| + VREvent_TrackedDeviceUserInteractionStarted = 103,
|
| + VREvent_TrackedDeviceUserInteractionEnded = 104,
|
| + VREvent_IpdChanged = 105,
|
| + VREvent_EnterStandbyMode = 106,
|
| + VREvent_LeaveStandbyMode = 107,
|
| + VREvent_TrackedDeviceRoleChanged = 108,
|
| + VREvent_WatchdogWakeUpRequested = 109,
|
| + VREvent_LensDistortionChanged = 110,
|
| + VREvent_PropertyChanged = 111,
|
| +
|
| + VREvent_ButtonPress = 200, // data is controller
|
| + VREvent_ButtonUnpress = 201, // data is controller
|
| + VREvent_ButtonTouch = 202, // data is controller
|
| + VREvent_ButtonUntouch = 203, // data is controller
|
| +
|
| + VREvent_MouseMove = 300, // data is mouse
|
| + VREvent_MouseButtonDown = 301, // data is mouse
|
| + VREvent_MouseButtonUp = 302, // data is mouse
|
| + VREvent_FocusEnter = 303, // data is overlay
|
| + VREvent_FocusLeave = 304, // data is overlay
|
| + VREvent_Scroll = 305, // data is mouse
|
| + VREvent_TouchPadMove = 306, // data is mouse
|
| + VREvent_OverlayFocusChanged = 307, // data is overlay, global event
|
| +
|
| + VREvent_InputFocusCaptured = 400, // data is process DEPRECATED
|
| + VREvent_InputFocusReleased = 401, // data is process DEPRECATED
|
| + VREvent_SceneFocusLost = 402, // data is process
|
| + VREvent_SceneFocusGained = 403, // data is process
|
| + VREvent_SceneApplicationChanged = 404, // data is process - The App actually drawing the scene changed (usually to or from the compositor)
|
| + VREvent_SceneFocusChanged = 405, // data is process - New app got access to draw the scene
|
| + VREvent_InputFocusChanged = 406, // data is process
|
| + VREvent_SceneApplicationSecondaryRenderingStarted = 407, // data is process
|
| +
|
| + VREvent_HideRenderModels = 410, // Sent to the scene application to request hiding render models temporarily
|
| + VREvent_ShowRenderModels = 411, // Sent to the scene application to request restoring render model visibility
|
| +
|
| + VREvent_OverlayShown = 500,
|
| + VREvent_OverlayHidden = 501,
|
| + VREvent_DashboardActivated = 502,
|
| + VREvent_DashboardDeactivated = 503,
|
| + VREvent_DashboardThumbSelected = 504, // Sent to the overlay manager - data is overlay
|
| + VREvent_DashboardRequested = 505, // Sent to the overlay manager - data is overlay
|
| + VREvent_ResetDashboard = 506, // Send to the overlay manager
|
| + VREvent_RenderToast = 507, // Send to the dashboard to render a toast - data is the notification ID
|
| + VREvent_ImageLoaded = 508, // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
|
| + VREvent_ShowKeyboard = 509, // Sent to keyboard renderer in the dashboard to invoke it
|
| + VREvent_HideKeyboard = 510, // Sent to keyboard renderer in the dashboard to hide it
|
| + VREvent_OverlayGamepadFocusGained = 511, // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
|
| + VREvent_OverlayGamepadFocusLost = 512, // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
|
| + VREvent_OverlaySharedTextureChanged = 513,
|
| + VREvent_DashboardGuideButtonDown = 514,
|
| + VREvent_DashboardGuideButtonUp = 515,
|
| + VREvent_ScreenshotTriggered = 516, // Screenshot button combo was pressed, Dashboard should request a screenshot
|
| + VREvent_ImageFailed = 517, // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
|
| + VREvent_DashboardOverlayCreated = 518,
|
| +
|
| + // Screenshot API
|
| + VREvent_RequestScreenshot = 520, // Sent by vrclient application to compositor to take a screenshot
|
| + VREvent_ScreenshotTaken = 521, // Sent by compositor to the application that the screenshot has been taken
|
| + VREvent_ScreenshotFailed = 522, // Sent by compositor to the application that the screenshot failed to be taken
|
| + VREvent_SubmitScreenshotToDashboard = 523, // Sent by compositor to the dashboard that a completed screenshot was submitted
|
| + VREvent_ScreenshotProgressToDashboard = 524, // Sent by compositor to the dashboard that a completed screenshot was submitted
|
| +
|
| + VREvent_PrimaryDashboardDeviceChanged = 525,
|
| +
|
| + VREvent_Notification_Shown = 600,
|
| + VREvent_Notification_Hidden = 601,
|
| + VREvent_Notification_BeginInteraction = 602,
|
| + VREvent_Notification_Destroyed = 603,
|
| +
|
| + VREvent_Quit = 700, // data is process
|
| + VREvent_ProcessQuit = 701, // data is process
|
| + VREvent_QuitAborted_UserPrompt = 702, // data is process
|
| + VREvent_QuitAcknowledged = 703, // data is process
|
| + VREvent_DriverRequestedQuit = 704, // The driver has requested that SteamVR shut down
|
| +
|
| + VREvent_ChaperoneDataHasChanged = 800,
|
| + VREvent_ChaperoneUniverseHasChanged = 801,
|
| + VREvent_ChaperoneTempDataHasChanged = 802,
|
| + VREvent_ChaperoneSettingsHaveChanged = 803,
|
| + VREvent_SeatedZeroPoseReset = 804,
|
| +
|
| + VREvent_AudioSettingsHaveChanged = 820,
|
| +
|
| + VREvent_BackgroundSettingHasChanged = 850,
|
| + VREvent_CameraSettingsHaveChanged = 851,
|
| + VREvent_ReprojectionSettingHasChanged = 852,
|
| + VREvent_ModelSkinSettingsHaveChanged = 853,
|
| + VREvent_EnvironmentSettingsHaveChanged = 854,
|
| + VREvent_PowerSettingsHaveChanged = 855,
|
| +
|
| + VREvent_StatusUpdate = 900,
|
| +
|
| + VREvent_MCImageUpdated = 1000,
|
| +
|
| + VREvent_FirmwareUpdateStarted = 1100,
|
| + VREvent_FirmwareUpdateFinished = 1101,
|
| +
|
| + VREvent_KeyboardClosed = 1200,
|
| + VREvent_KeyboardCharInput = 1201,
|
| + VREvent_KeyboardDone = 1202, // Sent when DONE button clicked on keyboard
|
| +
|
| + VREvent_ApplicationTransitionStarted = 1300,
|
| + VREvent_ApplicationTransitionAborted = 1301,
|
| + VREvent_ApplicationTransitionNewAppStarted = 1302,
|
| + VREvent_ApplicationListUpdated = 1303,
|
| + VREvent_ApplicationMimeTypeLoad = 1304,
|
| + VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
|
| +
|
| + VREvent_Compositor_MirrorWindowShown = 1400,
|
| + VREvent_Compositor_MirrorWindowHidden = 1401,
|
| + VREvent_Compositor_ChaperoneBoundsShown = 1410,
|
| + VREvent_Compositor_ChaperoneBoundsHidden = 1411,
|
| +
|
| + VREvent_TrackedCamera_StartVideoStream = 1500,
|
| + VREvent_TrackedCamera_StopVideoStream = 1501,
|
| + VREvent_TrackedCamera_PauseVideoStream = 1502,
|
| + VREvent_TrackedCamera_ResumeVideoStream = 1503,
|
| + VREvent_TrackedCamera_EditingSurface = 1550,
|
| +
|
| + VREvent_PerformanceTest_EnableCapture = 1600,
|
| + VREvent_PerformanceTest_DisableCapture = 1601,
|
| + VREvent_PerformanceTest_FidelityLevel = 1602,
|
| +
|
| + VREvent_MessageOverlay_Closed = 1650,
|
| +
|
| + // Vendors are free to expose private events in this reserved region
|
| + VREvent_VendorSpecific_Reserved_Start = 10000,
|
| + VREvent_VendorSpecific_Reserved_End = 19999,
|
| +};
|
| +
|
| +
|
| +/** Level of Hmd activity */
|
| +enum EDeviceActivityLevel
|
| +{
|
| + k_EDeviceActivityLevel_Unknown = -1,
|
| + k_EDeviceActivityLevel_Idle = 0,
|
| + k_EDeviceActivityLevel_UserInteraction = 1,
|
| + k_EDeviceActivityLevel_UserInteraction_Timeout = 2,
|
| + k_EDeviceActivityLevel_Standby = 3,
|
| +};
|
| +
|
| +
|
| +/** VR controller button and axis IDs */
|
| +enum EVRButtonId
|
| +{
|
| + k_EButton_System = 0,
|
| + k_EButton_ApplicationMenu = 1,
|
| + k_EButton_Grip = 2,
|
| + k_EButton_DPad_Left = 3,
|
| + k_EButton_DPad_Up = 4,
|
| + k_EButton_DPad_Right = 5,
|
| + k_EButton_DPad_Down = 6,
|
| + k_EButton_A = 7,
|
| +
|
| + k_EButton_ProximitySensor = 31,
|
| +
|
| + k_EButton_Axis0 = 32,
|
| + k_EButton_Axis1 = 33,
|
| + k_EButton_Axis2 = 34,
|
| + k_EButton_Axis3 = 35,
|
| + k_EButton_Axis4 = 36,
|
| +
|
| + // aliases for well known controllers
|
| + k_EButton_SteamVR_Touchpad = k_EButton_Axis0,
|
| + k_EButton_SteamVR_Trigger = k_EButton_Axis1,
|
| +
|
| + k_EButton_Dashboard_Back = k_EButton_Grip,
|
| +
|
| + k_EButton_Max = 64
|
| +};
|
| +
|
| +inline uint64_t ButtonMaskFromId( EVRButtonId id ) { return 1ull << id; }
|
| +
|
| +/** used for controller button events */
|
| +struct VREvent_Controller_t
|
| +{
|
| + uint32_t button; // EVRButtonId enum
|
| +};
|
| +
|
| +
|
| +/** used for simulated mouse events in overlay space */
|
| +enum EVRMouseButton
|
| +{
|
| + VRMouseButton_Left = 0x0001,
|
| + VRMouseButton_Right = 0x0002,
|
| + VRMouseButton_Middle = 0x0004,
|
| +};
|
| +
|
| +
|
| +/** used for simulated mouse events in overlay space */
|
| +struct VREvent_Mouse_t
|
| +{
|
| + float x, y; // co-ords are in GL space, bottom left of the texture is 0,0
|
| + uint32_t button; // EVRMouseButton enum
|
| +};
|
| +
|
| +/** used for simulated mouse wheel scroll in overlay space */
|
| +struct VREvent_Scroll_t
|
| +{
|
| + float xdelta, ydelta; // movement in fraction of the pad traversed since last delta, 1.0 for a full swipe
|
| + uint32_t repeatCount;
|
| +};
|
| +
|
| +/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
|
| + is on the touchpad (or just released from it)
|
| +**/
|
| +struct VREvent_TouchPadMove_t
|
| +{
|
| + // true if the users finger is detected on the touch pad
|
| + bool bFingerDown;
|
| +
|
| + // How long the finger has been down in seconds
|
| + float flSecondsFingerDown;
|
| +
|
| + // These values indicate the starting finger position (so you can do some basic swipe stuff)
|
| + float fValueXFirst;
|
| + float fValueYFirst;
|
| +
|
| + // This is the raw sampled coordinate without deadzoning
|
| + float fValueXRaw;
|
| + float fValueYRaw;
|
| +};
|
| +
|
| +/** notification related events. Details will still change at this point */
|
| +struct VREvent_Notification_t
|
| +{
|
| + uint64_t ulUserValue;
|
| + uint32_t notificationId;
|
| +};
|
| +
|
| +/** Used for events about processes */
|
| +struct VREvent_Process_t
|
| +{
|
| + uint32_t pid;
|
| + uint32_t oldPid;
|
| + bool bForced;
|
| +};
|
| +
|
| +
|
| +/** Used for a few events about overlays */
|
| +struct VREvent_Overlay_t
|
| +{
|
| + uint64_t overlayHandle;
|
| +};
|
| +
|
| +
|
| +/** Used for a few events about overlays */
|
| +struct VREvent_Status_t
|
| +{
|
| + uint32_t statusState; // EVRState enum
|
| +};
|
| +
|
| +/** Used for keyboard events **/
|
| +struct VREvent_Keyboard_t
|
| +{
|
| + char cNewInput[8]; // Up to 11 bytes of new input
|
| + uint64_t uUserValue; // Possible flags about the new input
|
| +};
|
| +
|
| +struct VREvent_Ipd_t
|
| +{
|
| + float ipdMeters;
|
| +};
|
| +
|
| +struct VREvent_Chaperone_t
|
| +{
|
| + uint64_t m_nPreviousUniverse;
|
| + uint64_t m_nCurrentUniverse;
|
| +};
|
| +
|
| +/** Not actually used for any events */
|
| +struct VREvent_Reserved_t
|
| +{
|
| + uint64_t reserved0;
|
| + uint64_t reserved1;
|
| +};
|
| +
|
| +struct VREvent_PerformanceTest_t
|
| +{
|
| + uint32_t m_nFidelityLevel;
|
| +};
|
| +
|
| +struct VREvent_SeatedZeroPoseReset_t
|
| +{
|
| + bool bResetBySystemMenu;
|
| +};
|
| +
|
| +struct VREvent_Screenshot_t
|
| +{
|
| + uint32_t handle;
|
| + uint32_t type;
|
| +};
|
| +
|
| +struct VREvent_ScreenshotProgress_t
|
| +{
|
| + float progress;
|
| +};
|
| +
|
| +struct VREvent_ApplicationLaunch_t
|
| +{
|
| + uint32_t pid;
|
| + uint32_t unArgsHandle;
|
| +};
|
| +
|
| +struct VREvent_EditingCameraSurface_t
|
| +{
|
| + uint64_t overlayHandle;
|
| + uint32_t nVisualMode;
|
| +};
|
| +
|
| +struct VREvent_MessageOverlay_t
|
| +{
|
| + uint32_t unVRMessageOverlayResponse; // vr::VRMessageOverlayResponse enum
|
| +};
|
| +
|
| +struct VREvent_Property_t
|
| +{
|
| + PropertyContainerHandle_t container;
|
| + ETrackedDeviceProperty prop;
|
| +};
|
| +
|
| +/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
|
| +typedef union
|
| +{
|
| + VREvent_Reserved_t reserved;
|
| + VREvent_Controller_t controller;
|
| + VREvent_Mouse_t mouse;
|
| + VREvent_Scroll_t scroll;
|
| + VREvent_Process_t process;
|
| + VREvent_Notification_t notification;
|
| + VREvent_Overlay_t overlay;
|
| + VREvent_Status_t status;
|
| + VREvent_Keyboard_t keyboard;
|
| + VREvent_Ipd_t ipd;
|
| + VREvent_Chaperone_t chaperone;
|
| + VREvent_PerformanceTest_t performanceTest;
|
| + VREvent_TouchPadMove_t touchPadMove;
|
| + VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
|
| + VREvent_Screenshot_t screenshot;
|
| + VREvent_ScreenshotProgress_t screenshotProgress;
|
| + VREvent_ApplicationLaunch_t applicationLaunch;
|
| + VREvent_EditingCameraSurface_t cameraSurface;
|
| + VREvent_MessageOverlay_t messageOverlay;
|
| + VREvent_Property_t property;
|
| +} VREvent_Data_t;
|
| +
|
| +/** An event posted by the server to all running applications */
|
| +struct VREvent_t
|
| +{
|
| + uint32_t eventType; // EVREventType enum
|
| + TrackedDeviceIndex_t trackedDeviceIndex;
|
| + float eventAgeSeconds;
|
| + // event data must be the end of the struct as its size is variable
|
| + VREvent_Data_t data;
|
| +};
|
| +
|
| +
|
| +/** The mesh to draw into the stencil (or depth) buffer to perform
|
| +* early stencil (or depth) kills of pixels that will never appear on the HMD.
|
| +* This mesh draws on all the pixels that will be hidden after distortion.
|
| +*
|
| +* If the HMD does not provide a visible area mesh pVertexData will be
|
| +* NULL and unTriangleCount will be 0. */
|
| +struct HiddenAreaMesh_t
|
| +{
|
| + const HmdVector2_t *pVertexData;
|
| + uint32_t unTriangleCount;
|
| +};
|
| +
|
| +
|
| +enum EHiddenAreaMeshType
|
| +{
|
| + k_eHiddenAreaMesh_Standard = 0,
|
| + k_eHiddenAreaMesh_Inverse = 1,
|
| + k_eHiddenAreaMesh_LineLoop = 2,
|
| +
|
| + k_eHiddenAreaMesh_Max = 3,
|
| +};
|
| +
|
| +
|
| +/** Identifies what kind of axis is on the controller at index n. Read this type
|
| +* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
|
| +*/
|
| +enum EVRControllerAxisType
|
| +{
|
| + k_eControllerAxis_None = 0,
|
| + k_eControllerAxis_TrackPad = 1,
|
| + k_eControllerAxis_Joystick = 2,
|
| + k_eControllerAxis_Trigger = 3, // Analog trigger data is in the X axis
|
| +};
|
| +
|
| +
|
| +/** contains information about one axis on the controller */
|
| +struct VRControllerAxis_t
|
| +{
|
| + float x; // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
|
| + float y; // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
|
| +};
|
| +
|
| +
|
| +/** the number of axes in the controller state */
|
| +static const uint32_t k_unControllerStateAxisCount = 5;
|
| +
|
| +
|
| +/** Holds all the state of a controller at one moment in time. */
|
| +struct VRControllerState001_t
|
| +{
|
| + // If packet num matches that on your prior call, then the controller state hasn't been changed since
|
| + // your last call and there is no need to process it
|
| + uint32_t unPacketNum;
|
| +
|
| + // bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
|
| + uint64_t ulButtonPressed;
|
| + uint64_t ulButtonTouched;
|
| +
|
| + // Axis data for the controller's analog inputs
|
| + VRControllerAxis_t rAxis[ k_unControllerStateAxisCount ];
|
| +};
|
| +
|
| +
|
| +typedef VRControllerState001_t VRControllerState_t;
|
| +
|
| +
|
| +/** determines how to provide output to the application of various event processing functions. */
|
| +enum EVRControllerEventOutputType
|
| +{
|
| + ControllerEventOutput_OSEvents = 0,
|
| + ControllerEventOutput_VREvents = 1,
|
| +};
|
| +
|
| +
|
| +
|
| +/** Collision Bounds Style */
|
| +enum ECollisionBoundsStyle
|
| +{
|
| + COLLISION_BOUNDS_STYLE_BEGINNER = 0,
|
| + COLLISION_BOUNDS_STYLE_INTERMEDIATE,
|
| + COLLISION_BOUNDS_STYLE_SQUARES,
|
| + COLLISION_BOUNDS_STYLE_ADVANCED,
|
| + COLLISION_BOUNDS_STYLE_NONE,
|
| +
|
| + COLLISION_BOUNDS_STYLE_COUNT
|
| +};
|
| +
|
| +/** Allows the application to customize how the overlay appears in the compositor */
|
| +struct Compositor_OverlaySettings
|
| +{
|
| + uint32_t size; // sizeof(Compositor_OverlaySettings)
|
| + bool curved, antialias;
|
| + float scale, distance, alpha;
|
| + float uOffset, vOffset, uScale, vScale;
|
| + float gridDivs, gridWidth, gridScale;
|
| + HmdMatrix44_t transform;
|
| +};
|
| +
|
| +/** used to refer to a single VR overlay */
|
| +typedef uint64_t VROverlayHandle_t;
|
| +
|
| +static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
|
| +
|
| +/** Errors that can occur around VR overlays */
|
| +enum EVROverlayError
|
| +{
|
| + VROverlayError_None = 0,
|
| +
|
| + VROverlayError_UnknownOverlay = 10,
|
| + VROverlayError_InvalidHandle = 11,
|
| + VROverlayError_PermissionDenied = 12,
|
| + VROverlayError_OverlayLimitExceeded = 13, // No more overlays could be created because the maximum number already exist
|
| + VROverlayError_WrongVisibilityType = 14,
|
| + VROverlayError_KeyTooLong = 15,
|
| + VROverlayError_NameTooLong = 16,
|
| + VROverlayError_KeyInUse = 17,
|
| + VROverlayError_WrongTransformType = 18,
|
| + VROverlayError_InvalidTrackedDevice = 19,
|
| + VROverlayError_InvalidParameter = 20,
|
| + VROverlayError_ThumbnailCantBeDestroyed = 21,
|
| + VROverlayError_ArrayTooSmall = 22,
|
| + VROverlayError_RequestFailed = 23,
|
| + VROverlayError_InvalidTexture = 24,
|
| + VROverlayError_UnableToLoadFile = 25,
|
| + VROverlayError_KeyboardAlreadyInUse = 26,
|
| + VROverlayError_NoNeighbor = 27,
|
| + VROverlayError_TooManyMaskPrimitives = 29,
|
| + VROverlayError_BadMaskPrimitive = 30,
|
| +};
|
| +
|
| +/** enum values to pass in to VR_Init to identify whether the application will
|
| +* draw a 3D scene. */
|
| +enum EVRApplicationType
|
| +{
|
| + VRApplication_Other = 0, // Some other kind of application that isn't covered by the other entries
|
| + VRApplication_Scene = 1, // Application will submit 3D frames
|
| + VRApplication_Overlay = 2, // Application only interacts with overlays
|
| + VRApplication_Background = 3, // Application should not start SteamVR if it's not already running, and should not
|
| + // keep it running if everything else quits.
|
| + VRApplication_Utility = 4, // Init should not try to load any drivers. The application needs access to utility
|
| + // interfaces (like IVRSettings and IVRApplications) but not hardware.
|
| + VRApplication_VRMonitor = 5, // Reserved for vrmonitor
|
| + VRApplication_SteamWatchdog = 6,// Reserved for Steam
|
| +
|
| + VRApplication_Max
|
| +};
|
| +
|
| +
|
| +/** error codes for firmware */
|
| +enum EVRFirmwareError
|
| +{
|
| + VRFirmwareError_None = 0,
|
| + VRFirmwareError_Success = 1,
|
| + VRFirmwareError_Fail = 2,
|
| +};
|
| +
|
| +
|
| +/** error codes for notifications */
|
| +enum EVRNotificationError
|
| +{
|
| + VRNotificationError_OK = 0,
|
| + VRNotificationError_InvalidNotificationId = 100,
|
| + VRNotificationError_NotificationQueueFull = 101,
|
| + VRNotificationError_InvalidOverlayHandle = 102,
|
| + VRNotificationError_SystemWithUserValueAlreadyExists = 103,
|
| +};
|
| +
|
| +
|
| +/** error codes returned by Vr_Init */
|
| +
|
| +// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
|
| +enum EVRInitError
|
| +{
|
| + VRInitError_None = 0,
|
| + VRInitError_Unknown = 1,
|
| +
|
| + VRInitError_Init_InstallationNotFound = 100,
|
| + VRInitError_Init_InstallationCorrupt = 101,
|
| + VRInitError_Init_VRClientDLLNotFound = 102,
|
| + VRInitError_Init_FileNotFound = 103,
|
| + VRInitError_Init_FactoryNotFound = 104,
|
| + VRInitError_Init_InterfaceNotFound = 105,
|
| + VRInitError_Init_InvalidInterface = 106,
|
| + VRInitError_Init_UserConfigDirectoryInvalid = 107,
|
| + VRInitError_Init_HmdNotFound = 108,
|
| + VRInitError_Init_NotInitialized = 109,
|
| + VRInitError_Init_PathRegistryNotFound = 110,
|
| + VRInitError_Init_NoConfigPath = 111,
|
| + VRInitError_Init_NoLogPath = 112,
|
| + VRInitError_Init_PathRegistryNotWritable = 113,
|
| + VRInitError_Init_AppInfoInitFailed = 114,
|
| + VRInitError_Init_Retry = 115, // Used internally to cause retries to vrserver
|
| + VRInitError_Init_InitCanceledByUser = 116, // The calling application should silently exit. The user canceled app startup
|
| + VRInitError_Init_AnotherAppLaunching = 117,
|
| + VRInitError_Init_SettingsInitFailed = 118,
|
| + VRInitError_Init_ShuttingDown = 119,
|
| + VRInitError_Init_TooManyObjects = 120,
|
| + VRInitError_Init_NoServerForBackgroundApp = 121,
|
| + VRInitError_Init_NotSupportedWithCompositor = 122,
|
| + VRInitError_Init_NotAvailableToUtilityApps = 123,
|
| + VRInitError_Init_Internal = 124,
|
| + VRInitError_Init_HmdDriverIdIsNone = 125,
|
| + VRInitError_Init_HmdNotFoundPresenceFailed = 126,
|
| + VRInitError_Init_VRMonitorNotFound = 127,
|
| + VRInitError_Init_VRMonitorStartupFailed = 128,
|
| + VRInitError_Init_LowPowerWatchdogNotSupported = 129,
|
| + VRInitError_Init_InvalidApplicationType = 130,
|
| + VRInitError_Init_NotAvailableToWatchdogApps = 131,
|
| + VRInitError_Init_WatchdogDisabledInSettings = 132,
|
| + VRInitError_Init_VRDashboardNotFound = 133,
|
| + VRInitError_Init_VRDashboardStartupFailed = 134,
|
| +
|
| + VRInitError_Driver_Failed = 200,
|
| + VRInitError_Driver_Unknown = 201,
|
| + VRInitError_Driver_HmdUnknown = 202,
|
| + VRInitError_Driver_NotLoaded = 203,
|
| + VRInitError_Driver_RuntimeOutOfDate = 204,
|
| + VRInitError_Driver_HmdInUse = 205,
|
| + VRInitError_Driver_NotCalibrated = 206,
|
| + VRInitError_Driver_CalibrationInvalid = 207,
|
| + VRInitError_Driver_HmdDisplayNotFound = 208,
|
| + VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
|
| + // VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
|
| + VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
|
| + VRInitError_Driver_HmdDisplayMirrored = 212,
|
| +
|
| + VRInitError_IPC_ServerInitFailed = 300,
|
| + VRInitError_IPC_ConnectFailed = 301,
|
| + VRInitError_IPC_SharedStateInitFailed = 302,
|
| + VRInitError_IPC_CompositorInitFailed = 303,
|
| + VRInitError_IPC_MutexInitFailed = 304,
|
| + VRInitError_IPC_Failed = 305,
|
| + VRInitError_IPC_CompositorConnectFailed = 306,
|
| + VRInitError_IPC_CompositorInvalidConnectResponse = 307,
|
| + VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
|
| +
|
| + VRInitError_Compositor_Failed = 400,
|
| + VRInitError_Compositor_D3D11HardwareRequired = 401,
|
| + VRInitError_Compositor_FirmwareRequiresUpdate = 402,
|
| + VRInitError_Compositor_OverlayInitFailed = 403,
|
| + VRInitError_Compositor_ScreenshotsInitFailed = 404,
|
| +
|
| + VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
|
| +
|
| + VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
|
| + VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
|
| + VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
|
| + VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
|
| + VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
|
| + VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
|
| + VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
|
| + VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
|
| + VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
|
| + VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
|
| + VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
|
| + VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
|
| + VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
|
| +
|
| + VRInitError_Steam_SteamInstallationNotFound = 2000,
|
| +};
|
| +
|
| +enum EVRScreenshotType
|
| +{
|
| + VRScreenshotType_None = 0,
|
| + VRScreenshotType_Mono = 1, // left eye only
|
| + VRScreenshotType_Stereo = 2,
|
| + VRScreenshotType_Cubemap = 3,
|
| + VRScreenshotType_MonoPanorama = 4,
|
| + VRScreenshotType_StereoPanorama = 5
|
| +};
|
| +
|
| +enum EVRScreenshotPropertyFilenames
|
| +{
|
| + VRScreenshotPropertyFilenames_Preview = 0,
|
| + VRScreenshotPropertyFilenames_VR = 1,
|
| +};
|
| +
|
| +enum EVRTrackedCameraError
|
| +{
|
| + VRTrackedCameraError_None = 0,
|
| + VRTrackedCameraError_OperationFailed = 100,
|
| + VRTrackedCameraError_InvalidHandle = 101,
|
| + VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
|
| + VRTrackedCameraError_OutOfHandles = 103,
|
| + VRTrackedCameraError_IPCFailure = 104,
|
| + VRTrackedCameraError_NotSupportedForThisDevice = 105,
|
| + VRTrackedCameraError_SharedMemoryFailure = 106,
|
| + VRTrackedCameraError_FrameBufferingFailure = 107,
|
| + VRTrackedCameraError_StreamSetupFailure = 108,
|
| + VRTrackedCameraError_InvalidGLTextureId = 109,
|
| + VRTrackedCameraError_InvalidSharedTextureHandle = 110,
|
| + VRTrackedCameraError_FailedToGetGLTextureId = 111,
|
| + VRTrackedCameraError_SharedTextureFailure = 112,
|
| + VRTrackedCameraError_NoFrameAvailable = 113,
|
| + VRTrackedCameraError_InvalidArgument = 114,
|
| + VRTrackedCameraError_InvalidFrameBufferSize = 115,
|
| +};
|
| +
|
| +enum EVRTrackedCameraFrameType
|
| +{
|
| + VRTrackedCameraFrameType_Distorted = 0, // This is the camera video frame size in pixels, still distorted.
|
| + VRTrackedCameraFrameType_Undistorted, // In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
|
| + VRTrackedCameraFrameType_MaximumUndistorted, // In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
|
| + MAX_CAMERA_FRAME_TYPES
|
| +};
|
| +
|
| +typedef uint64_t TrackedCameraHandle_t;
|
| +#define INVALID_TRACKED_CAMERA_HANDLE ((vr::TrackedCameraHandle_t)0)
|
| +
|
| +struct CameraVideoStreamFrameHeader_t
|
| +{
|
| + EVRTrackedCameraFrameType eFrameType;
|
| +
|
| + uint32_t nWidth;
|
| + uint32_t nHeight;
|
| + uint32_t nBytesPerPixel;
|
| +
|
| + uint32_t nFrameSequence;
|
| +
|
| + TrackedDevicePose_t standingTrackedDevicePose;
|
| +};
|
| +
|
| +// Screenshot types
|
| +typedef uint32_t ScreenshotHandle_t;
|
| +
|
| +static const uint32_t k_unScreenshotHandleInvalid = 0;
|
| +
|
| +#pragma pack( pop )
|
| +
|
| +// figure out how to import from the VR API dll
|
| +#if defined(_WIN32)
|
| +
|
| +#ifdef VR_API_EXPORT
|
| +#define VR_INTERFACE extern "C" __declspec( dllexport )
|
| +#else
|
| +#define VR_INTERFACE extern "C" __declspec( dllimport )
|
| +#endif
|
| +
|
| +#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
|
| +
|
| +#ifdef VR_API_EXPORT
|
| +#define VR_INTERFACE extern "C" __attribute__((visibility("default")))
|
| +#else
|
| +#define VR_INTERFACE extern "C"
|
| +#endif
|
| +
|
| +#else
|
| +#error "Unsupported Platform."
|
| +#endif
|
| +
|
| +
|
| +#if defined( _WIN32 )
|
| +#define VR_CALLTYPE __cdecl
|
| +#else
|
| +#define VR_CALLTYPE
|
| +#endif
|
| +
|
| +} // namespace vr
|
| +
|
| +#endif // _INCLUDE_VRTYPES_H
|
| +
|
| +
|
| +// vrannotation.h
|
| +#ifdef API_GEN
|
| +# define VR_CLANG_ATTR(ATTR) __attribute__((annotate( ATTR )))
|
| +#else
|
| +# define VR_CLANG_ATTR(ATTR)
|
| +#endif
|
| +
|
| +#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR( "desc:" #DESC ";" )
|
| +#define VR_IGNOREATTR() VR_CLANG_ATTR( "ignore" )
|
| +#define VR_OUT_STRUCT() VR_CLANG_ATTR( "out_struct: ;" )
|
| +#define VR_OUT_STRING() VR_CLANG_ATTR( "out_string: ;" )
|
| +#define VR_OUT_ARRAY_CALL(COUNTER,FUNCTION,PARAMS) VR_CLANG_ATTR( "out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";" )
|
| +#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "out_array_count:" #COUNTER ";" )
|
| +#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "array_count:" #COUNTER ";" )
|
| +#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR( "array_count:" #COUNTER ";desc:" #DESC )
|
| +#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "buffer_count:" #COUNTER ";" )
|
| +#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "out_buffer_count:" #COUNTER ";" )
|
| +#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR( "out_string_count:" #COUNTER ";" )
|
| +
|
| +// vrtrackedcameratypes.h
|
| +#ifndef _VRTRACKEDCAMERATYPES_H
|
| +#define _VRTRACKEDCAMERATYPES_H
|
| +
|
| +namespace vr
|
| +{
|
| +
|
| +#if defined(__linux__) || defined(__APPLE__)
|
| + // The 32-bit version of gcc has the alignment requirement for uint64 and double set to
|
| + // 4 meaning that even with #pragma pack(8) these types will only be four-byte aligned.
|
| + // The 64-bit version of gcc has the alignment requirement for these types set to
|
| + // 8 meaning that unless we use #pragma pack(4) our structures will get bigger.
|
| + // The 64-bit structure packing has to match the 32-bit structure packing for each platform.
|
| + #pragma pack( push, 4 )
|
| +#else
|
| + #pragma pack( push, 8 )
|
| +#endif
|
| +
|
| +enum ECameraVideoStreamFormat
|
| +{
|
| + CVS_FORMAT_UNKNOWN = 0,
|
| + CVS_FORMAT_RAW10 = 1, // 10 bits per pixel
|
| + CVS_FORMAT_NV12 = 2, // 12 bits per pixel
|
| + CVS_FORMAT_RGB24 = 3, // 24 bits per pixel
|
| + CVS_MAX_FORMATS
|
| +};
|
| +
|
| +enum ECameraCompatibilityMode
|
| +{
|
| + CAMERA_COMPAT_MODE_BULK_DEFAULT = 0,
|
| + CAMERA_COMPAT_MODE_BULK_64K_DMA,
|
| + CAMERA_COMPAT_MODE_BULK_16K_DMA,
|
| + CAMERA_COMPAT_MODE_BULK_8K_DMA,
|
| + CAMERA_COMPAT_MODE_ISO_52FPS,
|
| + CAMERA_COMPAT_MODE_ISO_50FPS,
|
| + CAMERA_COMPAT_MODE_ISO_48FPS,
|
| + CAMERA_COMPAT_MODE_ISO_46FPS,
|
| + CAMERA_COMPAT_MODE_ISO_44FPS,
|
| + CAMERA_COMPAT_MODE_ISO_42FPS,
|
| + CAMERA_COMPAT_MODE_ISO_40FPS,
|
| + CAMERA_COMPAT_MODE_ISO_35FPS,
|
| + CAMERA_COMPAT_MODE_ISO_30FPS,
|
| + MAX_CAMERA_COMPAT_MODES
|
| +};
|
| +
|
| +#ifdef _MSC_VER
|
| +#define VR_CAMERA_DECL_ALIGN( x ) __declspec( align( x ) )
|
| +#else
|
| +#define VR_CAMERA_DECL_ALIGN( x ) //
|
| +#endif
|
| +
|
| +#define MAX_CAMERA_FRAME_SHARED_HANDLES 4
|
| +
|
| +VR_CAMERA_DECL_ALIGN( 8 ) struct CameraVideoStreamFrame_t
|
| +{
|
| + ECameraVideoStreamFormat m_nStreamFormat;
|
| +
|
| + uint32_t m_nWidth;
|
| + uint32_t m_nHeight;
|
| +
|
| + uint32_t m_nImageDataSize; // Based on stream format, width, height
|
| +
|
| + uint32_t m_nFrameSequence; // Starts from 0 when stream starts.
|
| +
|
| + uint32_t m_nBufferIndex; // Identifies which buffer the image data is hosted
|
| + uint32_t m_nBufferCount; // Total number of configured buffers
|
| +
|
| + uint32_t m_nExposureTime;
|
| +
|
| + uint32_t m_nISPFrameTimeStamp; // Driver provided time stamp per driver centric time base
|
| + uint32_t m_nISPReferenceTimeStamp;
|
| + uint32_t m_nSyncCounter;
|
| +
|
| + uint32_t m_nCamSyncEvents;
|
| + uint32_t m_nISPSyncEvents;
|
| +
|
| + double m_flReferenceCamSyncTime;
|
| +
|
| + double m_flFrameElapsedTime; // Starts from 0 when stream starts. In seconds.
|
| + double m_flFrameDeliveryRate;
|
| +
|
| + double m_flFrameCaptureTime_DriverAbsolute; // In USB time, via AuxEvent
|
| + double m_flFrameCaptureTime_ServerRelative; // In System time within the server
|
| + uint64_t m_nFrameCaptureTicks_ServerAbsolute; // In system ticks within the server
|
| + double m_flFrameCaptureTime_ClientRelative; // At the client, relative to when the frame was exposed/captured.
|
| +
|
| + double m_flSyncMarkerError;
|
| +
|
| + TrackedDevicePose_t m_StandingTrackedDevicePose; // Supplied by HMD layer when used as a tracked camera
|
| +
|
| + uint64_t m_pImageData;
|
| +};
|
| +
|
| +#pragma pack( pop )
|
| +
|
| +}
|
| +
|
| +#endif // _VRTRACKEDCAMERATYPES_H
|
| +// ivrsettings.h
|
| +namespace vr
|
| +{
|
| + enum EVRSettingsError
|
| + {
|
| + VRSettingsError_None = 0,
|
| + VRSettingsError_IPCFailed = 1,
|
| + VRSettingsError_WriteFailed = 2,
|
| + VRSettingsError_ReadFailed = 3,
|
| + VRSettingsError_JsonParseFailed = 4,
|
| + VRSettingsError_UnsetSettingHasNoDefault = 5, // This will be returned if the setting does not appear in the appropriate default file and has not been set
|
| + };
|
| +
|
| + // The maximum length of a settings key
|
| + static const uint32_t k_unMaxSettingsKeyLength = 128;
|
| +
|
| + class IVRSettings
|
| + {
|
| + public:
|
| + virtual const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) = 0;
|
| +
|
| + // Returns true if file sync occurred (force or settings dirty)
|
| + virtual bool Sync( bool bForce = false, EVRSettingsError *peError = nullptr ) = 0;
|
| +
|
| + virtual void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr ) = 0;
|
| + virtual void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr ) = 0;
|
| + virtual void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr ) = 0;
|
| + virtual void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr ) = 0;
|
| +
|
| + // Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
|
| + // of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
|
| + virtual bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
|
| + virtual int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
|
| + virtual float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
|
| + virtual void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr ) = 0;
|
| +
|
| + virtual void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr ) = 0;
|
| + virtual void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
|
| + };
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + static const char * const IVRSettings_Version = "IVRSettings_002";
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + // steamvr keys
|
| + static const char * const k_pch_SteamVR_Section = "steamvr";
|
| + static const char * const k_pch_SteamVR_RequireHmd_String = "requireHmd";
|
| + static const char * const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
|
| + static const char * const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
|
| + static const char * const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
|
| + static const char * const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
|
| + static const char * const k_pch_SteamVR_EnableDistortion_Bool = "enableDistortion";
|
| + static const char * const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
|
| + static const char * const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
|
| + static const char * const k_pch_SteamVR_SendSystemButtonToAllApps_Bool= "sendSystemButtonToAllApps";
|
| + static const char * const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
|
| + static const char * const k_pch_SteamVR_IPD_Float = "ipd";
|
| + static const char * const k_pch_SteamVR_Background_String = "background";
|
| + static const char * const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
|
| + static const char * const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
|
| + static const char * const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
|
| + static const char * const k_pch_SteamVR_GridColor_String = "gridColor";
|
| + static const char * const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
|
| + static const char * const k_pch_SteamVR_ShowStage_Bool = "showStage";
|
| + static const char * const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
|
| + static const char * const k_pch_SteamVR_DirectMode_Bool = "directMode";
|
| + static const char * const k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
|
| + static const char * const k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
|
| + static const char * const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
|
| + static const char * const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
|
| + static const char * const k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
|
| + static const char * const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
|
| + static const char * const k_pch_SteamVR_RenderTargetMultiplier_Float = "renderTargetMultiplier";
|
| + static const char * const k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
|
| + static const char * const k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
|
| + static const char * const k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
|
| + static const char * const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
|
| + static const char * const k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
|
| + static const char * const k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
|
| + static const char * const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
|
| + static const char * const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
|
| + static const char * const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
|
| + static const char * const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
|
| + static const char * const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
|
| + static const char * const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
|
| + static const char * const k_pch_SteamVR_SetInitialDefaultHomeApp = "setInitialDefaultHomeApp";
|
| + static const char * const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
|
| + static const char * const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
|
| + static const char * const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + // lighthouse keys
|
| + static const char * const k_pch_Lighthouse_Section = "driver_lighthouse";
|
| + static const char * const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
|
| + static const char * const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
|
| + static const char * const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
|
| + static const char * const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
|
| + static const char * const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + // null keys
|
| + static const char * const k_pch_Null_Section = "driver_null";
|
| + static const char * const k_pch_Null_SerialNumber_String = "serialNumber";
|
| + static const char * const k_pch_Null_ModelNumber_String = "modelNumber";
|
| + static const char * const k_pch_Null_WindowX_Int32 = "windowX";
|
| + static const char * const k_pch_Null_WindowY_Int32 = "windowY";
|
| + static const char * const k_pch_Null_WindowWidth_Int32 = "windowWidth";
|
| + static const char * const k_pch_Null_WindowHeight_Int32 = "windowHeight";
|
| + static const char * const k_pch_Null_RenderWidth_Int32 = "renderWidth";
|
| + static const char * const k_pch_Null_RenderHeight_Int32 = "renderHeight";
|
| + static const char * const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
|
| + static const char * const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + // user interface keys
|
| + static const char * const k_pch_UserInterface_Section = "userinterface";
|
| + static const char * const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
|
| + static const char * const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
|
| + static const char * const k_pch_UserInterface_Screenshots_Bool = "screenshots";
|
| + static const char * const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + // notification keys
|
| + static const char * const k_pch_Notifications_Section = "notifications";
|
| + static const char * const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + // keyboard keys
|
| + static const char * const k_pch_Keyboard_Section = "keyboard";
|
| + static const char * const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
|
| + static const char * const k_pch_Keyboard_ScaleX = "ScaleX";
|
| + static const char * const k_pch_Keyboard_ScaleY = "ScaleY";
|
| + static const char * const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
|
| + static const char * const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
|
| + static const char * const k_pch_Keyboard_OffsetY = "OffsetY";
|
| + static const char * const k_pch_Keyboard_Smoothing = "Smoothing";
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + // perf keys
|
| + static const char * const k_pch_Perf_Section = "perfcheck";
|
| + static const char * const k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
|
| + static const char * const k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
|
| + static const char * const k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
|
| + static const char * const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
|
| + static const char * const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
|
| + static const char * const k_pch_Perf_TestData_Float = "perfTestData";
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + // collision bounds keys
|
| + static const char * const k_pch_CollisionBounds_Section = "collisionBounds";
|
| + static const char * const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
|
| + static const char * const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
|
| + static const char * const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
|
| + static const char * const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
|
| + static const char * const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
|
| + static const char * const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
|
| + static const char * const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
|
| + static const char * const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
|
| + static const char * const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + // camera keys
|
| + static const char * const k_pch_Camera_Section = "camera";
|
| + static const char * const k_pch_Camera_EnableCamera_Bool = "enableCamera";
|
| + static const char * const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
|
| + static const char * const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
|
| + static const char * const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
|
| + static const char * const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
|
| + static const char * const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
|
| + static const char * const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
|
| + static const char * const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
|
| + static const char * const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + // audio keys
|
| + static const char * const k_pch_audio_Section = "audio";
|
| + static const char * const k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
|
| + static const char * const k_pch_audio_OnRecordDevice_String = "onRecordDevice";
|
| + static const char * const k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
|
| + static const char * const k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
|
| + static const char * const k_pch_audio_OffRecordDevice_String = "offRecordDevice";
|
| + static const char * const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + // power management keys
|
| + static const char * const k_pch_Power_Section = "power";
|
| + static const char * const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
|
| + static const char * const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
|
| + static const char * const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
|
| + static const char * const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
|
| + static const char * const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + // dashboard keys
|
| + static const char * const k_pch_Dashboard_Section = "dashboard";
|
| + static const char * const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
|
| + static const char * const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + // model skin keys
|
| + static const char * const k_pch_modelskin_Section = "modelskins";
|
| +
|
| + //-----------------------------------------------------------------------------
|
| + // driver keys - These could be checked in any driver_<name> section
|
| + static const char * const k_pch_Driver_Enable_Bool = "enable";
|
| +
|
| +} // namespace vr
|
| +
|
| +// iservertrackeddevicedriver.h
|
| +namespace vr
|
| +{
|
| +
|
| +
|
| +struct DriverPoseQuaternion_t
|
| +{
|
| + double w, x, y, z;
|
| +};
|
| +
|
| +struct DriverPose_t
|
| +{
|
| + /* Time offset of this pose, in seconds from the actual time of the pose,
|
| + * relative to the time of the PoseUpdated() call made by the driver.
|
| + */
|
| + double poseTimeOffset;
|
| +
|
| + /* Generally, the pose maintained by a driver
|
| + * is in an inertial coordinate system different
|
| + * from the world system of x+ right, y+ up, z+ back.
|
| + * Also, the driver is not usually tracking the "head" position,
|
| + * but instead an internal IMU or another reference point in the HMD.
|
| + * The following two transforms transform positions and orientations
|
| + * to app world space from driver world space,
|
| + * and to HMD head space from driver local body space.
|
| + *
|
| + * We maintain the driver pose state in its internal coordinate system,
|
| + * so we can do the pose prediction math without having to
|
| + * use angular acceleration. A driver's angular acceleration is generally not measured,
|
| + * and is instead calculated from successive samples of angular velocity.
|
| + * This leads to a noisy angular acceleration values, which are also
|
| + * lagged due to the filtering required to reduce noise to an acceptable level.
|
| + */
|
| + vr::HmdQuaternion_t qWorldFromDriverRotation;
|
| + double vecWorldFromDriverTranslation[ 3 ];
|
| +
|
| + vr::HmdQuaternion_t qDriverFromHeadRotation;
|
| + double vecDriverFromHeadTranslation[ 3 ];
|
| +
|
| + /* State of driver pose, in meters and radians. */
|
| + /* Position of the driver tracking reference in driver world space
|
| + * +[0] (x) is right
|
| + * +[1] (y) is up
|
| + * -[2] (z) is forward
|
| + */
|
| + double vecPosition[ 3 ];
|
| +
|
| + /* Velocity of the pose in meters/second */
|
| + double vecVelocity[ 3 ];
|
| +
|
| + /* Acceleration of the pose in meters/second */
|
| + double vecAcceleration[ 3 ];
|
| +
|
| + /* Orientation of the tracker, represented as a quaternion */
|
| + vr::HmdQuaternion_t qRotation;
|
| +
|
| + /* Angular velocity of the pose in axis-angle
|
| + * representation. The direction is the angle of
|
| + * rotation and the magnitude is the angle around
|
| + * that axis in radians/second. */
|
| + double vecAngularVelocity[ 3 ];
|
| +
|
| + /* Angular acceleration of the pose in axis-angle
|
| + * representation. The direction is the angle of
|
| + * rotation and the magnitude is the angle around
|
| + * that axis in radians/second^2. */
|
| + double vecAngularAcceleration[ 3 ];
|
| +
|
| + ETrackingResult result;
|
| +
|
| + bool poseIsValid;
|
| + bool willDriftInYaw;
|
| + bool shouldApplyHeadModel;
|
| + bool deviceIsConnected;
|
| +};
|
| +
|
| +
|
| +// ----------------------------------------------------------------------------------------------
|
| +// Purpose: Represents a single tracked device in a driver
|
| +// ----------------------------------------------------------------------------------------------
|
| +class ITrackedDeviceServerDriver
|
| +{
|
| +public:
|
| +
|
| + // ------------------------------------
|
| + // Management Methods
|
| + // ------------------------------------
|
| + /** This is called before an HMD is returned to the application. It will always be
|
| + * called before any display or tracking methods. Memory and processor use by the
|
| + * ITrackedDeviceServerDriver object should be kept to a minimum until it is activated.
|
| + * The pose listener is guaranteed to be valid until Deactivate is called, but
|
| + * should not be used after that point. */
|
| + virtual EVRInitError Activate( uint32_t unObjectId ) = 0;
|
| +
|
| + /** This is called when The VR system is switching from this Hmd being the active display
|
| + * to another Hmd being the active display. The driver should clean whatever memory
|
| + * and thread use it can when it is deactivated */
|
| + virtual void Deactivate() = 0;
|
| +
|
| + /** Handles a request from the system to put this device into standby mode. What that means is defined per-device. */
|
| + virtual void EnterStandby() = 0;
|
| +
|
| + /** Requests a component interface of the driver for device-specific functionality. The driver should return NULL
|
| + * if the requested interface or version is not supported. */
|
| + virtual void *GetComponent( const char *pchComponentNameAndVersion ) = 0;
|
| +
|
| + /** A VR Client has made this debug request of the driver. The set of valid requests is entirely
|
| + * up to the driver and the client to figure out, as is the format of the response. Responses that
|
| + * exceed the length of the supplied buffer should be truncated and null terminated */
|
| + virtual void DebugRequest( const char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize ) = 0;
|
| +
|
| + // ------------------------------------
|
| + // Tracking Methods
|
| + // ------------------------------------
|
| + virtual DriverPose_t GetPose() = 0;
|
| +};
|
| +
|
| +
|
| +
|
| +static const char *ITrackedDeviceServerDriver_Version = "ITrackedDeviceServerDriver_005";
|
| +
|
| +}
|
| +// ivrdisplaycomponent.h
|
| +namespace vr
|
| +{
|
| +
|
| +
|
| + // ----------------------------------------------------------------------------------------------
|
| + // Purpose: The display component on a single tracked device
|
| + // ----------------------------------------------------------------------------------------------
|
| + class IVRDisplayComponent
|
| + {
|
| + public:
|
| +
|
| + // ------------------------------------
|
| + // Display Methods
|
| + // ------------------------------------
|
| +
|
| + /** Size and position that the window needs to be on the VR display. */
|
| + virtual void GetWindowBounds( int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
|
| +
|
| + /** Returns true if the display is extending the desktop. */
|
| + virtual bool IsDisplayOnDesktop( ) = 0;
|
| +
|
| + /** Returns true if the display is real and not a fictional display. */
|
| + virtual bool IsDisplayRealDisplay( ) = 0;
|
| +
|
| + /** Suggested size for the intermediate render target that the distortion pulls from. */
|
| + virtual void GetRecommendedRenderTargetSize( uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
|
| +
|
| + /** Gets the viewport in the frame buffer to draw the output of the distortion into */
|
| + virtual void GetEyeOutputViewport( EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
|
| +
|
| + /** 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 ) = 0;
|
| +
|
| + /** Returns 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. */
|
| + virtual DistortionCoordinates_t ComputeDistortion( EVREye eEye, float fU, float fV ) = 0;
|
| +
|
| + };
|
| +
|
| + static const char *IVRDisplayComponent_Version = "IVRDisplayComponent_002";
|
| +
|
| +}
|
| +
|
| +// ivrdriverdirectmodecomponent.h
|
| +namespace vr
|
| +{
|
| +
|
| +
|
| + // ----------------------------------------------------------------------------------------------
|
| + // Purpose: This component is used for drivers that implement direct mode entirely on their own
|
| + // without allowing the VR Compositor to own the window/device. Chances are you don't
|
| + // need to implement this component in your driver.
|
| + // ----------------------------------------------------------------------------------------------
|
| + class IVRDriverDirectModeComponent
|
| + {
|
| + public:
|
| +
|
| + // -----------------------------------
|
| + // Direct mode methods
|
| + // -----------------------------------
|
| +
|
| + /** Specific to Oculus compositor support, textures supplied must be created using this method. */
|
| + virtual void CreateSwapTextureSet( uint32_t unPid, uint32_t unFormat, uint32_t unWidth, uint32_t unHeight, vr::SharedTextureHandle_t( *pSharedTextureHandles )[ 3 ] ) {}
|
| +
|
| + /** Used to textures created using CreateSwapTextureSet. Only one of the set's handles needs to be used to destroy the entire set. */
|
| + virtual void DestroySwapTextureSet( vr::SharedTextureHandle_t sharedTextureHandle ) {}
|
| +
|
| + /** Used to purge all texture sets for a given process. */
|
| + virtual void DestroyAllSwapTextureSets( uint32_t unPid ) {}
|
| +
|
| + /** After Present returns, calls this to get the next index to use for rendering. */
|
| + virtual void GetNextSwapTextureSetIndex( vr::SharedTextureHandle_t sharedTextureHandles[ 2 ], uint32_t( *pIndices )[ 2 ] ) {}
|
| +
|
| + /** Call once per layer to draw for this frame. One shared texture handle per eye. Textures must be created
|
| + * using CreateSwapTextureSet and should be alternated per frame. Call Present once all layers have been submitted. */
|
| + virtual void SubmitLayer( vr::SharedTextureHandle_t sharedTextureHandles[ 2 ], const vr::VRTextureBounds_t( &bounds )[ 2 ], const vr::HmdMatrix34_t *pPose ) {}
|
| +
|
| + /** Submits queued layers for display. */
|
| + virtual void Present( vr::SharedTextureHandle_t syncTexture ) {}
|
| +
|
| + };
|
| +
|
| + static const char *IVRDriverDirectModeComponent_Version = "IVRDriverDirectModeComponent_002";
|
| +
|
| +}
|
| +
|
| +// ivrcontrollercomponent.h
|
| +namespace vr
|
| +{
|
| +
|
| +
|
| + // ----------------------------------------------------------------------------------------------
|
| + // Purpose: Controller access on a single tracked device.
|
| + // ----------------------------------------------------------------------------------------------
|
| + class IVRControllerComponent
|
| + {
|
| + public:
|
| +
|
| + // ------------------------------------
|
| + // Controller Methods
|
| + // ------------------------------------
|
| +
|
| + /** Gets the current state of a controller. */
|
| + virtual VRControllerState_t GetControllerState( ) = 0;
|
| +
|
| + /** Returns a uint64 property. If the property is not available this function will return 0. */
|
| + virtual bool TriggerHapticPulse( uint32_t unAxisId, uint16_t usPulseDurationMicroseconds ) = 0;
|
| +
|
| + };
|
| +
|
| +
|
| +
|
| + static const char *IVRControllerComponent_Version = "IVRControllerComponent_001";
|
| +
|
| +}
|
| +// ivrcameracomponent.h
|
| +namespace vr
|
| +{
|
| + //-----------------------------------------------------------------------------
|
| + //-----------------------------------------------------------------------------
|
| + class ICameraVideoSinkCallback
|
| + {
|
| + public:
|
| + virtual void OnCameraVideoSinkCallback() = 0;
|
| + };
|
| +
|
| + // ----------------------------------------------------------------------------------------------
|
| + // Purpose: The camera on a single tracked device
|
| + // ----------------------------------------------------------------------------------------------
|
| + class IVRCameraComponent
|
| + {
|
| + public:
|
| + // ------------------------------------
|
| + // Camera Methods
|
| + // ------------------------------------
|
| + virtual bool GetCameraFrameDimensions( vr::ECameraVideoStreamFormat nVideoStreamFormat, uint32_t *pWidth, uint32_t *pHeight ) = 0;
|
| + virtual bool GetCameraFrameBufferingRequirements( int *pDefaultFrameQueueSize, uint32_t *pFrameBufferDataSize ) = 0;
|
| + virtual bool SetCameraFrameBuffering( int nFrameBufferCount, void **ppFrameBuffers, uint32_t nFrameBufferDataSize ) = 0;
|
| + virtual bool SetCameraVideoStreamFormat( vr::ECameraVideoStreamFormat nVideoStreamFormat ) = 0;
|
| + virtual vr::ECameraVideoStreamFormat GetCameraVideoStreamFormat() = 0;
|
| + virtual bool StartVideoStream() = 0;
|
| + virtual void StopVideoStream() = 0;
|
| + virtual bool IsVideoStreamActive( bool *pbPaused, float *pflElapsedTime ) = 0;
|
| + virtual const vr::CameraVideoStreamFrame_t *GetVideoStreamFrame() = 0;
|
| + virtual void ReleaseVideoStreamFrame( const vr::CameraVideoStreamFrame_t *pFrameImage ) = 0;
|
| + virtual bool SetAutoExposure( bool bEnable ) = 0;
|
| + virtual bool PauseVideoStream() = 0;
|
| + virtual bool ResumeVideoStream() = 0;
|
| + virtual bool GetCameraDistortion( float flInputU, float flInputV, float *pflOutputU, float *pflOutputV ) = 0;
|
| + virtual bool GetCameraProjection( vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection ) = 0;
|
| + virtual bool SetFrameRate( int nISPFrameRate, int nSensorFrameRate ) = 0;
|
| + virtual bool SetCameraVideoSinkCallback( vr::ICameraVideoSinkCallback *pCameraVideoSinkCallback ) = 0;
|
| + virtual bool GetCameraCompatibilityMode( vr::ECameraCompatibilityMode *pCameraCompatibilityMode ) = 0;
|
| + virtual bool SetCameraCompatibilityMode( vr::ECameraCompatibilityMode nCameraCompatibilityMode ) = 0;
|
| + virtual bool GetCameraFrameBounds( vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pLeft, uint32_t *pTop, uint32_t *pWidth, uint32_t *pHeight ) = 0;
|
| + virtual bool GetCameraIntrinsics( vr::EVRTrackedCameraFrameType eFrameType, HmdVector2_t *pFocalLength, HmdVector2_t *pCenter ) = 0;
|
| + };
|
| +
|
| + static const char *IVRCameraComponent_Version = "IVRCameraComponent_002";
|
| +}
|
| +// itrackeddevicedriverprovider.h
|
| +namespace vr
|
| +{
|
| +
|
| +class ITrackedDeviceServerDriver;
|
| +struct TrackedDeviceDriverInfo_t;
|
| +struct DriverPose_t;
|
| +typedef PropertyContainerHandle_t DriverHandle_t;
|
| +
|
| +/** This interface is provided by vrserver to allow the driver to notify
|
| +* the system when something changes about a device. These changes must
|
| +* not change the serial number or class of the device because those values
|
| +* are permanently associated with the device's index. */
|
| +class IVRDriverContext
|
| +{
|
| +public:
|
| + /** Returns the requested interface. If the interface was not available it will return NULL and fill
|
| + * out the error. */
|
| + virtual void *GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError = nullptr ) = 0;
|
| +
|
| + /** Returns the property container handle for this driver */
|
| + virtual DriverHandle_t GetDriverHandle() = 0;
|
| +};
|
| +
|
| +
|
| +/** This interface must be implemented in each driver. It will be loaded in vrserver.exe */
|
| +class IServerTrackedDeviceProvider
|
| +{
|
| +public:
|
| + /** initializes the driver. This will be called before any other methods are called.
|
| + * If Init returns anything other than VRInitError_None the driver DLL will be unloaded.
|
| + *
|
| + * pDriverHost will never be NULL, and will always be a pointer to a IServerDriverHost interface
|
| + *
|
| + * pchUserDriverConfigDir - The absolute path of the directory where the driver should store user
|
| + * config files.
|
| + * pchDriverInstallDir - The absolute path of the root directory for the driver.
|
| + */
|
| + virtual EVRInitError Init( IVRDriverContext *pDriverContext ) = 0;
|
| +
|
| + /** cleans up the driver right before it is unloaded */
|
| + virtual void Cleanup() = 0;
|
| +
|
| + /** Returns the version of the ITrackedDeviceServerDriver interface used by this driver */
|
| + virtual const char * const *GetInterfaceVersions() = 0;
|
| +
|
| + /** Allows the driver do to some work in the main loop of the server. */
|
| + virtual void RunFrame() = 0;
|
| +
|
| +
|
| + // ------------ Power State Functions ----------------------- //
|
| +
|
| + /** Returns true if the driver wants to block Standby mode. */
|
| + virtual bool ShouldBlockStandbyMode() = 0;
|
| +
|
| + /** Called when the system is entering Standby mode. The driver should switch itself into whatever sort of low-power
|
| + * state it has. */
|
| + virtual void EnterStandby() = 0;
|
| +
|
| + /** Called when the system is leaving Standby mode. The driver should switch itself back to
|
| + full operation. */
|
| + virtual void LeaveStandby() = 0;
|
| +
|
| +};
|
| +
|
| +
|
| +static const char *IServerTrackedDeviceProvider_Version = "IServerTrackedDeviceProvider_004";
|
| +
|
| +
|
| +
|
| +
|
| +/** This interface must be implemented in each driver. It will be loaded in vrclient.dll */
|
| +class IVRWatchdogProvider
|
| +{
|
| +public:
|
| + /** initializes the driver in watchdog mode. */
|
| + virtual EVRInitError Init( IVRDriverContext *pDriverContext ) = 0;
|
| +
|
| + /** cleans up the driver right before it is unloaded */
|
| + virtual void Cleanup() = 0;
|
| +};
|
| +
|
| +static const char *IVRWatchdogProvider_Version = "IVRWatchdogProvider_001";
|
| +
|
| +}
|
| +// ivrproperties.h
|
| +#include <string>
|
| +
|
| +namespace vr
|
| +{
|
| +
|
| + enum EPropertyWriteType
|
| + {
|
| + PropertyWrite_Set = 0,
|
| + PropertyWrite_Erase = 1,
|
| + PropertyWrite_SetError = 2
|
| + };
|
| +
|
| + struct PropertyWrite_t
|
| + {
|
| + ETrackedDeviceProperty prop;
|
| + EPropertyWriteType writeType;
|
| + ETrackedPropertyError eSetError;
|
| + void *pvBuffer;
|
| + uint32_t unBufferSize;
|
| + PropertyTypeTag_t unTag;
|
| + ETrackedPropertyError eError;
|
| + };
|
| +
|
| + struct PropertyRead_t
|
| + {
|
| + ETrackedDeviceProperty prop;
|
| + void *pvBuffer;
|
| + uint32_t unBufferSize;
|
| + PropertyTypeTag_t unTag;
|
| + uint32_t unRequiredBufferSize;
|
| + ETrackedPropertyError eError;
|
| + };
|
| +
|
| +
|
| +class IVRProperties
|
| +{
|
| +public:
|
| +
|
| + /** Reads a set of properties atomically. See the PropertyReadBatch_t struct for more information. */
|
| + virtual ETrackedPropertyError ReadPropertyBatch( PropertyContainerHandle_t ulContainerHandle, PropertyRead_t *pBatch, uint32_t unBatchEntryCount ) = 0;
|
| +
|
| + /** Writes a set of properties atomically. See the PropertyWriteBatch_t struct for more information. */
|
| + virtual ETrackedPropertyError WritePropertyBatch( PropertyContainerHandle_t ulContainerHandle, PropertyWrite_t *pBatch, uint32_t unBatchEntryCount ) = 0;
|
| +
|
| + /** 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 ) = 0;
|
| +
|
| + /** Returns a container handle given a tracked device index */
|
| + virtual PropertyContainerHandle_t TrackedDeviceToPropertyContainer( TrackedDeviceIndex_t nDevice ) = 0;
|
| +
|
| +};
|
| +
|
| +static const char * const IVRProperties_Version = "IVRProperties_001";
|
| +
|
| +class CVRPropertyHelpers
|
| +{
|
| +public:
|
| + CVRPropertyHelpers( IVRProperties * pProperties ) : m_pProperties( pProperties ) {}
|
| +
|
| + /** Returns a scaler property. If the device index is not valid or the property value type does not match,
|
| + * this function will return false. */
|
| + bool GetBoolProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
|
| + float GetFloatProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
|
| + int32_t GetInt32Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
|
| + uint64_t GetUint64Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
|
| +
|
| + /** Returns a single typed 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. */
|
| + uint32_t GetProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() void *pvBuffer, uint32_t unBufferSize, PropertyTypeTag_t *punTag, ETrackedPropertyError *pError = 0L );
|
| +
|
| +
|
| + /** 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. */
|
| + uint32_t GetStringProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L );
|
| +
|
| + /** Returns a string property as a std::string. If the device index is not valid or the property is not a string type this function will
|
| + * return an empty string. */
|
| + std::string GetStringProperty( vr::PropertyContainerHandle_t ulContainer, vr::ETrackedDeviceProperty prop, vr::ETrackedPropertyError *peError = nullptr );
|
| +
|
| + /** Sets a scaler property. The new value will be returned on any subsequent call to get this property in any process. */
|
| + ETrackedPropertyError SetBoolProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, bool bNewValue );
|
| + ETrackedPropertyError SetFloatProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, float fNewValue );
|
| + ETrackedPropertyError SetInt32Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, int32_t nNewValue );
|
| + ETrackedPropertyError SetUint64Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, uint64_t ulNewValue );
|
| +
|
| + /** Sets a string property. The new value will be returned on any subsequent call to get this property in any process. */
|
| + ETrackedPropertyError SetStringProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const char *pchNewValue );
|
| +
|
| + /** Sets a single typed property. The new value will be returned on any subsequent call to get this property in any process. */
|
| + ETrackedPropertyError SetProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, void *pvNewValue, uint32_t unNewValueSize, PropertyTypeTag_t unTag );
|
| +
|
| + /** Sets the error return value for a property. This value will be returned on all subsequent requests to get the property */
|
| + ETrackedPropertyError SetPropertyError( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError eError );
|
| +
|
| + /** Clears any value or error set for the property. */
|
| + ETrackedPropertyError EraseProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop );
|
| +
|
| + /* Turns a device index into a property container handle. */
|
| + PropertyContainerHandle_t TrackedDeviceToPropertyContainer( TrackedDeviceIndex_t nDevice ) { return m_pProperties->TrackedDeviceToPropertyContainer( nDevice ); }
|
| +
|
| +private:
|
| + template<typename T>
|
| + T GetPropertyHelper( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError, T bDefault, PropertyTypeTag_t unTypeTag );
|
| +
|
| + IVRProperties *m_pProperties;
|
| +};
|
| +
|
| +
|
| +inline uint32_t CVRPropertyHelpers::GetProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() void *pvBuffer, uint32_t unBufferSize, PropertyTypeTag_t *punTag, ETrackedPropertyError *pError )
|
| +{
|
| + PropertyRead_t batch;
|
| + batch.prop = prop;
|
| + batch.pvBuffer = pvBuffer;
|
| + batch.unBufferSize = unBufferSize;
|
| +
|
| + m_pProperties->ReadPropertyBatch( ulContainerHandle, &batch, 1 );
|
| +
|
| + if ( pError )
|
| + {
|
| + *pError = batch.eError;
|
| + }
|
| +
|
| + if ( punTag )
|
| + {
|
| + *punTag = batch.unTag;
|
| + }
|
| +
|
| + return batch.unRequiredBufferSize;
|
| +}
|
| +
|
| +
|
| +/** Sets a single typed property. The new value will be returned on any subsequent call to get this property in any process. */
|
| +inline ETrackedPropertyError CVRPropertyHelpers::SetProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, void *pvNewValue, uint32_t unNewValueSize, PropertyTypeTag_t unTag )
|
| +{
|
| + PropertyWrite_t batch;
|
| + batch.writeType = PropertyWrite_Set;
|
| + batch.prop = prop;
|
| + batch.pvBuffer = pvNewValue;
|
| + batch.unBufferSize = unNewValueSize;
|
| + batch.unTag = unTag;
|
| +
|
| + m_pProperties->WritePropertyBatch( ulContainerHandle, &batch, 1 );
|
| +
|
| + return batch.eError;
|
| +}
|
| +
|
| +
|
| +/** 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. */
|
| +inline uint32_t CVRPropertyHelpers::GetStringProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError )
|
| +{
|
| + PropertyTypeTag_t unTag;
|
| + ETrackedPropertyError error;
|
| + uint32_t unRequiredSize = GetProperty( ulContainerHandle, prop, pchValue, unBufferSize, &unTag, &error );
|
| + if ( unTag != k_unStringPropertyTag && error == TrackedProp_Success )
|
| + {
|
| + error = TrackedProp_WrongDataType;
|
| + }
|
| +
|
| + if ( pError )
|
| + {
|
| + *pError = error;
|
| + }
|
| +
|
| + if ( error != TrackedProp_Success )
|
| + {
|
| + if ( pchValue && unBufferSize )
|
| + {
|
| + *pchValue = '\0';
|
| + }
|
| + }
|
| +
|
| + return unRequiredSize;
|
| +}
|
| +
|
| +
|
| +/** Returns a string property as a std::string. If the device index is not valid or the property is not a string type this function will
|
| +* return an empty string. */
|
| +inline std::string CVRPropertyHelpers::GetStringProperty( vr::PropertyContainerHandle_t ulContainer, vr::ETrackedDeviceProperty prop, vr::ETrackedPropertyError *peError )
|
| +{
|
| + char buf[1024];
|
| + vr::ETrackedPropertyError err;
|
| + uint32_t unRequiredBufferLen = GetStringProperty( ulContainer, prop, buf, sizeof(buf), &err );
|
| +
|
| + std::string sResult;
|
| +
|
| + if ( err == TrackedProp_Success )
|
| + {
|
| + sResult = buf;
|
| + }
|
| + else if ( err == TrackedProp_BufferTooSmall )
|
| + {
|
| + char *pchBuffer = new char[unRequiredBufferLen];
|
| + unRequiredBufferLen = GetStringProperty( ulContainer, prop, pchBuffer, unRequiredBufferLen, &err );
|
| + sResult = pchBuffer;
|
| + delete[] pchBuffer;
|
| + }
|
| +
|
| + if ( peError )
|
| + {
|
| + *peError = err;
|
| + }
|
| +
|
| + return sResult;
|
| +}
|
| +
|
| +
|
| +/** Sets a string property. The new value will be returned on any subsequent call to get this property in any process. */
|
| +inline ETrackedPropertyError CVRPropertyHelpers::SetStringProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const char *pchNewValue )
|
| +{
|
| + if ( !pchNewValue )
|
| + return TrackedProp_InvalidOperation;
|
| +
|
| + // this is strlen without the dependency on string.h
|
| + const char *pchCurr = pchNewValue;
|
| + while ( *pchCurr )
|
| + {
|
| + pchCurr++;
|
| + }
|
| +
|
| + return SetProperty( ulContainerHandle, prop, (void *)pchNewValue, (uint32_t)(pchCurr - pchNewValue) + 1, k_unStringPropertyTag );
|
| +}
|
| +
|
| +
|
| +template<typename T>
|
| +inline T CVRPropertyHelpers::GetPropertyHelper( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError, T bDefault, PropertyTypeTag_t unTypeTag )
|
| +{
|
| + T bValue;
|
| + ETrackedPropertyError eError;
|
| + PropertyTypeTag_t unReadTag;
|
| + GetProperty( ulContainerHandle, prop, &bValue, sizeof( bValue ), &unReadTag, &eError );
|
| + if ( unReadTag != unTypeTag && eError == TrackedProp_Success )
|
| + {
|
| + eError = TrackedProp_WrongDataType;
|
| + };
|
| +
|
| + if ( pError )
|
| + *pError = eError;
|
| + if ( eError != TrackedProp_Success )
|
| + {
|
| + return bDefault;
|
| + }
|
| + else
|
| + {
|
| + return bValue;
|
| + }
|
| +}
|
| +
|
| +
|
| +inline bool CVRPropertyHelpers::GetBoolProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
|
| +{
|
| + return GetPropertyHelper<bool>( ulContainerHandle, prop, pError, false, k_unBoolPropertyTag );
|
| +}
|
| +
|
| +
|
| +inline float CVRPropertyHelpers::GetFloatProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
|
| +{
|
| + return GetPropertyHelper<float>( ulContainerHandle, prop, pError, 0.f, k_unFloatPropertyTag );
|
| +}
|
| +
|
| +inline int32_t CVRPropertyHelpers::GetInt32Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
|
| +{
|
| + return GetPropertyHelper<int32_t>( ulContainerHandle, prop, pError, 0, k_unInt32PropertyTag );
|
| +}
|
| +
|
| +inline uint64_t CVRPropertyHelpers::GetUint64Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
|
| +{
|
| + return GetPropertyHelper<uint64_t>( ulContainerHandle, prop, pError, 0, k_unUint64PropertyTag );
|
| +}
|
| +
|
| +inline ETrackedPropertyError CVRPropertyHelpers::SetBoolProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, bool bNewValue )
|
| +{
|
| + return SetProperty( ulContainerHandle, prop, &bNewValue, sizeof( bNewValue ), k_unBoolPropertyTag );
|
| +}
|
| +
|
| +inline ETrackedPropertyError CVRPropertyHelpers::SetFloatProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, float fNewValue )
|
| +{
|
| + return SetProperty( ulContainerHandle, prop, &fNewValue, sizeof( fNewValue ), k_unFloatPropertyTag );
|
| +}
|
| +
|
| +inline ETrackedPropertyError CVRPropertyHelpers::SetInt32Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, int32_t nNewValue )
|
| +{
|
| + return SetProperty( ulContainerHandle, prop, &nNewValue, sizeof( nNewValue ), k_unInt32PropertyTag );
|
| +}
|
| +
|
| +inline ETrackedPropertyError CVRPropertyHelpers::SetUint64Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, uint64_t ulNewValue )
|
| +{
|
| + return SetProperty( ulContainerHandle, prop, &ulNewValue, sizeof( ulNewValue ), k_unUint64PropertyTag );
|
| +}
|
| +
|
| +/** Sets the error return value for a property. This value will be returned on all subsequent requests to get the property */
|
| +inline ETrackedPropertyError CVRPropertyHelpers::SetPropertyError( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError eError )
|
| +{
|
| + PropertyWrite_t batch;
|
| + batch.writeType = PropertyWrite_SetError;
|
| + batch.prop = prop;
|
| + batch.eSetError = eError;
|
| +
|
| + m_pProperties->WritePropertyBatch( ulContainerHandle, &batch, 1 );
|
| +
|
| + return batch.eError;
|
| +}
|
| +
|
| +/** Clears any value or error set for the property. */
|
| +inline ETrackedPropertyError CVRPropertyHelpers::EraseProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop )
|
| +{
|
| + PropertyWrite_t batch;
|
| + batch.writeType = PropertyWrite_Erase;
|
| + batch.prop = prop;
|
| +
|
| + m_pProperties->WritePropertyBatch( ulContainerHandle, &batch, 1 );
|
| +
|
| + return batch.eError;
|
| +
|
| +}
|
| +
|
| +}
|
| +
|
| +
|
| +// ivrdriverlog.h
|
| +namespace vr
|
| +{
|
| +
|
| +class IVRDriverLog
|
| +{
|
| +public:
|
| + /** Writes a log message to the log file prefixed with the driver name */
|
| + virtual void Log( const char *pchLogMessage ) = 0;
|
| +};
|
| +
|
| +
|
| +static const char *IVRDriverLog_Version = "IVRDriverLog_001";
|
| +
|
| +}
|
| +// ivrserverdriverhost.h
|
| +namespace vr
|
| +{
|
| +
|
| +class ITrackedDeviceServerDriver;
|
| +struct TrackedDeviceDriverInfo_t;
|
| +struct DriverPose_t;
|
| +
|
| +/** This interface is provided by vrserver to allow the driver to notify
|
| +* the system when something changes about a device. These changes must
|
| +* not change the serial number or class of the device because those values
|
| +* are permanently associated with the device's index. */
|
| +class IVRServerDriverHost
|
| +{
|
| +public:
|
| + /** Notifies the server that a tracked device has been added. If this function returns true
|
| + * the server will call Activate on the device. If it returns false some kind of error
|
| + * has occurred and the device will not be activated. */
|
| + virtual bool TrackedDeviceAdded( const char *pchDeviceSerialNumber, ETrackedDeviceClass eDeviceClass, ITrackedDeviceServerDriver *pDriver ) = 0;
|
| +
|
| + /** Notifies the server that a tracked device's pose has been updated */
|
| + virtual void TrackedDevicePoseUpdated( uint32_t unWhichDevice, const DriverPose_t & newPose, uint32_t unPoseStructSize ) = 0;
|
| +
|
| + /** Notifies the server that vsync has occurred on the the display attached to the device. This is
|
| + * only permitted on devices of the HMD class. */
|
| + virtual void VsyncEvent( double vsyncTimeOffsetSeconds ) = 0;
|
| +
|
| + /** notifies the server that the button was pressed */
|
| + virtual void TrackedDeviceButtonPressed( uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset ) = 0;
|
| +
|
| + /** notifies the server that the button was unpressed */
|
| + virtual void TrackedDeviceButtonUnpressed( uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset ) = 0;
|
| +
|
| + /** notifies the server that the button was pressed */
|
| + virtual void TrackedDeviceButtonTouched( uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset ) = 0;
|
| +
|
| + /** notifies the server that the button was unpressed */
|
| + virtual void TrackedDeviceButtonUntouched( uint32_t unWhichDevice, EVRButtonId eButtonId, double eventTimeOffset ) = 0;
|
| +
|
| + /** notifies the server than a controller axis changed */
|
| + virtual void TrackedDeviceAxisUpdated( uint32_t unWhichDevice, uint32_t unWhichAxis, const VRControllerAxis_t & axisState ) = 0;
|
| +
|
| + /** Notifies the server that the proximity sensor on the specified device */
|
| + virtual void ProximitySensorState( uint32_t unWhichDevice, bool bProximitySensorTriggered ) = 0;
|
| +
|
| + /** Sends a vendor specific event (VREvent_VendorSpecific_Reserved_Start..VREvent_VendorSpecific_Reserved_End */
|
| + virtual void VendorSpecificEvent( uint32_t unWhichDevice, vr::EVREventType eventType, const VREvent_Data_t & eventData, double eventTimeOffset ) = 0;
|
| +
|
| + /** Returns true if SteamVR is exiting */
|
| + virtual bool IsExiting() = 0;
|
| +
|
| + /** 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 ) = 0;
|
| +};
|
| +
|
| +static const char *IVRServerDriverHost_Version = "IVRServerDriverHost_004";
|
| +
|
| +}
|
| +// ivrhiddenarea.h
|
| +namespace vr
|
| +{
|
| +
|
| +class CVRHiddenAreaHelpers
|
| +{
|
| +public:
|
| + CVRHiddenAreaHelpers( IVRProperties *pProperties ) : m_pProperties( pProperties ) {}
|
| +
|
| + /** Stores a hidden area mesh in a property */
|
| + ETrackedPropertyError SetHiddenArea( EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount );
|
| +
|
| + /** retrieves a hidden area mesh from a property. Returns the vert count read out of the property. */
|
| + uint32_t GetHiddenArea( EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount, ETrackedPropertyError *peError );
|
| +
|
| +private:
|
| + ETrackedDeviceProperty GetPropertyEnum( EVREye eEye, EHiddenAreaMeshType type )
|
| + {
|
| + return (ETrackedDeviceProperty)(Prop_DisplayHiddenArea_Binary_Start + ((int)type * 2) + (int)eEye);
|
| + }
|
| +
|
| + IVRProperties *m_pProperties;
|
| +};
|
| +
|
| +
|
| +inline ETrackedPropertyError CVRHiddenAreaHelpers::SetHiddenArea( EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount )
|
| +{
|
| + ETrackedDeviceProperty prop = GetPropertyEnum( eEye, type );
|
| + CVRPropertyHelpers propHelpers( m_pProperties );
|
| + return propHelpers.SetProperty( propHelpers.TrackedDeviceToPropertyContainer( k_unTrackedDeviceIndex_Hmd ), prop, pVerts, sizeof( HmdVector2_t ) * unVertCount, k_unHiddenAreaPropertyTag );
|
| +}
|
| +
|
| +
|
| +inline uint32_t CVRHiddenAreaHelpers::GetHiddenArea( EVREye eEye, EHiddenAreaMeshType type, HmdVector2_t *pVerts, uint32_t unVertCount, ETrackedPropertyError *peError )
|
| +{
|
| + ETrackedDeviceProperty prop = GetPropertyEnum( eEye, type );
|
| + CVRPropertyHelpers propHelpers( m_pProperties );
|
| + ETrackedPropertyError propError;
|
| + PropertyTypeTag_t unTag;
|
| + uint32_t unBytesNeeded = propHelpers.GetProperty( propHelpers.TrackedDeviceToPropertyContainer( k_unTrackedDeviceIndex_Hmd ), prop, pVerts, sizeof( HmdVector2_t )*unVertCount, &unTag, &propError );
|
| + if ( propError == TrackedProp_Success && unTag != k_unHiddenAreaPropertyTag )
|
| + {
|
| + propError = TrackedProp_WrongDataType;
|
| + unBytesNeeded = 0;
|
| + }
|
| +
|
| + if ( peError )
|
| + {
|
| + *peError = propError;
|
| + }
|
| +
|
| + return unBytesNeeded / sizeof( HmdVector2_t );
|
| +}
|
| +
|
| +}
|
| +// ivrwatchdoghost.h
|
| +namespace vr
|
| +{
|
| +
|
| +/** This interface is provided by vrclient to allow the driver to make everything wake up */
|
| +class IVRWatchdogHost
|
| +{
|
| +public:
|
| + /** Client drivers in watchdog mode should call this when they have received a signal from hardware that should
|
| + * cause SteamVR to start */
|
| + virtual void WatchdogWakeUp() = 0;
|
| +};
|
| +
|
| +static const char *IVRWatchdogHost_Version = "IVRWatchdogHost_001";
|
| +
|
| +};
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +
|
| +namespace vr
|
| +{
|
| + static const char * const k_InterfaceVersions[] =
|
| + {
|
| + IVRSettings_Version,
|
| + ITrackedDeviceServerDriver_Version,
|
| + IVRDisplayComponent_Version,
|
| + IVRDriverDirectModeComponent_Version,
|
| + IVRControllerComponent_Version,
|
| + IVRCameraComponent_Version,
|
| + IServerTrackedDeviceProvider_Version,
|
| + IVRWatchdogProvider_Version,
|
| + nullptr
|
| + };
|
| +
|
| + inline IVRDriverContext *&VRDriverContext()
|
| + {
|
| + static IVRDriverContext *pHost;
|
| + return pHost;
|
| + }
|
| +
|
| + class COpenVRDriverContext
|
| + {
|
| + public:
|
| + COpenVRDriverContext() : m_propertyHelpers(nullptr), m_hiddenAreaHelpers(nullptr) { Clear(); }
|
| + void Clear();
|
| +
|
| + EVRInitError InitServer();
|
| + EVRInitError InitWatchdog();
|
| +
|
| + IVRSettings *VRSettings()
|
| + {
|
| + if ( m_pVRSettings == nullptr )
|
| + {
|
| + EVRInitError eError;
|
| + m_pVRSettings = (IVRSettings *)VRDriverContext()->GetGenericInterface( IVRSettings_Version, &eError );
|
| + }
|
| + return m_pVRSettings;
|
| + }
|
| +
|
| + IVRProperties *VRPropertiesRaw()
|
| + {
|
| + if ( m_pVRProperties == nullptr )
|
| + {
|
| + EVRInitError eError;
|
| + m_pVRProperties = (IVRProperties *)VRDriverContext()->GetGenericInterface( IVRProperties_Version, &eError );
|
| + m_propertyHelpers = CVRPropertyHelpers( m_pVRProperties );
|
| + m_hiddenAreaHelpers = CVRHiddenAreaHelpers( m_pVRProperties );
|
| + }
|
| + return m_pVRProperties;
|
| + }
|
| +
|
| + CVRPropertyHelpers *VRProperties()
|
| + {
|
| + VRPropertiesRaw();
|
| + return &m_propertyHelpers;
|
| + }
|
| +
|
| + CVRHiddenAreaHelpers *VRHiddenArea()
|
| + {
|
| + VRPropertiesRaw();
|
| + return &m_hiddenAreaHelpers;
|
| + }
|
| +
|
| + IVRServerDriverHost *VRServerDriverHost()
|
| + {
|
| + if ( m_pVRServerDriverHost == nullptr )
|
| + {
|
| + EVRInitError eError;
|
| + m_pVRServerDriverHost = (IVRServerDriverHost *)VRDriverContext()->GetGenericInterface( IVRServerDriverHost_Version, &eError );
|
| + }
|
| + return m_pVRServerDriverHost;
|
| + }
|
| +
|
| + IVRWatchdogHost *VRWatchdogHost()
|
| + {
|
| + if ( m_pVRWatchdogHost == nullptr )
|
| + {
|
| + EVRInitError eError;
|
| + m_pVRWatchdogHost = (IVRWatchdogHost *)VRDriverContext()->GetGenericInterface( IVRWatchdogHost_Version, &eError );
|
| + }
|
| + return m_pVRWatchdogHost;
|
| + }
|
| +
|
| + IVRDriverLog *VRDriverLog()
|
| + {
|
| + if ( m_pVRDriverLog == nullptr )
|
| + {
|
| + EVRInitError eError;
|
| + m_pVRDriverLog = (IVRDriverLog *)VRDriverContext()->GetGenericInterface( IVRDriverLog_Version, &eError );
|
| + }
|
| + return m_pVRDriverLog;
|
| + }
|
| +
|
| + DriverHandle_t VR_CALLTYPE VRDriverHandle()
|
| + {
|
| + return VRDriverContext()->GetDriverHandle();
|
| + }
|
| +
|
| + private:
|
| + IVRSettings *m_pVRSettings;
|
| + IVRProperties *m_pVRProperties;
|
| + CVRPropertyHelpers m_propertyHelpers;
|
| + CVRHiddenAreaHelpers m_hiddenAreaHelpers;
|
| + IVRServerDriverHost *m_pVRServerDriverHost;
|
| + IVRWatchdogHost *m_pVRWatchdogHost;
|
| + IVRDriverLog *m_pVRDriverLog;
|
| + };
|
| +
|
| + inline COpenVRDriverContext &OpenVRInternal_ModuleServerDriverContext()
|
| + {
|
| + static void *ctx[sizeof( COpenVRDriverContext ) / sizeof( void * )];
|
| + return *(COpenVRDriverContext *)ctx; // bypass zero-init constructor
|
| + }
|
| +
|
| + inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleServerDriverContext().VRSettings(); }
|
| + inline IVRProperties *VR_CALLTYPE VRPropertiesRaw() { return OpenVRInternal_ModuleServerDriverContext().VRPropertiesRaw(); }
|
| + inline CVRPropertyHelpers *VR_CALLTYPE VRProperties() { return OpenVRInternal_ModuleServerDriverContext().VRProperties(); }
|
| + inline CVRHiddenAreaHelpers *VR_CALLTYPE VRHiddenArea() { return OpenVRInternal_ModuleServerDriverContext().VRHiddenArea(); }
|
| + inline IVRDriverLog *VR_CALLTYPE VRDriverLog() { return OpenVRInternal_ModuleServerDriverContext().VRDriverLog(); }
|
| + inline IVRServerDriverHost *VR_CALLTYPE VRServerDriverHost() { return OpenVRInternal_ModuleServerDriverContext().VRServerDriverHost(); }
|
| + inline IVRWatchdogHost *VR_CALLTYPE VRWatchdogHost() { return OpenVRInternal_ModuleServerDriverContext().VRWatchdogHost(); }
|
| + inline DriverHandle_t VR_CALLTYPE VRDriverHandle() { return OpenVRInternal_ModuleServerDriverContext().VRDriverHandle(); }
|
| + inline void COpenVRDriverContext::Clear()
|
| + {
|
| + m_pVRSettings = nullptr;
|
| + m_pVRProperties = nullptr;
|
| + m_pVRServerDriverHost = nullptr;
|
| + m_pVRDriverLog = nullptr;
|
| + m_pVRWatchdogHost = nullptr;
|
| + }
|
| +
|
| + inline EVRInitError COpenVRDriverContext::InitServer()
|
| + {
|
| + Clear();
|
| + if ( !VRServerDriverHost()
|
| + || !VRSettings()
|
| + || !VRProperties()
|
| + || !VRDriverLog() )
|
| + return VRInitError_Init_InterfaceNotFound;
|
| + return VRInitError_None;
|
| + }
|
| +
|
| + inline EVRInitError COpenVRDriverContext::InitWatchdog()
|
| + {
|
| + Clear();
|
| + if ( !VRWatchdogHost()
|
| + || !VRSettings()
|
| + || !VRDriverLog() )
|
| + return VRInitError_Init_InterfaceNotFound;
|
| + return VRInitError_None;
|
| + }
|
| +
|
| + inline EVRInitError InitServerDriverContext( IVRDriverContext *pContext )
|
| + {
|
| + VRDriverContext() = pContext;
|
| + return OpenVRInternal_ModuleServerDriverContext().InitServer();
|
| + }
|
| +
|
| + inline EVRInitError InitWatchdogDriverContext( IVRDriverContext *pContext )
|
| + {
|
| + VRDriverContext() = pContext;
|
| + return OpenVRInternal_ModuleServerDriverContext().InitWatchdog();
|
| + }
|
| +
|
| + inline void CleanupDriverContext()
|
| + {
|
| + VRDriverContext() = nullptr;
|
| + OpenVRInternal_ModuleServerDriverContext().Clear();
|
| + }
|
| +
|
| + #define VR_INIT_SERVER_DRIVER_CONTEXT( pContext ) \
|
| + { \
|
| + vr::EVRInitError eError = vr::InitServerDriverContext( pContext ); \
|
| + if( eError != vr::VRInitError_None ) \
|
| + return eError; \
|
| + }
|
| +
|
| + #define VR_CLEANUP_SERVER_DRIVER_CONTEXT() \
|
| + vr::CleanupDriverContext();
|
| +
|
| + #define VR_INIT_WATCHDOG_DRIVER_CONTEXT( pContext ) \
|
| + { \
|
| + vr::EVRInitError eError = vr::InitWatchdogDriverContext( pContext ); \
|
| + if( eError != vr::VRInitError_None ) \
|
| + return eError; \
|
| + }
|
| +
|
| + #define VR_CLEANUP_WATCHDOG_DRIVER_CONTEXT() \
|
| + vr::CleanupDriverContext();
|
| +}
|
| +// End
|
| +
|
| +#endif // _OPENVR_DRIVER_API
|
| +
|
| +
|
|
|
Chromium Code Reviews
Issue 2754253003:
Add OpenVR SDK to third_party (Closed)
