#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 // 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_ 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 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 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 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( ulContainerHandle, prop, pError, false, k_unBoolPropertyTag ); } inline float CVRPropertyHelpers::GetFloatProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError ) { return GetPropertyHelper( ulContainerHandle, prop, pError, 0.f, k_unFloatPropertyTag ); } inline int32_t CVRPropertyHelpers::GetInt32Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError ) { return GetPropertyHelper( ulContainerHandle, prop, pError, 0, k_unInt32PropertyTag ); } inline uint64_t CVRPropertyHelpers::GetUint64Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError ) { return GetPropertyHelper( 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