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 |
+ |
+ |