[CMake] Use target oriented design for bmalloc
[WebKit-https.git] / Source / ThirdParty / openvr / headers / openvr.h
1 #pragma once
2
3 // openvr.h
4 //========= Copyright Valve Corporation ============//
5 // Dynamically generated file. Do not modify this file directly.
6
7 #ifndef _OPENVR_API
8 #define _OPENVR_API
9
10 #include <stdint.h>
11
12
13
14 // vrtypes.h
15 #ifndef _INCLUDE_VRTYPES_H
16 #define _INCLUDE_VRTYPES_H
17
18 // Forward declarations to avoid requiring vulkan.h
19 struct VkDevice_T;
20 struct VkPhysicalDevice_T;
21 struct VkInstance_T;
22 struct VkQueue_T;
23
24 // Forward declarations to avoid requiring d3d12.h
25 struct ID3D12Resource;
26 struct ID3D12CommandQueue;
27
28 namespace vr
29 {
30 #pragma pack( push, 8 )
31
32 typedef void* glSharedTextureHandle_t;
33 typedef int32_t glInt_t;
34 typedef uint32_t glUInt_t;
35
36 // right-handed system
37 // +y is up
38 // +x is to the right
39 // -z is going away from you
40 // Distance unit is  meters
41 struct HmdMatrix34_t
42 {
43        float m[3][4];
44 };
45
46 struct HmdMatrix44_t
47 {
48        float m[4][4];
49 };
50
51 struct HmdVector3_t
52 {
53        float v[3];
54 };
55
56 struct HmdVector4_t
57 {
58        float v[4];
59 };
60
61 struct HmdVector3d_t
62 {
63        double v[3];
64 };
65
66 struct HmdVector2_t
67 {
68        float v[2];
69 };
70
71 struct HmdQuaternion_t
72 {
73        double w, x, y, z;
74 };
75
76 struct HmdColor_t
77 {
78        float r, g, b, a;
79 };
80
81 struct HmdQuad_t
82 {
83        HmdVector3_t vCorners[ 4 ];
84 };
85
86 struct HmdRect2_t
87 {
88        HmdVector2_t vTopLeft;
89        HmdVector2_t vBottomRight;
90 };
91
92 /** Used to return the post-distortion UVs for each color channel. 
93 * UVs range from 0 to 1 with 0,0 in the upper left corner of the 
94 * source render target. The 0,0 to 1,1 range covers a single eye. */
95 struct DistortionCoordinates_t
96 {
97        float rfRed[2];
98        float rfGreen[2];
99        float rfBlue[2];
100 };
101
102 enum EVREye
103 {
104        Eye_Left = 0,
105        Eye_Right = 1
106 };
107
108 enum ETextureType
109 {
110        TextureType_DirectX = 0, // Handle is an ID3D11Texture
111        TextureType_OpenGL = 1,  // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
112        TextureType_Vulkan = 2, // Handle is a pointer to a VRVulkanTextureData_t structure
113        TextureType_IOSurface = 3, // Handle is a macOS cross-process-sharable IOSurfaceRef
114        TextureType_DirectX12 = 4, // Handle is a pointer to a D3D12TextureData_t structure
115 };
116
117 enum EColorSpace
118 {
119        ColorSpace_Auto = 0,       // Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
120        ColorSpace_Gamma = 1,       // Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
121        ColorSpace_Linear = 2,       // Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
122 };
123
124 struct Texture_t
125 {
126        void* handle; // See ETextureType definition above
127        ETextureType eType;
128        EColorSpace eColorSpace;
129 };
130
131 // Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
132 typedef uint64_t SharedTextureHandle_t;
133 #define INVALID_SHARED_TEXTURE_HANDLE       ((vr::SharedTextureHandle_t)0)
134
135 enum ETrackingResult
136 {
137        TrackingResult_Uninitialized                     = 1,
138
139        TrackingResult_Calibrating_InProgress       = 100,
140        TrackingResult_Calibrating_OutOfRange       = 101,
141
142        TrackingResult_Running_OK                            = 200,
143        TrackingResult_Running_OutOfRange              = 201,
144 };
145
146 typedef uint32_t DriverId_t;
147 static const uint32_t k_nDriverNone = 0xFFFFFFFF;
148
149 static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
150
151 /** Used to pass device IDs to API calls */
152 typedef uint32_t TrackedDeviceIndex_t;
153 static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
154 static const uint32_t k_unMaxTrackedDeviceCount = 16;
155 static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
156 static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
157
158 /** Describes what kind of object is being tracked at a given ID */
159 enum ETrackedDeviceClass
160 {
161        TrackedDeviceClass_Invalid = 0,                            // the ID was not valid.
162        TrackedDeviceClass_HMD = 1,                                   // Head-Mounted Displays
163        TrackedDeviceClass_Controller = 2,                     // Tracked controllers
164        TrackedDeviceClass_GenericTracker = 3,              // Generic trackers, similar to controllers
165        TrackedDeviceClass_TrackingReference = 4,       // Camera and base stations that serve as tracking reference points
166        TrackedDeviceClass_DisplayRedirect = 5,              // Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
167 };
168
169
170 /** Describes what specific role associated with a tracked device */
171 enum ETrackedControllerRole
172 {
173        TrackedControllerRole_Invalid = 0,                                   // Invalid value for controller type
174        TrackedControllerRole_LeftHand = 1,                                   // Tracked device associated with the left hand
175        TrackedControllerRole_RightHand = 2,                            // Tracked device associated with the right hand
176 };
177
178
179 /** describes a single pose for a tracked object */
180 struct TrackedDevicePose_t
181 {
182        HmdMatrix34_t mDeviceToAbsoluteTracking;
183        HmdVector3_t vVelocity;                            // velocity in tracker space in m/s
184        HmdVector3_t vAngularVelocity;              // angular velocity in radians/s (?)
185        ETrackingResult eTrackingResult;
186        bool bPoseIsValid;
187
188        // This indicates that there is a device connected for this spot in the pose array.
189        // It could go from true to false if the user unplugs the device.
190        bool bDeviceIsConnected;
191 };
192
193 /** Identifies which style of tracking origin the application wants to use
194 * for the poses it is requesting */
195 enum ETrackingUniverseOrigin
196 {
197        TrackingUniverseSeated = 0,              // Poses are provided relative to the seated zero pose
198        TrackingUniverseStanding = 1,       // Poses are provided relative to the safe bounds configured by the user
199        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.
200 };
201
202 // Refers to a single container of properties
203 typedef uint64_t PropertyContainerHandle_t;
204 typedef uint32_t PropertyTypeTag_t;
205
206 static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
207 static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
208
209 // Use these tags to set/get common types as struct properties
210 static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
211 static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
212 static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
213 static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
214 static const PropertyTypeTag_t k_unStringPropertyTag = 5;
215
216 static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
217 static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
218 static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
219 static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
220
221 static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
222
223 static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
224 static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
225
226
227 /** Each entry in this enum represents a property that can be retrieved about a
228 * tracked device. Many fields are only valid for one ETrackedDeviceClass. */
229 enum ETrackedDeviceProperty
230 {
231        Prop_Invalid                                                        = 0,
232
233        // general properties that apply to all device classes
234        Prop_TrackingSystemName_String                            = 1000,
235        Prop_ModelNumber_String                                          = 1001,
236        Prop_SerialNumber_String                                   = 1002,
237        Prop_RenderModelName_String                                   = 1003,
238        Prop_WillDriftInYaw_Bool                                   = 1004,
239        Prop_ManufacturerName_String                            = 1005,
240        Prop_TrackingFirmwareVersion_String                     = 1006,
241        Prop_HardwareRevision_String                            = 1007,
242        Prop_AllWirelessDongleDescriptions_String       = 1008,
243        Prop_ConnectedWirelessDongle_String                     = 1009,
244        Prop_DeviceIsWireless_Bool                                   = 1010,
245        Prop_DeviceIsCharging_Bool                                   = 1011,
246        Prop_DeviceBatteryPercentage_Float                     = 1012, // 0 is empty, 1 is full
247        Prop_StatusDisplayTransform_Matrix34              = 1013,
248        Prop_Firmware_UpdateAvailable_Bool                     = 1014,
249        Prop_Firmware_ManualUpdate_Bool                            = 1015,
250        Prop_Firmware_ManualUpdateURL_String              = 1016,
251        Prop_HardwareRevision_Uint64                            = 1017,
252        Prop_FirmwareVersion_Uint64                                   = 1018,
253        Prop_FPGAVersion_Uint64                                          = 1019,
254        Prop_VRCVersion_Uint64                                          = 1020,
255        Prop_RadioVersion_Uint64                                   = 1021,
256        Prop_DongleVersion_Uint64                                   = 1022,
257        Prop_BlockServerShutdown_Bool                            = 1023,
258        Prop_CanUnifyCoordinateSystemWithHmd_Bool       = 1024,
259        Prop_ContainsProximitySensor_Bool                     = 1025,
260        Prop_DeviceProvidesBatteryStatus_Bool              = 1026,
261        Prop_DeviceCanPowerOff_Bool                                   = 1027,
262        Prop_Firmware_ProgrammingTarget_String              = 1028,
263        Prop_DeviceClass_Int32                                          = 1029,
264        Prop_HasCamera_Bool                                                 = 1030,
265        Prop_DriverVersion_String                   = 1031,
266        Prop_Firmware_ForceUpdateRequired_Bool      = 1032,
267        Prop_ViveSystemButtonFixRequired_Bool              = 1033,
268        Prop_ParentDriver_Uint64                                   = 1034,
269        Prop_ResourceRoot_String                                   = 1035,
270
271        // Properties that are unique to TrackedDeviceClass_HMD
272        Prop_ReportsTimeSinceVSync_Bool                            = 2000,
273        Prop_SecondsFromVsyncToPhotons_Float              = 2001,
274        Prop_DisplayFrequency_Float                                   = 2002,
275        Prop_UserIpdMeters_Float                                   = 2003,
276        Prop_CurrentUniverseId_Uint64                            = 2004, 
277        Prop_PreviousUniverseId_Uint64                            = 2005, 
278        Prop_DisplayFirmwareVersion_Uint64                     = 2006,
279        Prop_IsOnDesktop_Bool                                          = 2007,
280        Prop_DisplayMCType_Int32                                   = 2008,
281        Prop_DisplayMCOffset_Float                                   = 2009,
282        Prop_DisplayMCScale_Float                                   = 2010,
283        Prop_EdidVendorID_Int32                                          = 2011,
284        Prop_DisplayMCImageLeft_String              = 2012,
285        Prop_DisplayMCImageRight_String             = 2013,
286        Prop_DisplayGCBlackClamp_Float                            = 2014,
287        Prop_EdidProductID_Int32                                   = 2015,
288        Prop_CameraToHeadTransform_Matrix34                     = 2016,
289        Prop_DisplayGCType_Int32                                   = 2017,
290        Prop_DisplayGCOffset_Float                                   = 2018,
291        Prop_DisplayGCScale_Float                                   = 2019,
292        Prop_DisplayGCPrescale_Float                            = 2020,
293        Prop_DisplayGCImage_String                                   = 2021,
294        Prop_LensCenterLeftU_Float                                   = 2022,
295        Prop_LensCenterLeftV_Float                                   = 2023,
296        Prop_LensCenterRightU_Float                                   = 2024,
297        Prop_LensCenterRightV_Float                                   = 2025,
298        Prop_UserHeadToEyeDepthMeters_Float                     = 2026,
299        Prop_CameraFirmwareVersion_Uint64                     = 2027,
300        Prop_CameraFirmwareDescription_String              = 2028,
301        Prop_DisplayFPGAVersion_Uint64                            = 2029,
302        Prop_DisplayBootloaderVersion_Uint64              = 2030,
303        Prop_DisplayHardwareVersion_Uint64                     = 2031,
304        Prop_AudioFirmwareVersion_Uint64                     = 2032,
305        Prop_CameraCompatibilityMode_Int32                     = 2033,
306        Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
307        Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
308        Prop_DisplaySuppressed_Bool                                   = 2036,
309        Prop_DisplayAllowNightMode_Bool                            = 2037,
310        Prop_DisplayMCImageWidth_Int32                            = 2038,
311        Prop_DisplayMCImageHeight_Int32                            = 2039,
312        Prop_DisplayMCImageNumChannels_Int32              = 2040,
313        Prop_DisplayMCImageData_Binary                            = 2041,
314        Prop_SecondsFromPhotonsToVblank_Float              = 2042,
315        Prop_DriverDirectModeSendsVsyncEvents_Bool       = 2043,
316        Prop_DisplayDebugMode_Bool                                   = 2044,
317        Prop_GraphicsAdapterLuid_Uint64                            = 2045,
318        Prop_DriverProvidedChaperonePath_String              = 2048,
319
320        // Properties that are unique to TrackedDeviceClass_Controller
321        Prop_AttachedDeviceId_String                            = 3000,
322        Prop_SupportedButtons_Uint64                            = 3001,
323        Prop_Axis0Type_Int32                                          = 3002, // Return value is of type EVRControllerAxisType
324        Prop_Axis1Type_Int32                                          = 3003, // Return value is of type EVRControllerAxisType
325        Prop_Axis2Type_Int32                                          = 3004, // Return value is of type EVRControllerAxisType
326        Prop_Axis3Type_Int32                                          = 3005, // Return value is of type EVRControllerAxisType
327        Prop_Axis4Type_Int32                                          = 3006, // Return value is of type EVRControllerAxisType
328        Prop_ControllerRoleHint_Int32                            = 3007, // Return value is of type ETrackedControllerRole
329
330        // Properties that are unique to TrackedDeviceClass_TrackingReference
331        Prop_FieldOfViewLeftDegrees_Float                     = 4000,
332        Prop_FieldOfViewRightDegrees_Float                     = 4001,
333        Prop_FieldOfViewTopDegrees_Float                     = 4002,
334        Prop_FieldOfViewBottomDegrees_Float                     = 4003,
335        Prop_TrackingRangeMinimumMeters_Float              = 4004,
336        Prop_TrackingRangeMaximumMeters_Float              = 4005,
337        Prop_ModeLabel_String                                          = 4006,
338
339        // Properties that are used for user interface like icons names
340        Prop_IconPathName_String                                          = 5000, // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
341        Prop_NamedIconPathDeviceOff_String                            = 5001, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
342        Prop_NamedIconPathDeviceSearching_String              = 5002, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
343        Prop_NamedIconPathDeviceSearchingAlert_String       = 5003, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
344        Prop_NamedIconPathDeviceReady_String                     = 5004, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
345        Prop_NamedIconPathDeviceReadyAlert_String              = 5005, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
346        Prop_NamedIconPathDeviceNotReady_String                     = 5006, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
347        Prop_NamedIconPathDeviceStandby_String                     = 5007, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
348        Prop_NamedIconPathDeviceAlertLow_String                     = 5008, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
349
350        // Properties that are used by helpers, but are opaque to applications
351        Prop_DisplayHiddenArea_Binary_Start                            = 5100,
352        Prop_DisplayHiddenArea_Binary_End                            = 5150,
353
354        // Properties that are unique to drivers
355        Prop_UserConfigPath_String                                   = 6000,
356        Prop_InstallPath_String                                          = 6001,
357        Prop_HasDisplayComponent_Bool                            = 6002,
358        Prop_HasControllerComponent_Bool                     = 6003,
359        Prop_HasCameraComponent_Bool                            = 6004,
360        Prop_HasDriverDirectModeComponent_Bool              = 6005,
361        Prop_HasVirtualDisplayComponent_Bool              = 6006,
362
363        // Vendors are free to expose private debug data in this reserved region
364        Prop_VendorSpecific_Reserved_Start                     = 10000,
365        Prop_VendorSpecific_Reserved_End                     = 10999,
366 };
367
368 /** No string property will ever be longer than this length */
369 static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
370
371 /** Used to return errors that occur when reading properties. */
372 enum ETrackedPropertyError
373 {
374        TrackedProp_Success                                          = 0,
375        TrackedProp_WrongDataType                            = 1,
376        TrackedProp_WrongDeviceClass                     = 2,
377        TrackedProp_BufferTooSmall                            = 3,
378        TrackedProp_UnknownProperty                            = 4, // Driver has not set the property (and may not ever).
379        TrackedProp_InvalidDevice                            = 5,
380        TrackedProp_CouldNotContactServer              = 6,
381        TrackedProp_ValueNotProvidedByDevice       = 7,
382        TrackedProp_StringExceedsMaximumLength       = 8,
383        TrackedProp_NotYetAvailable                            = 9, // The property value isn't known yet, but is expected soon. Call again later.
384        TrackedProp_PermissionDenied                     = 10,
385        TrackedProp_InvalidOperation                     = 11,
386 };
387
388 /** Allows the application to control what part of the provided texture will be used in the
389 * frame buffer. */
390 struct VRTextureBounds_t
391 {
392        float uMin, vMin;
393        float uMax, vMax;
394 };
395
396 /** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
397 struct VRTextureWithPose_t : public Texture_t
398 {
399        HmdMatrix34_t mDeviceToAbsoluteTracking; // Actual pose used to render scene textures.
400 };
401
402 /** Allows the application to control how scene textures are used by the compositor when calling Submit. */
403 enum EVRSubmitFlags
404 {
405        // Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
406        Submit_Default = 0x00,
407
408        // App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
409        // barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
410        // vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
411        Submit_LensDistortionAlreadyApplied = 0x01,
412
413        // If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
414        Submit_GlRenderBuffer = 0x02,
415
416        // Do not use
417        Submit_Reserved = 0x04,
418
419        // Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
420        Submit_TextureWithPose = 0x08,
421 };
422
423 /** Data required for passing Vulkan textures to IVRCompositor::Submit.
424 * Be sure to call OpenVR_Shutdown before destroying these resources. */
425 struct VRVulkanTextureData_t
426 {
427        uint64_t m_nImage; // VkImage
428        VkDevice_T *m_pDevice;
429        VkPhysicalDevice_T *m_pPhysicalDevice;
430        VkInstance_T *m_pInstance;
431        VkQueue_T *m_pQueue;
432        uint32_t m_nQueueFamilyIndex;
433        uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
434 };
435
436 /** Data required for passing D3D12 textures to IVRCompositor::Submit.
437 * Be sure to call OpenVR_Shutdown before destroying these resources. */
438 struct D3D12TextureData_t
439 {
440        ID3D12Resource *m_pResource;
441        ID3D12CommandQueue *m_pCommandQueue;
442        uint32_t m_nNodeMask;
443 };
444
445 /** Status of the overall system or tracked objects */
446 enum EVRState
447 {
448        VRState_Undefined = -1,
449        VRState_Off = 0,
450        VRState_Searching = 1,
451        VRState_Searching_Alert = 2,
452        VRState_Ready = 3,
453        VRState_Ready_Alert = 4,
454        VRState_NotReady = 5,
455        VRState_Standby = 6,
456        VRState_Ready_Alert_Low = 7,
457 };
458
459 /** The types of events that could be posted (and what the parameters mean for each event type) */
460 enum EVREventType
461 {
462        VREvent_None = 0,
463
464        VREvent_TrackedDeviceActivated              = 100,
465        VREvent_TrackedDeviceDeactivated       = 101,
466        VREvent_TrackedDeviceUpdated              = 102,
467        VREvent_TrackedDeviceUserInteractionStarted       = 103,
468        VREvent_TrackedDeviceUserInteractionEnded       = 104,
469        VREvent_IpdChanged                                   = 105,
470        VREvent_EnterStandbyMode                     = 106,
471        VREvent_LeaveStandbyMode                     = 107,
472        VREvent_TrackedDeviceRoleChanged       = 108,
473        VREvent_WatchdogWakeUpRequested              = 109,
474        VREvent_LensDistortionChanged              = 110,
475        VREvent_PropertyChanged                            = 111,
476        VREvent_WirelessDisconnect                     = 112,
477        VREvent_WirelessReconnect                     = 113,
478
479        VREvent_ButtonPress                                   = 200, // data is controller
480        VREvent_ButtonUnpress                            = 201, // data is controller
481        VREvent_ButtonTouch                                   = 202, // data is controller
482        VREvent_ButtonUntouch                            = 203, // data is controller
483
484        VREvent_MouseMove                                   = 300, // data is mouse
485        VREvent_MouseButtonDown                            = 301, // data is mouse
486        VREvent_MouseButtonUp                            = 302, // data is mouse
487        VREvent_FocusEnter                                   = 303, // data is overlay
488        VREvent_FocusLeave                                   = 304, // data is overlay
489        VREvent_Scroll                                          = 305, // data is mouse
490        VREvent_TouchPadMove                            = 306, // data is mouse
491        VREvent_OverlayFocusChanged                     = 307, // data is overlay, global event
492
493        VREvent_InputFocusCaptured                     = 400, // data is process DEPRECATED
494        VREvent_InputFocusReleased                     = 401, // data is process DEPRECATED
495        VREvent_SceneFocusLost                            = 402, // data is process
496        VREvent_SceneFocusGained                     = 403, // data is process
497        VREvent_SceneApplicationChanged              = 404, // data is process - The App actually drawing the scene changed (usually to or from the compositor)
498        VREvent_SceneFocusChanged                     = 405, // data is process - New app got access to draw the scene
499        VREvent_InputFocusChanged                     = 406, // data is process
500        VREvent_SceneApplicationSecondaryRenderingStarted = 407, // data is process
501
502        VREvent_HideRenderModels                     = 410, // Sent to the scene application to request hiding render models temporarily
503        VREvent_ShowRenderModels                     = 411, // Sent to the scene application to request restoring render model visibility
504
505        VREvent_OverlayShown                            = 500,
506        VREvent_OverlayHidden                            = 501,
507        VREvent_DashboardActivated                     = 502,
508        VREvent_DashboardDeactivated              = 503,
509        VREvent_DashboardThumbSelected              = 504, // Sent to the overlay manager - data is overlay
510        VREvent_DashboardRequested                     = 505, // Sent to the overlay manager - data is overlay
511        VREvent_ResetDashboard                            = 506, // Send to the overlay manager
512        VREvent_RenderToast                                   = 507, // Send to the dashboard to render a toast - data is the notification ID
513        VREvent_ImageLoaded                                   = 508, // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
514        VREvent_ShowKeyboard                            = 509, // Sent to keyboard renderer in the dashboard to invoke it
515        VREvent_HideKeyboard                            = 510, // Sent to keyboard renderer in the dashboard to hide it
516        VREvent_OverlayGamepadFocusGained       = 511, // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
517        VREvent_OverlayGamepadFocusLost              = 512, // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
518        VREvent_OverlaySharedTextureChanged = 513,
519        VREvent_DashboardGuideButtonDown       = 514,
520        VREvent_DashboardGuideButtonUp              = 515,
521        VREvent_ScreenshotTriggered                     = 516, // Screenshot button combo was pressed, Dashboard should request a screenshot
522        VREvent_ImageFailed                                   = 517, // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
523        VREvent_DashboardOverlayCreated              = 518,
524
525        // Screenshot API
526        VREvent_RequestScreenshot                            = 520, // Sent by vrclient application to compositor to take a screenshot
527        VREvent_ScreenshotTaken                                   = 521, // Sent by compositor to the application that the screenshot has been taken
528        VREvent_ScreenshotFailed                            = 522, // Sent by compositor to the application that the screenshot failed to be taken
529        VREvent_SubmitScreenshotToDashboard              = 523, // Sent by compositor to the dashboard that a completed screenshot was submitted
530        VREvent_ScreenshotProgressToDashboard       = 524, // Sent by compositor to the dashboard that a completed screenshot was submitted
531
532        VREvent_PrimaryDashboardDeviceChanged       = 525,
533
534        VREvent_Notification_Shown                            = 600,
535        VREvent_Notification_Hidden                            = 601,
536        VREvent_Notification_BeginInteraction       = 602,
537        VREvent_Notification_Destroyed                     = 603,
538
539        VREvent_Quit                                                 = 700, // data is process
540        VREvent_ProcessQuit                                          = 701, // data is process
541        VREvent_QuitAborted_UserPrompt                     = 702, // data is process
542        VREvent_QuitAcknowledged                            = 703, // data is process
543        VREvent_DriverRequestedQuit                            = 704, // The driver has requested that SteamVR shut down
544
545        VREvent_ChaperoneDataHasChanged                     = 800,
546        VREvent_ChaperoneUniverseHasChanged              = 801,
547        VREvent_ChaperoneTempDataHasChanged              = 802,
548        VREvent_ChaperoneSettingsHaveChanged       = 803,
549        VREvent_SeatedZeroPoseReset                            = 804,
550
551        VREvent_AudioSettingsHaveChanged              = 820,
552
553        VREvent_BackgroundSettingHasChanged              = 850,
554        VREvent_CameraSettingsHaveChanged              = 851,
555        VREvent_ReprojectionSettingHasChanged       = 852,
556        VREvent_ModelSkinSettingsHaveChanged       = 853,
557        VREvent_EnvironmentSettingsHaveChanged       = 854,
558        VREvent_PowerSettingsHaveChanged              = 855,
559        VREvent_EnableHomeAppSettingsHaveChanged = 856,
560
561        VREvent_StatusUpdate                                   = 900,
562
563        VREvent_MCImageUpdated                                   = 1000,
564
565        VREvent_FirmwareUpdateStarted                     = 1100,
566        VREvent_FirmwareUpdateFinished                     = 1101,
567
568        VREvent_KeyboardClosed                                   = 1200,
569        VREvent_KeyboardCharInput                            = 1201,
570        VREvent_KeyboardDone                                   = 1202, // Sent when DONE button clicked on keyboard
571
572        VREvent_ApplicationTransitionStarted              = 1300,
573        VREvent_ApplicationTransitionAborted              = 1301,
574        VREvent_ApplicationTransitionNewAppStarted       = 1302,
575        VREvent_ApplicationListUpdated                            = 1303,
576        VREvent_ApplicationMimeTypeLoad                            = 1304,
577        VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
578        VREvent_ProcessConnected                                   = 1306,
579        VREvent_ProcessDisconnected                                   = 1307,
580
581        VREvent_Compositor_MirrorWindowShown              = 1400,
582        VREvent_Compositor_MirrorWindowHidden              = 1401,
583        VREvent_Compositor_ChaperoneBoundsShown              = 1410,
584        VREvent_Compositor_ChaperoneBoundsHidden       = 1411,
585
586        VREvent_TrackedCamera_StartVideoStream  = 1500,
587        VREvent_TrackedCamera_StopVideoStream   = 1501,
588        VREvent_TrackedCamera_PauseVideoStream  = 1502,
589        VREvent_TrackedCamera_ResumeVideoStream = 1503,
590        VREvent_TrackedCamera_EditingSurface    = 1550,
591
592        VREvent_PerformanceTest_EnableCapture       = 1600,
593        VREvent_PerformanceTest_DisableCapture       = 1601,
594        VREvent_PerformanceTest_FidelityLevel       = 1602,
595
596        VREvent_MessageOverlay_Closed                     = 1650,
597        VREvent_MessageOverlayCloseRequested       = 1651,
598        
599        // Vendors are free to expose private events in this reserved region
600        VREvent_VendorSpecific_Reserved_Start       = 10000,
601        VREvent_VendorSpecific_Reserved_End              = 19999,
602 };
603
604
605 /** Level of Hmd activity */
606 // UserInteraction_Timeout means the device is in the process of timing out.
607 // InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
608 // VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
609 // VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
610 enum EDeviceActivityLevel
611 {       
612        k_EDeviceActivityLevel_Unknown = -1,                                                               
613        k_EDeviceActivityLevel_Idle = 0,                                          // No activity for the last 10 seconds
614        k_EDeviceActivityLevel_UserInteraction = 1,                            // Activity (movement or prox sensor) is happening now       
615        k_EDeviceActivityLevel_UserInteraction_Timeout = 2,              // No activity for the last 0.5 seconds
616        k_EDeviceActivityLevel_Standby = 3,                                          // Idle for at least 5 seconds (configurable in Settings -> Power Management)
617 };
618
619
620 /** VR controller button and axis IDs */
621 enum EVRButtonId
622 {
623        k_EButton_System                     = 0,
624        k_EButton_ApplicationMenu       = 1,
625        k_EButton_Grip                            = 2,
626        k_EButton_DPad_Left                     = 3,
627        k_EButton_DPad_Up                     = 4,
628        k_EButton_DPad_Right              = 5,
629        k_EButton_DPad_Down                     = 6,
630        k_EButton_A                                   = 7,
631        
632        k_EButton_ProximitySensor   = 31,
633
634        k_EButton_Axis0                            = 32,
635        k_EButton_Axis1                            = 33,
636        k_EButton_Axis2                            = 34,
637        k_EButton_Axis3                            = 35,
638        k_EButton_Axis4                            = 36,
639
640        // aliases for well known controllers
641        k_EButton_SteamVR_Touchpad       = k_EButton_Axis0,
642        k_EButton_SteamVR_Trigger       = k_EButton_Axis1,
643
644        k_EButton_Dashboard_Back       = k_EButton_Grip,
645
646        k_EButton_Max                            = 64
647 };
648
649 inline uint64_t ButtonMaskFromId( EVRButtonId id ) { return 1ull << id; }
650
651 /** used for controller button events */
652 struct VREvent_Controller_t
653 {
654        uint32_t button; // EVRButtonId enum
655 };
656
657
658 /** used for simulated mouse events in overlay space */
659 enum EVRMouseButton
660 {
661        VRMouseButton_Left                                   = 0x0001,
662        VRMouseButton_Right                                   = 0x0002,
663        VRMouseButton_Middle                            = 0x0004,
664 };
665
666
667 /** used for simulated mouse events in overlay space */
668 struct VREvent_Mouse_t
669 {
670        float x, y; // co-ords are in GL space, bottom left of the texture is 0,0
671        uint32_t button; // EVRMouseButton enum
672 };
673
674 /** used for simulated mouse wheel scroll in overlay space */
675 struct VREvent_Scroll_t
676 {
677        float xdelta, ydelta; // movement in fraction of the pad traversed since last delta, 1.0 for a full swipe
678        uint32_t repeatCount;
679 };
680
681 /** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
682    is on the touchpad (or just released from it) 
683 **/
684 struct VREvent_TouchPadMove_t
685 {
686        // true if the users finger is detected on the touch pad
687        bool bFingerDown;
688
689        // How long the finger has been down in seconds
690        float flSecondsFingerDown;
691
692        // These values indicate the starting finger position (so you can do some basic swipe stuff)
693        float fValueXFirst;
694        float fValueYFirst;
695
696        // This is the raw sampled coordinate without deadzoning
697        float fValueXRaw;
698        float fValueYRaw;
699 };
700
701 /** notification related events. Details will still change at this point */
702 struct VREvent_Notification_t
703 {
704        uint64_t ulUserValue;
705        uint32_t notificationId;
706 };
707
708 /** Used for events about processes */
709 struct VREvent_Process_t
710 {
711        uint32_t pid;
712        uint32_t oldPid;
713        bool bForced;
714 };
715
716
717 /** Used for a few events about overlays */
718 struct VREvent_Overlay_t
719 {
720        uint64_t overlayHandle;
721 };
722
723
724 /** Used for a few events about overlays */
725 struct VREvent_Status_t
726 {
727        uint32_t statusState; // EVRState enum
728 };
729
730 /** Used for keyboard events **/
731 struct VREvent_Keyboard_t
732 {
733        char cNewInput[8];       // Up to 11 bytes of new input
734        uint64_t uUserValue;       // Possible flags about the new input
735 };
736
737 struct VREvent_Ipd_t
738 {
739        float ipdMeters;
740 };
741
742 struct VREvent_Chaperone_t
743 {
744        uint64_t m_nPreviousUniverse;
745        uint64_t m_nCurrentUniverse;
746 };
747
748 /** Not actually used for any events */
749 struct VREvent_Reserved_t
750 {
751        uint64_t reserved0;
752        uint64_t reserved1;
753 };
754
755 struct VREvent_PerformanceTest_t
756 {
757        uint32_t m_nFidelityLevel;
758 };
759
760 struct VREvent_SeatedZeroPoseReset_t
761 {
762        bool bResetBySystemMenu;
763 };
764
765 struct VREvent_Screenshot_t
766 {
767        uint32_t handle;
768        uint32_t type;
769 };
770
771 struct VREvent_ScreenshotProgress_t
772 {
773        float progress;
774 };
775
776 struct VREvent_ApplicationLaunch_t
777 {
778        uint32_t pid;
779        uint32_t unArgsHandle;
780 };
781
782 struct VREvent_EditingCameraSurface_t
783 {
784        uint64_t overlayHandle;
785        uint32_t nVisualMode;
786 };
787
788 struct VREvent_MessageOverlay_t
789 {
790        uint32_t unVRMessageOverlayResponse; // vr::VRMessageOverlayResponse enum
791 };
792
793 struct VREvent_Property_t
794 {
795        PropertyContainerHandle_t container;
796        ETrackedDeviceProperty prop;
797 };
798
799 /** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
800 typedef union
801 {
802        VREvent_Reserved_t reserved;
803        VREvent_Controller_t controller;
804        VREvent_Mouse_t mouse;
805        VREvent_Scroll_t scroll;
806        VREvent_Process_t process;
807        VREvent_Notification_t notification;
808        VREvent_Overlay_t overlay;
809        VREvent_Status_t status;
810        VREvent_Keyboard_t keyboard;
811        VREvent_Ipd_t ipd;
812        VREvent_Chaperone_t chaperone;
813        VREvent_PerformanceTest_t performanceTest;
814        VREvent_TouchPadMove_t touchPadMove;
815        VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
816        VREvent_Screenshot_t screenshot;
817        VREvent_ScreenshotProgress_t screenshotProgress;
818        VREvent_ApplicationLaunch_t applicationLaunch;
819        VREvent_EditingCameraSurface_t cameraSurface;
820        VREvent_MessageOverlay_t messageOverlay;
821        VREvent_Property_t property;
822 } VREvent_Data_t;
823
824
825 #if defined(__linux__) || defined(__APPLE__) 
826 // This structure was originally defined mis-packed on Linux, preserved for 
827 // compatibility. 
828 #pragma pack( push, 4 )
829 #endif
830
831 /** An event posted by the server to all running applications */
832 struct VREvent_t
833 {
834        uint32_t eventType; // EVREventType enum
835        TrackedDeviceIndex_t trackedDeviceIndex;
836        float eventAgeSeconds;
837        // event data must be the end of the struct as its size is variable
838        VREvent_Data_t data;
839 };
840
841 #if defined(__linux__) || defined(__APPLE__) 
842 #pragma pack( pop )
843 #endif
844
845 /** The mesh to draw into the stencil (or depth) buffer to perform 
846 * early stencil (or depth) kills of pixels that will never appear on the HMD.
847 * This mesh draws on all the pixels that will be hidden after distortion. 
848 *
849 * If the HMD does not provide a visible area mesh pVertexData will be
850 * NULL and unTriangleCount will be 0. */
851 struct HiddenAreaMesh_t
852 {
853        const HmdVector2_t *pVertexData;
854        uint32_t unTriangleCount;
855 };
856
857
858 enum EHiddenAreaMeshType
859 {
860        k_eHiddenAreaMesh_Standard = 0,
861        k_eHiddenAreaMesh_Inverse = 1,
862        k_eHiddenAreaMesh_LineLoop = 2,
863
864        k_eHiddenAreaMesh_Max = 3,
865 };
866
867
868 /** Identifies what kind of axis is on the controller at index n. Read this type 
869 * with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
870 */
871 enum EVRControllerAxisType
872 {
873        k_eControllerAxis_None = 0,
874        k_eControllerAxis_TrackPad = 1,
875        k_eControllerAxis_Joystick = 2,
876        k_eControllerAxis_Trigger = 3, // Analog trigger data is in the X axis
877 };
878
879
880 /** contains information about one axis on the controller */
881 struct VRControllerAxis_t
882 {
883        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.
884        float y; // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
885 };
886
887
888 /** the number of axes in the controller state */
889 static const uint32_t k_unControllerStateAxisCount = 5;
890
891
892 #if defined(__linux__) || defined(__APPLE__) 
893 // This structure was originally defined mis-packed on Linux, preserved for 
894 // compatibility. 
895 #pragma pack( push, 4 )
896 #endif
897
898 /** Holds all the state of a controller at one moment in time. */
899 struct VRControllerState001_t
900 {
901        // If packet num matches that on your prior call, then the controller state hasn't been changed since 
902        // your last call and there is no need to process it
903        uint32_t unPacketNum;
904
905        // bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
906        uint64_t ulButtonPressed;
907        uint64_t ulButtonTouched;
908
909        // Axis data for the controller's analog inputs
910        VRControllerAxis_t rAxis[ k_unControllerStateAxisCount ];
911 };
912 #if defined(__linux__) || defined(__APPLE__) 
913 #pragma pack( pop )
914 #endif
915
916
917 typedef VRControllerState001_t VRControllerState_t;
918
919
920 /** determines how to provide output to the application of various event processing functions. */
921 enum EVRControllerEventOutputType
922 {
923        ControllerEventOutput_OSEvents = 0,
924        ControllerEventOutput_VREvents = 1,
925 };
926
927
928
929 /** Collision Bounds Style */
930 enum ECollisionBoundsStyle
931 {
932        COLLISION_BOUNDS_STYLE_BEGINNER = 0,
933        COLLISION_BOUNDS_STYLE_INTERMEDIATE,
934        COLLISION_BOUNDS_STYLE_SQUARES,
935        COLLISION_BOUNDS_STYLE_ADVANCED,
936        COLLISION_BOUNDS_STYLE_NONE,
937
938        COLLISION_BOUNDS_STYLE_COUNT
939 };
940
941 /** Allows the application to customize how the overlay appears in the compositor */
942 struct Compositor_OverlaySettings
943 {
944        uint32_t size; // sizeof(Compositor_OverlaySettings)
945        bool curved, antialias;
946        float scale, distance, alpha;
947        float uOffset, vOffset, uScale, vScale;
948        float gridDivs, gridWidth, gridScale;
949        HmdMatrix44_t transform;
950 };
951
952 /** used to refer to a single VR overlay */
953 typedef uint64_t VROverlayHandle_t;
954
955 static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
956
957 /** Errors that can occur around VR overlays */
958 enum EVROverlayError
959 {
960        VROverlayError_None                                          = 0,
961
962        VROverlayError_UnknownOverlay                     = 10,
963        VROverlayError_InvalidHandle                     = 11,
964        VROverlayError_PermissionDenied                     = 12,
965        VROverlayError_OverlayLimitExceeded              = 13, // No more overlays could be created because the maximum number already exist
966        VROverlayError_WrongVisibilityType              = 14,
967        VROverlayError_KeyTooLong                            = 15,
968        VROverlayError_NameTooLong                            = 16,
969        VROverlayError_KeyInUse                                   = 17,
970        VROverlayError_WrongTransformType              = 18,
971        VROverlayError_InvalidTrackedDevice              = 19,
972        VROverlayError_InvalidParameter                     = 20,
973        VROverlayError_ThumbnailCantBeDestroyed       = 21,
974        VROverlayError_ArrayTooSmall                     = 22,
975        VROverlayError_RequestFailed                     = 23,
976        VROverlayError_InvalidTexture                     = 24,
977        VROverlayError_UnableToLoadFile                     = 25,
978        VROverlayError_KeyboardAlreadyInUse              = 26,
979        VROverlayError_NoNeighbor                            = 27,
980        VROverlayError_TooManyMaskPrimitives       = 29,
981        VROverlayError_BadMaskPrimitive                     = 30,
982 };
983
984 /** enum values to pass in to VR_Init to identify whether the application will 
985 * draw a 3D scene. */
986 enum EVRApplicationType
987 {
988        VRApplication_Other = 0,              // Some other kind of application that isn't covered by the other entries 
989        VRApplication_Scene       = 1,              // Application will submit 3D frames 
990        VRApplication_Overlay = 2,              // Application only interacts with overlays
991        VRApplication_Background = 3,       // Application should not start SteamVR if it's not already running, and should not
992                                                                // keep it running if everything else quits.
993        VRApplication_Utility = 4,              // Init should not try to load any drivers. The application needs access to utility
994                                                                // interfaces (like IVRSettings and IVRApplications) but not hardware.
995        VRApplication_VRMonitor = 5,       // Reserved for vrmonitor
996        VRApplication_SteamWatchdog = 6,// Reserved for Steam
997        VRApplication_Bootstrapper = 7, // Start up SteamVR
998
999        VRApplication_Max
1000 };
1001
1002
1003 /** error codes for firmware */
1004 enum EVRFirmwareError
1005 {
1006        VRFirmwareError_None = 0,
1007        VRFirmwareError_Success = 1,
1008        VRFirmwareError_Fail = 2,
1009 };
1010
1011
1012 /** error codes for notifications */
1013 enum EVRNotificationError
1014 {
1015        VRNotificationError_OK = 0,
1016        VRNotificationError_InvalidNotificationId = 100,
1017        VRNotificationError_NotificationQueueFull = 101,
1018        VRNotificationError_InvalidOverlayHandle = 102,
1019        VRNotificationError_SystemWithUserValueAlreadyExists = 103,
1020 };
1021
1022
1023 /** error codes returned by Vr_Init */
1024
1025 // Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
1026 enum EVRInitError
1027 {
1028        VRInitError_None       = 0,
1029        VRInitError_Unknown = 1,
1030
1031        VRInitError_Init_InstallationNotFound                     = 100,
1032        VRInitError_Init_InstallationCorrupt                     = 101,
1033        VRInitError_Init_VRClientDLLNotFound                     = 102,
1034        VRInitError_Init_FileNotFound                                   = 103,
1035        VRInitError_Init_FactoryNotFound                            = 104,
1036        VRInitError_Init_InterfaceNotFound                            = 105,
1037        VRInitError_Init_InvalidInterface                            = 106,
1038        VRInitError_Init_UserConfigDirectoryInvalid              = 107,
1039        VRInitError_Init_HmdNotFound                                   = 108,
1040        VRInitError_Init_NotInitialized                                   = 109,
1041        VRInitError_Init_PathRegistryNotFound                     = 110,
1042        VRInitError_Init_NoConfigPath                                   = 111,
1043        VRInitError_Init_NoLogPath                                          = 112,
1044        VRInitError_Init_PathRegistryNotWritable              = 113,
1045        VRInitError_Init_AppInfoInitFailed                            = 114,
1046        VRInitError_Init_Retry                                                 = 115, // Used internally to cause retries to vrserver
1047        VRInitError_Init_InitCanceledByUser                            = 116, // The calling application should silently exit. The user canceled app startup
1048        VRInitError_Init_AnotherAppLaunching                     = 117, 
1049        VRInitError_Init_SettingsInitFailed                            = 118, 
1050        VRInitError_Init_ShuttingDown                                   = 119,
1051        VRInitError_Init_TooManyObjects                                   = 120,
1052        VRInitError_Init_NoServerForBackgroundApp              = 121,
1053        VRInitError_Init_NotSupportedWithCompositor              = 122,
1054        VRInitError_Init_NotAvailableToUtilityApps              = 123,
1055        VRInitError_Init_Internal                                           = 124,
1056        VRInitError_Init_HmdDriverIdIsNone                             = 125,
1057        VRInitError_Init_HmdNotFoundPresenceFailed               = 126,
1058        VRInitError_Init_VRMonitorNotFound                            = 127,
1059        VRInitError_Init_VRMonitorStartupFailed                     = 128,
1060        VRInitError_Init_LowPowerWatchdogNotSupported       = 129, 
1061        VRInitError_Init_InvalidApplicationType                     = 130,
1062        VRInitError_Init_NotAvailableToWatchdogApps              = 131,
1063        VRInitError_Init_WatchdogDisabledInSettings              = 132,
1064        VRInitError_Init_VRDashboardNotFound                     = 133,
1065        VRInitError_Init_VRDashboardStartupFailed              = 134,
1066        VRInitError_Init_VRHomeNotFound                                   = 135,
1067        VRInitError_Init_VRHomeStartupFailed                     = 136,
1068        VRInitError_Init_RebootingBusy                                   = 137,
1069        VRInitError_Init_FirmwareUpdateBusy                            = 138,
1070        VRInitError_Init_FirmwareRecoveryBusy                     = 139,
1071
1072
1073        VRInitError_Driver_Failed                                          = 200,
1074        VRInitError_Driver_Unknown                                          = 201,
1075        VRInitError_Driver_HmdUnknown                                   = 202,
1076        VRInitError_Driver_NotLoaded                                   = 203,
1077        VRInitError_Driver_RuntimeOutOfDate                            = 204,
1078        VRInitError_Driver_HmdInUse                                          = 205,
1079        VRInitError_Driver_NotCalibrated                            = 206,
1080        VRInitError_Driver_CalibrationInvalid                     = 207,
1081        VRInitError_Driver_HmdDisplayNotFound                     = 208,
1082        VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
1083        // VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
1084        VRInitError_Driver_HmdDriverIdOutOfBounds              = 211,
1085        VRInitError_Driver_HmdDisplayMirrored                     = 212,
1086
1087        VRInitError_IPC_ServerInitFailed                            = 300,
1088        VRInitError_IPC_ConnectFailed                                   = 301,
1089        VRInitError_IPC_SharedStateInitFailed                     = 302,
1090        VRInitError_IPC_CompositorInitFailed                     = 303,
1091        VRInitError_IPC_MutexInitFailed                                   = 304,
1092        VRInitError_IPC_Failed                                                 = 305,
1093        VRInitError_IPC_CompositorConnectFailed                     = 306,
1094        VRInitError_IPC_CompositorInvalidConnectResponse = 307,
1095        VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
1096
1097        VRInitError_Compositor_Failed                                   = 400,
1098        VRInitError_Compositor_D3D11HardwareRequired       = 401,
1099        VRInitError_Compositor_FirmwareRequiresUpdate       = 402,
1100        VRInitError_Compositor_OverlayInitFailed              = 403,
1101        VRInitError_Compositor_ScreenshotsInitFailed       = 404,
1102        VRInitError_Compositor_UnableToCreateDevice              = 405,
1103
1104        VRInitError_VendorSpecific_UnableToConnectToOculusRuntime              = 1000,
1105
1106        VRInitError_VendorSpecific_HmdFound_CantOpenDevice                             = 1101,
1107        VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart       = 1102,
1108        VRInitError_VendorSpecific_HmdFound_NoStoredConfig                             = 1103,
1109        VRInitError_VendorSpecific_HmdFound_ConfigTooBig                             = 1104,
1110        VRInitError_VendorSpecific_HmdFound_ConfigTooSmall                             = 1105,
1111        VRInitError_VendorSpecific_HmdFound_UnableToInitZLib                      = 1106,
1112        VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion        = 1107,
1113        VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart       = 1108,
1114        VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart       = 1109,
1115        VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext              = 1110,
1116        VRInitError_VendorSpecific_HmdFound_UserDataAddressRange              = 1111,
1117        VRInitError_VendorSpecific_HmdFound_UserDataError                            = 1112,
1118        VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck              = 1113,
1119
1120        VRInitError_Steam_SteamInstallationNotFound = 2000,
1121 };
1122
1123 enum EVRScreenshotType
1124 {
1125        VRScreenshotType_None = 0,
1126        VRScreenshotType_Mono = 1, // left eye only
1127        VRScreenshotType_Stereo = 2,
1128        VRScreenshotType_Cubemap = 3,
1129        VRScreenshotType_MonoPanorama = 4,
1130        VRScreenshotType_StereoPanorama = 5
1131 };
1132
1133 enum EVRScreenshotPropertyFilenames
1134 {
1135        VRScreenshotPropertyFilenames_Preview = 0,
1136        VRScreenshotPropertyFilenames_VR = 1,
1137 };
1138
1139 enum EVRTrackedCameraError
1140 {
1141        VRTrackedCameraError_None                       = 0,
1142        VRTrackedCameraError_OperationFailed            = 100,
1143        VRTrackedCameraError_InvalidHandle              = 101,       
1144        VRTrackedCameraError_InvalidFrameHeaderVersion  = 102,
1145        VRTrackedCameraError_OutOfHandles               = 103,
1146        VRTrackedCameraError_IPCFailure                 = 104,
1147        VRTrackedCameraError_NotSupportedForThisDevice  = 105,
1148        VRTrackedCameraError_SharedMemoryFailure        = 106,
1149        VRTrackedCameraError_FrameBufferingFailure      = 107,
1150        VRTrackedCameraError_StreamSetupFailure         = 108,
1151        VRTrackedCameraError_InvalidGLTextureId         = 109,
1152        VRTrackedCameraError_InvalidSharedTextureHandle = 110,
1153        VRTrackedCameraError_FailedToGetGLTextureId     = 111,
1154        VRTrackedCameraError_SharedTextureFailure       = 112,
1155        VRTrackedCameraError_NoFrameAvailable           = 113,
1156        VRTrackedCameraError_InvalidArgument            = 114,
1157        VRTrackedCameraError_InvalidFrameBufferSize     = 115,
1158 };
1159
1160 enum EVRTrackedCameraFrameType
1161 {
1162        VRTrackedCameraFrameType_Distorted = 0,                     // This is the camera video frame size in pixels, still distorted.
1163        VRTrackedCameraFrameType_Undistorted,                     // In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
1164        VRTrackedCameraFrameType_MaximumUndistorted,       // In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
1165        MAX_CAMERA_FRAME_TYPES
1166 };
1167
1168 typedef uint64_t TrackedCameraHandle_t;
1169 #define INVALID_TRACKED_CAMERA_HANDLE       ((vr::TrackedCameraHandle_t)0)
1170
1171 struct CameraVideoStreamFrameHeader_t
1172 {
1173        EVRTrackedCameraFrameType eFrameType;
1174
1175        uint32_t nWidth;
1176        uint32_t nHeight;
1177        uint32_t nBytesPerPixel;
1178
1179        uint32_t nFrameSequence;
1180
1181        TrackedDevicePose_t standingTrackedDevicePose;
1182 };
1183
1184 // Screenshot types
1185 typedef uint32_t ScreenshotHandle_t;
1186
1187 static const uint32_t k_unScreenshotHandleInvalid = 0;
1188
1189 #pragma pack( pop )
1190
1191 // figure out how to import from the VR API dll
1192 #if defined(_WIN32)
1193
1194 #ifdef VR_API_EXPORT
1195 #define VR_INTERFACE extern "C" __declspec( dllexport )
1196 #else
1197 #define VR_INTERFACE extern "C" __declspec( dllimport )
1198 #endif
1199
1200 #elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
1201
1202 #ifdef VR_API_EXPORT
1203 #define VR_INTERFACE extern "C" __attribute__((visibility("default")))
1204 #else
1205 #define VR_INTERFACE extern "C" 
1206 #endif
1207
1208 #else
1209 #error "Unsupported Platform."
1210 #endif
1211
1212
1213 #if defined( _WIN32 )
1214 #define VR_CALLTYPE __cdecl
1215 #else
1216 #define VR_CALLTYPE 
1217 #endif
1218
1219 } // namespace vr
1220
1221 #endif // _INCLUDE_VRTYPES_H
1222
1223
1224 // vrannotation.h
1225 #ifdef API_GEN
1226 # define VR_CLANG_ATTR(ATTR) __attribute__((annotate( ATTR )))
1227 #else
1228 # define VR_CLANG_ATTR(ATTR)
1229 #endif
1230
1231 #define VR_METHOD_DESC(DESC) VR_CLANG_ATTR( "desc:" #DESC ";" )
1232 #define VR_IGNOREATTR() VR_CLANG_ATTR( "ignore" )
1233 #define VR_OUT_STRUCT() VR_CLANG_ATTR( "out_struct: ;" )
1234 #define VR_OUT_STRING() VR_CLANG_ATTR( "out_string: ;" )
1235 #define VR_OUT_ARRAY_CALL(COUNTER,FUNCTION,PARAMS) VR_CLANG_ATTR( "out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";" )
1236 #define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "out_array_count:" #COUNTER ";" )
1237 #define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "array_count:" #COUNTER ";" )
1238 #define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR( "array_count:" #COUNTER ";desc:" #DESC )
1239 #define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "buffer_count:" #COUNTER ";" )
1240 #define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "out_buffer_count:" #COUNTER ";" )
1241 #define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR( "out_string_count:" #COUNTER ";" )
1242
1243 // ivrsystem.h
1244 namespace vr
1245 {
1246
1247 class IVRSystem
1248 {
1249 public:
1250
1251
1252        // ------------------------------------
1253        // Display Methods
1254        // ------------------------------------
1255
1256        /** Suggested size for the intermediate render target that the distortion pulls from. */
1257        virtual void GetRecommendedRenderTargetSize( uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
1258
1259        /** The projection matrix for the specified eye */
1260        virtual HmdMatrix44_t GetProjectionMatrix( EVREye eEye, float fNearZ, float fFarZ ) = 0;
1261
1262        /** The components necessary to build your own projection matrix in case your
1263        * application is doing something fancy like infinite Z */
1264        virtual void GetProjectionRaw( EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom ) = 0;
1265
1266        /** Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in 
1267        * the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
1268        * Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. */
1269        virtual bool ComputeDistortion( EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates ) = 0;
1270
1271        /** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head
1272        * space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection. 
1273        * Normally View and Eye^-1 will be multiplied together and treated as View in your application. 
1274        */
1275        virtual HmdMatrix34_t GetEyeToHeadTransform( EVREye eEye ) = 0;
1276
1277        /** Returns the number of elapsed seconds since the last recorded vsync event. This 
1278        *       will come from a vsync timer event in the timer if possible or from the application-reported
1279        *   time if that is not available. If no vsync times are available the function will 
1280        *   return zero for vsync time and frame counter and return false from the method. */
1281        virtual bool GetTimeSinceLastVsync( float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter ) = 0;
1282
1283        /** [D3D9 Only]
1284        * Returns the adapter index that the user should pass into CreateDevice to set up D3D9 in such
1285        * a way that it can go full screen exclusive on the HMD. Returns -1 if there was an error.
1286        */
1287        virtual int32_t GetD3D9AdapterIndex() = 0;
1288
1289        /** [D3D10/11 Only]
1290        * Returns the adapter index that the user should pass into EnumAdapters to create the device 
1291        * and swap chain in DX10 and DX11. If an error occurs the index will be set to -1.
1292        */
1293        virtual void GetDXGIOutputInfo( int32_t *pnAdapterIndex ) = 0;
1294        
1295        /**
1296         * Returns platform- and texture-type specific adapter identification so that applications and the
1297         * compositor are creating textures and swap chains on the same GPU. If an error occurs the device
1298         * will be set to 0.
1299         * pInstance is an optional parameter that is required only when textureType is TextureType_Vulkan.
1300         * [D3D10/11/12 Only (D3D9 Not Supported)]
1301         *  Returns the adapter LUID that identifies the GPU attached to the HMD. The user should
1302         *  enumerate all adapters using IDXGIFactory::EnumAdapters and IDXGIAdapter::GetDesc to find
1303         *  the adapter with the matching LUID, or use IDXGIFactory4::EnumAdapterByLuid.
1304         *  The discovered IDXGIAdapter should be used to create the device and swap chain.
1305         * [Vulkan Only]
1306         *  Returns the VkPhysicalDevice that should be used by the application.
1307         *  pInstance must be the instance the application will use to query for the VkPhysicalDevice.  The application
1308         *  must create the VkInstance with extensions returned by IVRCompositor::GetVulkanInstanceExtensionsRequired enabled.
1309         * [macOS Only]
1310         *  Returns an id<MTLDevice> that should be used by the application.
1311         */
1312        virtual void GetOutputDevice( uint64_t *pnDevice, ETextureType textureType, VkInstance_T *pInstance = nullptr ) = 0;
1313
1314        // ------------------------------------
1315        // Display Mode methods
1316        // ------------------------------------
1317
1318        /** Use to determine if the headset display is part of the desktop (i.e. extended) or hidden (i.e. direct mode). */
1319        virtual bool IsDisplayOnDesktop() = 0;
1320
1321        /** Set the display visibility (true = extended, false = direct mode).  Return value of true indicates that the change was successful. */
1322        virtual bool SetDisplayVisibility( bool bIsVisibleOnDesktop ) = 0;
1323
1324        // ------------------------------------
1325        // Tracking Methods
1326        // ------------------------------------
1327
1328        /** The pose that the tracker thinks that the HMD will be in at the specified number of seconds into the 
1329        * future. Pass 0 to get the state at the instant the method is called. Most of the time the application should
1330        * calculate the time until the photons will be emitted from the display and pass that time into the method.
1331        *
1332        * This is roughly analogous to the inverse of the view matrix in most applications, though 
1333        * many games will need to do some additional rotation or translation on top of the rotation
1334        * and translation provided by the head pose.
1335        *
1336        * For devices where bPoseIsValid is true the application can use the pose to position the device
1337        * in question. The provided array can be any size up to k_unMaxTrackedDeviceCount. 
1338        *
1339        * Seated experiences should call this method with TrackingUniverseSeated and receive poses relative
1340        * to the seated zero pose. Standing experiences should call this method with TrackingUniverseStanding 
1341        * and receive poses relative to the Chaperone Play Area. TrackingUniverseRawAndUncalibrated should 
1342        * probably not be used unless the application is the Chaperone calibration tool itself, but will provide
1343        * poses relative to the hardware-specific coordinate system in the driver.
1344        */
1345        virtual void GetDeviceToAbsoluteTrackingPose( ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount) TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount ) = 0;
1346
1347        /** Sets the zero pose for the seated tracker coordinate system to the current position and yaw of the HMD. After 
1348        * ResetSeatedZeroPose all GetDeviceToAbsoluteTrackingPose calls that pass TrackingUniverseSeated as the origin 
1349        * will be relative to this new zero pose. The new zero coordinate system will not change the fact that the Y axis 
1350        * is up in the real world, so the next pose returned from GetDeviceToAbsoluteTrackingPose after a call to 
1351        * ResetSeatedZeroPose may not be exactly an identity matrix.
1352        *
1353        * NOTE: This function overrides the user's previously saved seated zero pose and should only be called as the result of a user action. 
1354        * Users are also able to set their seated zero pose via the OpenVR Dashboard.
1355        **/
1356        virtual void ResetSeatedZeroPose() = 0;
1357
1358        /** Returns the transform from the seated zero pose to the standing absolute tracking system. This allows 
1359        * applications to represent the seated origin to used or transform object positions from one coordinate
1360        * system to the other. 
1361        *
1362        * The seated origin may or may not be inside the Play Area or Collision Bounds returned by IVRChaperone. Its position 
1363        * depends on what the user has set from the Dashboard settings and previous calls to ResetSeatedZeroPose. */
1364        virtual HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() = 0;
1365
1366        /** Returns the transform from the tracking origin to the standing absolute tracking system. This allows
1367        * applications to convert from raw tracking space to the calibrated standing coordinate system. */
1368        virtual HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() = 0;
1369
1370        /** Get a sorted array of device indices of a given class of tracked devices (e.g. controllers).  Devices are sorted right to left
1371        * relative to the specified tracked device (default: hmd -- pass in -1 for absolute tracking space).  Returns the number of devices
1372        * in the list, or the size of the array needed if not large enough. */
1373        virtual uint32_t GetSortedTrackedDeviceIndicesOfClass( ETrackedDeviceClass eTrackedDeviceClass, VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount) vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex = k_unTrackedDeviceIndex_Hmd ) = 0;
1374
1375        /** Returns the level of activity on the device. */
1376        virtual EDeviceActivityLevel GetTrackedDeviceActivityLevel( vr::TrackedDeviceIndex_t unDeviceId ) = 0;
1377
1378        /** Convenience utility to apply the specified transform to the specified pose.
1379        *   This properly transforms all pose components, including velocity and angular velocity
1380        */
1381        virtual void ApplyTransform( TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform ) = 0;
1382
1383        /** Returns the device index associated with a specific role, for example the left hand or the right hand. */
1384        virtual vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForControllerRole( vr::ETrackedControllerRole unDeviceType ) = 0;
1385
1386        /** Returns the controller type associated with a device index. */
1387        virtual vr::ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
1388
1389        // ------------------------------------
1390        // Property methods
1391        // ------------------------------------
1392
1393        /** Returns the device class of a tracked device. If there has not been a device connected in this slot
1394        * since the application started this function will return TrackedDevice_Invalid. For previous detected
1395        * devices the function will return the previously observed device class. 
1396        *
1397        * To determine which devices exist on the system, just loop from 0 to k_unMaxTrackedDeviceCount and check
1398        * the device class. Every device with something other than TrackedDevice_Invalid is associated with an 
1399        * actual tracked device. */
1400        virtual ETrackedDeviceClass GetTrackedDeviceClass( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
1401
1402        /** Returns true if there is a device connected in this slot. */
1403        virtual bool IsTrackedDeviceConnected( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
1404
1405        /** Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false. */
1406        virtual bool GetBoolTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
1407
1408        /** Returns a float property. If the device index is not valid or the property is not a float type this function will return 0. */
1409        virtual float GetFloatTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
1410
1411        /** Returns an int property. If the device index is not valid or the property is not a int type this function will return 0. */
1412        virtual int32_t GetInt32TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
1413
1414        /** Returns a uint64 property. If the device index is not valid or the property is not a uint64 type this function will return 0. */
1415        virtual uint64_t GetUint64TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
1416
1417        /** Returns a matrix property. If the device index is not valid or the property is not a matrix type, this function will return identity. */
1418        virtual HmdMatrix34_t GetMatrix34TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
1419
1420        /** Returns a string property. If the device index is not valid or the property is not a string type this function will 
1421        * return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
1422        * null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
1423        virtual uint32_t GetStringTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) = 0;
1424
1425        /** returns a string that corresponds with the specified property error. The string will be the name 
1426        * of the error enum value for all valid error codes */
1427        virtual const char *GetPropErrorNameFromEnum( ETrackedPropertyError error ) = 0;
1428
1429        // ------------------------------------
1430        // Event methods
1431        // ------------------------------------
1432
1433        /** Returns true and fills the event with the next event on the queue if there is one. If there are no events
1434        * this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
1435        virtual bool PollNextEvent( VREvent_t *pEvent, uint32_t uncbVREvent ) = 0;
1436
1437        /** Returns true and fills the event with the next event on the queue if there is one. If there are no events
1438        * this method returns false. Fills in the pose of the associated tracked device in the provided pose struct. 
1439        * This pose will always be older than the call to this function and should not be used to render the device. 
1440        uncbVREvent should be the size in bytes of the VREvent_t struct */
1441        virtual bool PollNextEventWithPose( ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose ) = 0;
1442
1443        /** returns the name of an EVREvent enum value */
1444        virtual const char *GetEventTypeNameFromEnum( EVREventType eType ) = 0;
1445
1446        // ------------------------------------
1447        // Rendering helper methods
1448        // ------------------------------------
1449
1450        /** Returns the hidden area mesh for the current HMD. The pixels covered by this mesh will never be seen by the user after the lens distortion is
1451        * applied based on visibility to the panels. If this HMD does not have a hidden area mesh, the vertex data and count will be NULL and 0 respectively.
1452        * This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering each eye's view. 
1453        * This will improve performance by letting the GPU early-reject pixels the user will never see before running the pixel shader.
1454        * NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye.
1455        * Setting the bInverse argument to true will produce the visible area mesh that is commonly used in place of full-screen quads. The visible area mesh covers all of the pixels the hidden area mesh does not cover.
1456        * Setting the bLineLoop argument will return a line loop of vertices in HiddenAreaMesh_t->pVertexData with HiddenAreaMesh_t->unTriangleCount set to the number of vertices.
1457        */
1458        virtual HiddenAreaMesh_t GetHiddenAreaMesh( EVREye eEye, EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard ) = 0;
1459
1460        // ------------------------------------
1461        // Controller methods
1462        // ------------------------------------
1463
1464        /** Fills the supplied struct with the current state of the controller. Returns false if the controller index
1465        * is invalid. */
1466        virtual bool GetControllerState( vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize ) = 0;
1467
1468        /** fills the supplied struct with the current state of the controller and the provided pose with the pose of 
1469        * the controller when the controller state was updated most recently. Use this form if you need a precise controller
1470        * pose as input to your application when the user presses or releases a button. */
1471        virtual bool GetControllerStateWithPose( ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose ) = 0;
1472
1473        /** Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
1474        * and axis combination for 5ms. */
1475        virtual void TriggerHapticPulse( vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec ) = 0;
1476
1477        /** returns the name of an EVRButtonId enum value */
1478        virtual const char *GetButtonIdNameFromEnum( EVRButtonId eButtonId ) = 0;
1479
1480        /** returns the name of an EVRControllerAxisType enum value */
1481        virtual const char *GetControllerAxisTypeNameFromEnum( EVRControllerAxisType eAxisType ) = 0;
1482
1483        /** Tells OpenVR that this process wants exclusive access to controller button states and button events. Other apps will be notified that 
1484        * they have lost input focus with a VREvent_InputFocusCaptured event. Returns false if input focus could not be captured for
1485        * some reason. */
1486        virtual bool CaptureInputFocus() = 0;
1487
1488        /** Tells OpenVR that this process no longer wants exclusive access to button states and button events. Other apps will be notified 
1489        * that input focus has been released with a VREvent_InputFocusReleased event. */
1490        virtual void ReleaseInputFocus() = 0;
1491
1492        /** Returns true if input focus is captured by another process. */
1493        virtual bool IsInputFocusCapturedByAnotherProcess() = 0;
1494
1495        // ------------------------------------
1496        // Debug Methods
1497        // ------------------------------------
1498
1499        /** Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
1500        * but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated. 
1501        * The size of the response including its terminating null is returned. */
1502        virtual uint32_t DriverDebugRequest( vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize ) = 0;
1503
1504        // ------------------------------------
1505        // Firmware methods
1506        // ------------------------------------
1507        
1508        /** Performs the actual firmware update if applicable. 
1509         * The following events will be sent, if VRFirmwareError_None was returned: VREvent_FirmwareUpdateStarted, VREvent_FirmwareUpdateFinished 
1510         * Use the properties Prop_Firmware_UpdateAvailable_Bool, Prop_Firmware_ManualUpdate_Bool, and Prop_Firmware_ManualUpdateURL_String
1511         * to figure our whether a firmware update is available, and to figure out whether its a manual update 
1512         * Prop_Firmware_ManualUpdateURL_String should point to an URL describing the manual update process */
1513        virtual vr::EVRFirmwareError PerformFirmwareUpdate( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
1514
1515        // ------------------------------------
1516        // Application life cycle methods
1517        // ------------------------------------
1518
1519        /** Call this to acknowledge to the system that VREvent_Quit has been received and that the process is exiting.
1520        * This extends the timeout until the process is killed. */
1521        virtual void AcknowledgeQuit_Exiting() = 0;
1522
1523        /** Call this to tell the system that the user is being prompted to save data. This
1524        * halts the timeout and dismisses the dashboard (if it was up). Applications should be sure to actually 
1525        * prompt the user to save and then exit afterward, otherwise the user will be left in a confusing state. */
1526        virtual void AcknowledgeQuit_UserPrompt() = 0;
1527
1528 };
1529
1530 static const char * const IVRSystem_Version = "IVRSystem_017";
1531
1532 }
1533
1534
1535 // ivrapplications.h
1536 namespace vr
1537 {
1538
1539        /** Used for all errors reported by the IVRApplications interface */
1540        enum EVRApplicationError
1541        {
1542               VRApplicationError_None = 0,
1543
1544               VRApplicationError_AppKeyAlreadyExists = 100,       // Only one application can use any given key
1545               VRApplicationError_NoManifest = 101,                     // the running application does not have a manifest
1546               VRApplicationError_NoApplication = 102,                     // No application is running
1547               VRApplicationError_InvalidIndex = 103,
1548               VRApplicationError_UnknownApplication = 104,       // the application could not be found
1549               VRApplicationError_IPCFailed = 105,                            // An IPC failure caused the request to fail
1550               VRApplicationError_ApplicationAlreadyRunning = 106, 
1551               VRApplicationError_InvalidManifest = 107,
1552               VRApplicationError_InvalidApplication = 108,
1553               VRApplicationError_LaunchFailed = 109,                     // the process didn't start
1554               VRApplicationError_ApplicationAlreadyStarting = 110, // the system was already starting the same application
1555               VRApplicationError_LaunchInProgress = 111,              // The system was already starting a different application
1556               VRApplicationError_OldApplicationQuitting = 112, 
1557               VRApplicationError_TransitionAborted = 113,
1558               VRApplicationError_IsTemplate = 114, // error when you try to call LaunchApplication() on a template type app (use LaunchTemplateApplication)
1559               VRApplicationError_SteamVRIsExiting = 115,
1560
1561               VRApplicationError_BufferTooSmall = 200,              // The provided buffer was too small to fit the requested data
1562               VRApplicationError_PropertyNotSet = 201,              // The requested property was not set
1563               VRApplicationError_UnknownProperty = 202,
1564               VRApplicationError_InvalidParameter = 203,
1565        };
1566
1567        /** The maximum length of an application key */
1568        static const uint32_t k_unMaxApplicationKeyLength = 128;
1569
1570        /** these are the properties available on applications. */
1571        enum EVRApplicationProperty
1572        {
1573               VRApplicationProperty_Name_String                            = 0,
1574
1575               VRApplicationProperty_LaunchType_String                     = 11,
1576               VRApplicationProperty_WorkingDirectory_String       = 12,
1577               VRApplicationProperty_BinaryPath_String                     = 13,
1578               VRApplicationProperty_Arguments_String                     = 14,
1579               VRApplicationProperty_URL_String                            = 15,
1580
1581               VRApplicationProperty_Description_String              = 50,
1582               VRApplicationProperty_NewsURL_String                     = 51,
1583               VRApplicationProperty_ImagePath_String                     = 52,
1584               VRApplicationProperty_Source_String                            = 53,
1585
1586               VRApplicationProperty_IsDashboardOverlay_Bool       = 60,
1587               VRApplicationProperty_IsTemplate_Bool                     = 61,
1588               VRApplicationProperty_IsInstanced_Bool                     = 62,
1589               VRApplicationProperty_IsInternal_Bool                     = 63,
1590               VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
1591
1592               VRApplicationProperty_LastLaunchTime_Uint64              = 70,
1593        };
1594
1595        /** These are states the scene application startup process will go through. */
1596        enum EVRApplicationTransitionState
1597        {
1598               VRApplicationTransition_None = 0,
1599
1600               VRApplicationTransition_OldAppQuitSent = 10,
1601               VRApplicationTransition_WaitingForExternalLaunch = 11,
1602               
1603               VRApplicationTransition_NewAppLaunched = 20,
1604        };
1605
1606        struct AppOverrideKeys_t
1607        {
1608               const char *pchKey;
1609               const char *pchValue;
1610        };
1611
1612        /** Currently recognized mime types */
1613        static const char * const k_pch_MimeType_HomeApp              = "vr/home";
1614        static const char * const k_pch_MimeType_GameTheater       = "vr/game_theater";
1615
1616        class IVRApplications
1617        {
1618        public:
1619
1620               // ---------------  Application management  --------------- //
1621
1622               /** Adds an application manifest to the list to load when building the list of installed applications. 
1623               * Temporary manifests are not automatically loaded */
1624               virtual EVRApplicationError AddApplicationManifest( const char *pchApplicationManifestFullPath, bool bTemporary = false ) = 0;
1625
1626               /** Removes an application manifest from the list to load when building the list of installed applications. */
1627               virtual EVRApplicationError RemoveApplicationManifest( const char *pchApplicationManifestFullPath ) = 0;
1628
1629               /** Returns true if an application is installed */
1630               virtual bool IsApplicationInstalled( const char *pchAppKey ) = 0;
1631
1632               /** Returns the number of applications available in the list */
1633               virtual uint32_t GetApplicationCount() = 0;
1634
1635               /** Returns the key of the specified application. The index is at least 0 and is less than the return 
1636               * value of GetApplicationCount(). The buffer should be at least k_unMaxApplicationKeyLength in order to 
1637               * fit the key. */
1638               virtual EVRApplicationError GetApplicationKeyByIndex( uint32_t unApplicationIndex, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
1639
1640               /** Returns the key of the application for the specified Process Id. The buffer should be at least 
1641               * k_unMaxApplicationKeyLength in order to fit the key. */
1642               virtual EVRApplicationError GetApplicationKeyByProcessId( uint32_t unProcessId, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
1643
1644               /** Launches the application. The existing scene application will exit and then the new application will start.
1645               * This call is not valid for dashboard overlay applications. */
1646               virtual EVRApplicationError LaunchApplication( const char *pchAppKey ) = 0;
1647
1648               /** Launches an instance of an application of type template, with its app key being pchNewAppKey (which must be unique) and optionally override sections
1649               * from the manifest file via AppOverrideKeys_t
1650               */
1651               virtual EVRApplicationError LaunchTemplateApplication( const char *pchTemplateAppKey, const char *pchNewAppKey, VR_ARRAY_COUNT( unKeys ) const AppOverrideKeys_t *pKeys, uint32_t unKeys ) = 0;
1652
1653               /** launches the application currently associated with this mime type and passes it the option args, typically the filename or object name of the item being launched */
1654               virtual vr::EVRApplicationError LaunchApplicationFromMimeType( const char *pchMimeType, const char *pchArgs ) = 0;
1655
1656               /** Launches the dashboard overlay application if it is not already running. This call is only valid for 
1657               * dashboard overlay applications. */
1658               virtual EVRApplicationError LaunchDashboardOverlay( const char *pchAppKey ) = 0;
1659
1660               /** Cancel a pending launch for an application */
1661               virtual bool CancelApplicationLaunch( const char *pchAppKey ) = 0;
1662
1663               /** Identifies a running application. OpenVR can't always tell which process started in response
1664               * to a URL. This function allows a URL handler (or the process itself) to identify the app key 
1665               * for the now running application. Passing a process ID of 0 identifies the calling process. 
1666               * The application must be one that's known to the system via a call to AddApplicationManifest. */
1667               virtual EVRApplicationError IdentifyApplication( uint32_t unProcessId, const char *pchAppKey ) = 0;
1668
1669               /** Returns the process ID for an application. Return 0 if the application was not found or is not running. */
1670               virtual uint32_t GetApplicationProcessId( const char *pchAppKey ) = 0;
1671
1672               /** Returns a string for an applications error */
1673               virtual const char *GetApplicationsErrorNameFromEnum( EVRApplicationError error ) = 0;
1674
1675               // ---------------  Application properties  --------------- //
1676
1677               /** Returns a value for an application property. The required buffer size to fit this value will be returned. */
1678               virtual uint32_t GetApplicationPropertyString( const char *pchAppKey, EVRApplicationProperty eProperty, VR_OUT_STRING() char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError = nullptr ) = 0;
1679
1680               /** Returns a bool value for an application property. Returns false in all error cases. */
1681               virtual bool GetApplicationPropertyBool( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) = 0;
1682
1683               /** Returns a uint64 value for an application property. Returns 0 in all error cases. */
1684               virtual uint64_t GetApplicationPropertyUint64( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) = 0;
1685
1686               /** Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
1687               virtual EVRApplicationError SetApplicationAutoLaunch( const char *pchAppKey, bool bAutoLaunch ) = 0;
1688
1689               /** Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
1690               virtual bool GetApplicationAutoLaunch( const char *pchAppKey ) = 0;
1691
1692               /** Adds this mime-type to the list of supported mime types for this application*/
1693               virtual EVRApplicationError SetDefaultApplicationForMimeType( const char *pchAppKey, const char *pchMimeType ) = 0;
1694
1695               /** return the app key that will open this mime type */
1696               virtual bool GetDefaultApplicationForMimeType( const char *pchMimeType, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
1697
1698               /** Get the list of supported mime types for this application, comma-delimited */
1699               virtual bool GetApplicationSupportedMimeTypes( const char *pchAppKey, char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer ) = 0;
1700
1701               /** Get the list of app-keys that support this mime type, comma-delimited, the return value is number of bytes you need to return the full string */
1702               virtual uint32_t GetApplicationsThatSupportMimeType( const char *pchMimeType, char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer ) = 0;
1703
1704               /** Get the args list from an app launch that had the process already running, you call this when you get a VREvent_ApplicationMimeTypeLoad */
1705               virtual uint32_t GetApplicationLaunchArguments( uint32_t unHandle, char *pchArgs, uint32_t unArgs ) = 0;
1706
1707               // ---------------  Transition methods --------------- //
1708
1709               /** Returns the app key for the application that is starting up */
1710               virtual EVRApplicationError GetStartingApplication( char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
1711
1712               /** Returns the application transition state */
1713               virtual EVRApplicationTransitionState GetTransitionState() = 0;
1714
1715               /** Returns errors that would prevent the specified application from launching immediately. Calling this function will
1716               * cause the current scene application to quit, so only call it when you are actually about to launch something else.
1717               * What the caller should do about these failures depends on the failure:
1718               *   VRApplicationError_OldApplicationQuitting - An existing application has been told to quit. Wait for a VREvent_ProcessQuit
1719               *                                               and try again.
1720               *   VRApplicationError_ApplicationAlreadyStarting - This application is already starting. This is a permanent failure.
1721               *   VRApplicationError_LaunchInProgress             - A different application is already starting. This is a permanent failure.
1722               *   VRApplicationError_None                   - Go ahead and launch. Everything is clear.
1723               */
1724               virtual EVRApplicationError PerformApplicationPrelaunchCheck( const char *pchAppKey ) = 0;
1725
1726               /** Returns a string for an application transition state */
1727               virtual const char *GetApplicationsTransitionStateNameFromEnum( EVRApplicationTransitionState state ) = 0;
1728
1729               /** Returns true if the outgoing scene app has requested a save prompt before exiting */
1730               virtual bool IsQuitUserPromptRequested() = 0;
1731
1732               /** Starts a subprocess within the calling application. This
1733               * suppresses all application transition UI and automatically identifies the new executable 
1734               * as part of the same application. On success the calling process should exit immediately. 
1735               * If working directory is NULL or "" the directory portion of the binary path will be 
1736               * the working directory. */
1737               virtual EVRApplicationError LaunchInternalProcess( const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory ) = 0;
1738
1739               /** Returns the current scene process ID according to the application system. A scene process will get scene
1740               * focus once it starts rendering, but it will appear here once it calls VR_Init with the Scene application
1741               * type. */
1742               virtual uint32_t GetCurrentSceneProcessId() = 0;
1743        };
1744
1745        static const char * const IVRApplications_Version = "IVRApplications_006";
1746
1747 } // namespace vr
1748
1749 // ivrsettings.h
1750 namespace vr
1751 {
1752        enum EVRSettingsError
1753        {
1754               VRSettingsError_None = 0,
1755               VRSettingsError_IPCFailed = 1,
1756               VRSettingsError_WriteFailed = 2,
1757               VRSettingsError_ReadFailed = 3,
1758               VRSettingsError_JsonParseFailed = 4,
1759               VRSettingsError_UnsetSettingHasNoDefault = 5, // This will be returned if the setting does not appear in the appropriate default file and has not been set
1760        };
1761
1762        // The maximum length of a settings key
1763        static const uint32_t k_unMaxSettingsKeyLength = 128;
1764
1765        class IVRSettings
1766        {
1767        public:
1768               virtual const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) = 0;
1769
1770               // Returns true if file sync occurred (force or settings dirty)
1771               virtual bool Sync( bool bForce = false, EVRSettingsError *peError = nullptr ) = 0;
1772
1773               virtual void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr ) = 0;
1774               virtual void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr ) = 0;
1775               virtual void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr ) = 0;
1776               virtual void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr ) = 0;
1777
1778               // Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
1779               // of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
1780               virtual bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
1781               virtual int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
1782               virtual float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
1783               virtual void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr ) = 0;
1784
1785               virtual void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr ) = 0;
1786               virtual void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
1787        };
1788
1789        //-----------------------------------------------------------------------------
1790        static const char * const IVRSettings_Version = "IVRSettings_002";
1791
1792        //-----------------------------------------------------------------------------
1793        // steamvr keys
1794        static const char * const k_pch_SteamVR_Section = "steamvr";
1795        static const char * const k_pch_SteamVR_RequireHmd_String = "requireHmd";
1796        static const char * const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
1797        static const char * const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
1798        static const char * const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
1799        static const char * const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
1800        static const char * const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
1801        static const char * const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
1802        static const char * const k_pch_SteamVR_SendSystemButtonToAllApps_Bool= "sendSystemButtonToAllApps";
1803        static const char * const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
1804        static const char * const k_pch_SteamVR_IPD_Float = "ipd";
1805        static const char * const k_pch_SteamVR_Background_String = "background";
1806        static const char * const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
1807        static const char * const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
1808        static const char * const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
1809        static const char * const k_pch_SteamVR_GridColor_String = "gridColor";
1810        static const char * const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
1811        static const char * const k_pch_SteamVR_ShowStage_Bool = "showStage";
1812        static const char * const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
1813        static const char * const k_pch_SteamVR_DirectMode_Bool = "directMode";
1814        static const char * const k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
1815        static const char * const k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
1816        static const char * const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
1817        static const char * const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
1818        static const char * const k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
1819        static const char * const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
1820        static const char * const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
1821        static const char * const k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
1822        static const char * const k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
1823        static const char * const k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
1824        static const char * const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
1825        static const char * const k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
1826        static const char * const k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
1827        static const char * const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
1828        static const char * const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
1829        static const char * const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
1830        static const char * const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
1831        static const char * const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
1832        static const char * const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
1833        static const char * const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
1834        static const char * const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
1835        static const char * const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
1836        static const char * const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
1837        static const char * const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
1838
1839        //-----------------------------------------------------------------------------
1840        // lighthouse keys
1841        static const char * const k_pch_Lighthouse_Section = "driver_lighthouse";
1842        static const char * const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
1843        static const char * const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
1844        static const char * const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
1845        static const char * const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
1846        static const char * const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
1847
1848        //-----------------------------------------------------------------------------
1849        // null keys
1850        static const char * const k_pch_Null_Section = "driver_null";
1851        static const char * const k_pch_Null_SerialNumber_String = "serialNumber";
1852        static const char * const k_pch_Null_ModelNumber_String = "modelNumber";
1853        static const char * const k_pch_Null_WindowX_Int32 = "windowX";
1854        static const char * const k_pch_Null_WindowY_Int32 = "windowY";
1855        static const char * const k_pch_Null_WindowWidth_Int32 = "windowWidth";
1856        static const char * const k_pch_Null_WindowHeight_Int32 = "windowHeight";
1857        static const char * const k_pch_Null_RenderWidth_Int32 = "renderWidth";
1858        static const char * const k_pch_Null_RenderHeight_Int32 = "renderHeight";
1859        static const char * const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
1860        static const char * const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
1861
1862        //-----------------------------------------------------------------------------
1863        // user interface keys
1864        static const char * const k_pch_UserInterface_Section = "userinterface";
1865        static const char * const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
1866        static const char * const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
1867        static const char * const k_pch_UserInterface_Screenshots_Bool = "screenshots";
1868        static const char * const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
1869
1870        //-----------------------------------------------------------------------------
1871        // notification keys
1872        static const char * const k_pch_Notifications_Section = "notifications";
1873        static const char * const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
1874
1875        //-----------------------------------------------------------------------------
1876        // keyboard keys
1877        static const char * const k_pch_Keyboard_Section = "keyboard";
1878        static const char * const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
1879        static const char * const k_pch_Keyboard_ScaleX = "ScaleX";
1880        static const char * const k_pch_Keyboard_ScaleY = "ScaleY";
1881        static const char * const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
1882        static const char * const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
1883        static const char * const k_pch_Keyboard_OffsetY = "OffsetY";
1884        static const char * const k_pch_Keyboard_Smoothing = "Smoothing";
1885
1886        //-----------------------------------------------------------------------------
1887        // perf keys
1888        static const char * const k_pch_Perf_Section = "perfcheck";
1889        static const char * const k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
1890        static const char * const k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
1891        static const char * const k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
1892        static const char * const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
1893        static const char * const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
1894        static const char * const k_pch_Perf_TestData_Float = "perfTestData";
1895        static const char * const k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
1896
1897        //-----------------------------------------------------------------------------
1898        // collision bounds keys
1899        static const char * const k_pch_CollisionBounds_Section = "collisionBounds";
1900        static const char * const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
1901        static const char * const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
1902        static const char * const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
1903        static const char * const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
1904        static const char * const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
1905        static const char * const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
1906        static const char * const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
1907        static const char * const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
1908        static const char * const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
1909
1910        //-----------------------------------------------------------------------------
1911        // camera keys
1912        static const char * const k_pch_Camera_Section = "camera";
1913        static const char * const k_pch_Camera_EnableCamera_Bool = "enableCamera";
1914        static const char * const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
1915        static const char * const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
1916        static const char * const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
1917        static const char * const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
1918        static const char * const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
1919        static const char * const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
1920        static const char * const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
1921        static const char * const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
1922
1923        //-----------------------------------------------------------------------------
1924        // audio keys
1925        static const char * const k_pch_audio_Section = "audio";
1926        static const char * const k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
1927        static const char * const k_pch_audio_OnRecordDevice_String = "onRecordDevice";
1928        static const char * const k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
1929        static const char * const k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
1930        static const char * const k_pch_audio_OffRecordDevice_String = "offRecordDevice";
1931        static const char * const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
1932
1933        //-----------------------------------------------------------------------------
1934        // power management keys
1935        static const char * const k_pch_Power_Section = "power";
1936        static const char * const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
1937        static const char * const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
1938        static const char * const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
1939        static const char * const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
1940        static const char * const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
1941        static const char * const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
1942
1943        //-----------------------------------------------------------------------------
1944        // dashboard keys
1945        static const char * const k_pch_Dashboard_Section = "dashboard";
1946        static const char * const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
1947        static const char * const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
1948
1949        //-----------------------------------------------------------------------------
1950        // model skin keys
1951        static const char * const k_pch_modelskin_Section = "modelskins";
1952
1953        //-----------------------------------------------------------------------------
1954        // driver keys - These could be checked in any driver_<name> section
1955        static const char * const k_pch_Driver_Enable_Bool = "enable";
1956
1957 } // namespace vr
1958
1959 // ivrchaperone.h
1960 namespace vr
1961 {
1962
1963 #pragma pack( push, 8 )
1964
1965 enum ChaperoneCalibrationState
1966 {
1967        // OK!
1968        ChaperoneCalibrationState_OK = 1,                                                               // Chaperone is fully calibrated and working correctly
1969
1970        // Warnings
1971        ChaperoneCalibrationState_Warning = 100,
1972        ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,       // A base station thinks that it might have moved
1973        ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,                     // There are less base stations than when calibrated
1974        ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,              // Seated bounds haven't been calibrated for the current tracking center
1975
1976        // Errors
1977        ChaperoneCalibrationState_Error = 200,                                                        // The UniverseID is invalid
1978        ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,              // Tracking center hasn't be calibrated for at least one of the base stations
1979        ChaperoneCalibrationState_Error_BaseStationConflict = 202,                     // Tracking center is calibrated, but base stations disagree on the tracking space
1980        ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,                            // Play Area hasn't been calibrated for the current tracking center
1981        ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,              // Collision Bounds haven't been calibrated for the current tracking center
1982 };
1983
1984
1985 /** HIGH LEVEL TRACKING SPACE ASSUMPTIONS:
1986 * 0,0,0 is the preferred standing area center.
1987 * 0Y is the floor height.
1988 * -Z is the preferred forward facing direction. */
1989 class IVRChaperone
1990 {
1991 public:
1992
1993        /** Get the current state of Chaperone calibration. This state can change at any time during a session due to physical base station changes. **/
1994        virtual ChaperoneCalibrationState GetCalibrationState() = 0;
1995
1996        /** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z. 
1997        * Tracking space center (0,0,0) is the center of the Play Area. **/
1998        virtual bool GetPlayAreaSize( float *pSizeX, float *pSizeZ ) = 0;
1999
2000        /** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds).
2001        * Corners are in counter-clockwise order.
2002        * Standing center (0,0,0) is the center of the Play Area.
2003        * It's a rectangle.
2004        * 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
2005        * Height of every corner is 0Y (on the floor). **/
2006        virtual bool GetPlayAreaRect( HmdQuad_t *rect ) = 0;
2007
2008        /** Reload Chaperone data from the .vrchap file on disk. */
2009        virtual void ReloadInfo( void ) = 0;
2010
2011        /** Optionally give the chaperone system a hit about the color and brightness in the scene **/
2012        virtual void SetSceneColor( HmdColor_t color ) = 0;
2013
2014        /** Get the current chaperone bounds draw color and brightness **/
2015        virtual void GetBoundsColor( HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t *pOutputCameraColor ) = 0;
2016
2017        /** Determine whether the bounds are showing right now **/
2018        virtual bool AreBoundsVisible() = 0;
2019
2020        /** Force the bounds to show, mostly for utilities **/
2021        virtual void ForceBoundsVisible( bool bForce ) = 0;
2022 };
2023
2024 static const char * const IVRChaperone_Version = "IVRChaperone_003";
2025
2026 #pragma pack( pop )
2027
2028 }
2029
2030 // ivrchaperonesetup.h
2031 namespace vr
2032 {
2033
2034 enum EChaperoneConfigFile
2035 {
2036        EChaperoneConfigFile_Live = 1,              // The live chaperone config, used by most applications and games
2037        EChaperoneConfigFile_Temp = 2,              // The temporary chaperone config, used to live-preview collision bounds in room setup
2038 };
2039
2040 enum EChaperoneImportFlags
2041 {
2042        EChaperoneImport_BoundsOnly = 0x0001,
2043 };
2044
2045 /** Manages the working copy of the chaperone info. By default this will be the same as the 
2046 * live copy. Any changes made with this interface will stay in the working copy until 
2047 * CommitWorkingCopy() is called, at which point the working copy and the live copy will be 
2048 * the same again. */
2049 class IVRChaperoneSetup
2050 {
2051 public:
2052
2053        /** Saves the current working copy to disk */
2054        virtual bool CommitWorkingCopy( EChaperoneConfigFile configFile ) = 0;
2055
2056        /** Reverts the working copy to match the live chaperone calibration.
2057        * To modify existing data this MUST be do WHILE getting a non-error ChaperoneCalibrationStatus.
2058        * Only after this should you do gets and sets on the existing data. */
2059        virtual void RevertWorkingCopy() = 0;
2060
2061        /** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z from the working copy.
2062        * Tracking space center (0,0,0) is the center of the Play Area. */
2063        virtual bool GetWorkingPlayAreaSize( float *pSizeX, float *pSizeZ ) = 0;
2064
2065        /** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds) from the working copy.
2066        * Corners are in clockwise order.
2067        * Tracking space center (0,0,0) is the center of the Play Area.
2068        * It's a rectangle.
2069        * 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
2070        * Height of every corner is 0Y (on the floor). **/
2071        virtual bool GetWorkingPlayAreaRect( HmdQuad_t *rect ) = 0;
2072
2073        /** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
2074        * into the buffer up to the max specified from the working copy. */
2075        virtual bool GetWorkingCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
2076
2077        /** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
2078        * into the buffer up to the max specified. */
2079        virtual bool GetLiveCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
2080
2081        /** Returns the preferred seated position from the working copy. */
2082        virtual bool GetWorkingSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) = 0;
2083
2084        /** Returns the standing origin from the working copy. */
2085        virtual bool GetWorkingStandingZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose ) = 0;
2086
2087        /** Sets the Play Area in the working copy. */
2088        virtual void SetWorkingPlayAreaSize( float sizeX, float sizeZ ) = 0;
2089
2090        /** Sets the Collision Bounds in the working copy. */
2091        virtual void SetWorkingCollisionBoundsInfo( VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount ) = 0;
2092
2093        /** Sets the preferred seated position in the working copy. */
2094        virtual void SetWorkingSeatedZeroPoseToRawTrackingPose( const HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose ) = 0;
2095
2096        /** Sets the preferred standing position in the working copy. */
2097        virtual void SetWorkingStandingZeroPoseToRawTrackingPose( const HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose ) = 0;
2098
2099        /** Tear everything down and reload it from the file on disk */
2100        virtual void ReloadFromDisk( EChaperoneConfigFile configFile ) = 0;
2101
2102        /** Returns the preferred seated position. */
2103        virtual bool GetLiveSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) = 0;
2104
2105        virtual void SetWorkingCollisionBoundsTagsInfo( VR_ARRAY_COUNT(unTagCount) uint8_t *pTagsBuffer, uint32_t unTagCount ) = 0;
2106        virtual bool GetLiveCollisionBoundsTagsInfo( VR_OUT_ARRAY_COUNT(punTagCount) uint8_t *pTagsBuffer, uint32_t *punTagCount ) = 0;
2107
2108        virtual bool SetWorkingPhysicalBoundsInfo( VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount ) = 0;
2109        virtual bool GetLivePhysicalBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
2110
2111        virtual bool ExportLiveToBuffer( VR_OUT_STRING() char *pBuffer, uint32_t *pnBufferLength ) = 0;
2112        virtual bool ImportFromBufferToWorking( const char *pBuffer, uint32_t nImportFlags ) = 0;
2113 };
2114
2115 static const char * const IVRChaperoneSetup_Version = "IVRChaperoneSetup_005";
2116
2117
2118 }
2119
2120 // ivrcompositor.h
2121 namespace vr
2122 {
2123
2124 #pragma pack( push, 8 )
2125
2126 /** Errors that can occur with the VR compositor */
2127 enum EVRCompositorError
2128 {
2129        VRCompositorError_None                                          = 0,
2130        VRCompositorError_RequestFailed                            = 1,
2131        VRCompositorError_IncompatibleVersion              = 100,
2132        VRCompositorError_DoNotHaveFocus                     = 101,
2133        VRCompositorError_InvalidTexture                     = 102,
2134        VRCompositorError_IsNotSceneApplication              = 103,
2135        VRCompositorError_TextureIsOnWrongDevice       = 104,
2136        VRCompositorError_TextureUsesUnsupportedFormat = 105,
2137        VRCompositorError_SharedTexturesNotSupported = 106,
2138        VRCompositorError_IndexOutOfRange                     = 107,
2139        VRCompositorError_AlreadySubmitted                     = 108,
2140        VRCompositorError_InvalidBounds                            = 109,
2141 };
2142
2143 const uint32_t VRCompositor_ReprojectionReason_Cpu = 0x01;
2144 const uint32_t VRCompositor_ReprojectionReason_Gpu = 0x02;
2145 const uint32_t VRCompositor_ReprojectionAsync      = 0x04;       // This flag indicates the async reprojection mode is active,
2146                                                                                                          // but does not indicate if reprojection actually happened or not.
2147                                                                                                          // Use the ReprojectionReason flags above to check if reprojection
2148                                                                                                          // was actually applied (i.e. scene texture was reused).
2149                                                                                                          // NumFramePresents > 1 also indicates the scene texture was reused,
2150                                                                                                          // and also the number of times that it was presented in total.
2151
2152 /** Provides a single frame's timing information to the app */
2153 struct Compositor_FrameTiming
2154 {
2155        uint32_t m_nSize; // Set to sizeof( Compositor_FrameTiming )
2156        uint32_t m_nFrameIndex;
2157        uint32_t m_nNumFramePresents; // number of times this frame was presented
2158        uint32_t m_nNumMisPresented; // number of times this frame was presented on a vsync other than it was originally predicted to
2159        uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out
2160        uint32_t m_nReprojectionFlags;
2161
2162        /** Absolute time reference for comparing frames.  This aligns with the vsync that running start is relative to. */
2163        double m_flSystemTimeInSeconds;
2164
2165        /** These times may include work from other processes due to OS scheduling.
2166        * The fewer packets of work these are broken up into, the less likely this will happen.
2167        * GPU work can be broken up by calling Flush.  This can sometimes be useful to get the GPU started
2168        * processing that work earlier in the frame. */
2169        float m_flPreSubmitGpuMs; // time spent rendering the scene (gpu work submitted between WaitGetPoses and second Submit)
2170        float m_flPostSubmitGpuMs; // additional time spent rendering by application (e.g. companion window)
2171        float m_flTotalRenderGpuMs; // time between work submitted immediately after present (ideally vsync) until the end of compositor submitted work
2172        float m_flCompositorRenderGpuMs; // time spend performing distortion correction, rendering chaperone, overlays, etc.
2173        float m_flCompositorRenderCpuMs; // time spent on cpu submitting the above work for this frame
2174        float m_flCompositorIdleCpuMs; // time spent waiting for running start (application could have used this much more time)
2175
2176        /** Miscellaneous measured intervals. */
2177        float m_flClientFrameIntervalMs; // time between calls to WaitGetPoses
2178        float m_flPresentCallCpuMs; // time blocked on call to present (usually 0.0, but can go long)
2179        float m_flWaitForPresentCpuMs; // time spent spin-waiting for frame index to change (not near-zero indicates wait object failure)
2180        float m_flSubmitFrameMs; // time spent in IVRCompositor::Submit (not near-zero indicates driver issue)
2181
2182        /** The following are all relative to this frame's SystemTimeInSeconds */
2183        float m_flWaitGetPosesCalledMs;
2184        float m_flNewPosesReadyMs;
2185        float m_flNewFrameReadyMs; // second call to IVRCompositor::Submit
2186        float m_flCompositorUpdateStartMs;
2187        float m_flCompositorUpdateEndMs;
2188        float m_flCompositorRenderStartMs;
2189
2190        vr::TrackedDevicePose_t m_HmdPose; // pose used by app to render this frame
2191 };
2192
2193 /** Cumulative stats for current application.  These are not cleared until a new app connects,
2194 * but they do stop accumulating once the associated app disconnects. */
2195 struct Compositor_CumulativeStats
2196 {
2197        uint32_t m_nPid; // Process id associated with these stats (may no longer be running).
2198        uint32_t m_nNumFramePresents; // total number of times we called present (includes reprojected frames)
2199        uint32_t m_nNumDroppedFrames; // total number of times an old frame was re-scanned out (without reprojection)
2200        uint32_t m_nNumReprojectedFrames; // total number of times a frame was scanned out a second time (with reprojection)
2201
2202        /** Values recorded at startup before application has fully faded in the first time. */
2203        uint32_t m_nNumFramePresentsOnStartup;
2204        uint32_t m_nNumDroppedFramesOnStartup;
2205        uint32_t m_nNumReprojectedFramesOnStartup;
2206
2207        /** Applications may explicitly fade to the compositor.  This is usually to handle level transitions, and loading often causes
2208        * system wide hitches.  The following stats are collected during this period.  Does not include values recorded during startup. */
2209        uint32_t m_nNumLoading;
2210        uint32_t m_nNumFramePresentsLoading;
2211        uint32_t m_nNumDroppedFramesLoading;
2212        uint32_t m_nNumReprojectedFramesLoading;
2213
2214        /** If we don't get a new frame from the app in less than 2.5 frames, then we assume the app has hung and start
2215        * fading back to the compositor.  The following stats are a result of this, and are a subset of those recorded above.
2216        * Does not include values recorded during start up or loading. */
2217        uint32_t m_nNumTimedOut;
2218        uint32_t m_nNumFramePresentsTimedOut;
2219        uint32_t m_nNumDroppedFramesTimedOut;
2220        uint32_t m_nNumReprojectedFramesTimedOut;
2221 };
2222
2223 #pragma pack( pop )
2224
2225 /** Allows the application to interact with the compositor */
2226 class IVRCompositor
2227 {
2228 public:
2229        /** Sets tracking space returned by WaitGetPoses */
2230        virtual void SetTrackingSpace( ETrackingUniverseOrigin eOrigin ) = 0;
2231
2232        /** Gets current tracking space returned by WaitGetPoses */
2233        virtual ETrackingUniverseOrigin GetTrackingSpace() = 0;
2234
2235        /** Scene applications should call this function to get poses to render with (and optionally poses predicted an additional frame out to use for gameplay).
2236        * This function will block until "running start" milliseconds before the start of the frame, and should be called at the last moment before needing to
2237        * start rendering.
2238        *
2239        * Return codes:
2240        *       - IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
2241        *       - DoNotHaveFocus (some other app has taken focus - this will throttle the call to 10hz to reduce the impact on that app)
2242        */
2243        virtual EVRCompositorError WaitGetPoses( VR_ARRAY_COUNT(unRenderPoseArrayCount) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
2244               VR_ARRAY_COUNT(unGamePoseArrayCount) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) = 0;
2245
2246        /** Get the last set of poses returned by WaitGetPoses. */
2247        virtual EVRCompositorError GetLastPoses( VR_ARRAY_COUNT( unRenderPoseArrayCount ) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
2248               VR_ARRAY_COUNT( unGamePoseArrayCount ) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) = 0;
2249
2250        /** Interface for accessing last set of poses returned by WaitGetPoses one at a time.
2251        * Returns VRCompositorError_IndexOutOfRange if unDeviceIndex not less than k_unMaxTrackedDeviceCount otherwise VRCompositorError_None.
2252        * It is okay to pass NULL for either pose if you only want one of the values. */
2253        virtual EVRCompositorError GetLastPoseForTrackedDeviceIndex( TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose ) = 0;
2254
2255        /** Updated scene texture to display. If pBounds is NULL the entire texture will be used.  If called from an OpenGL app, consider adding a glFlush after
2256        * Submitting both frames to signal the driver to start processing, otherwise it may wait until the command buffer fills up, causing the app to miss frames.
2257        *
2258        * OpenGL dirty state:
2259        *       glBindTexture
2260        *
2261        * Return codes:
2262        *       - IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
2263        *       - DoNotHaveFocus (some other app has taken focus)
2264        *       - TextureIsOnWrongDevice (application did not use proper AdapterIndex - see IVRSystem.GetDXGIOutputInfo)
2265        *       - SharedTexturesNotSupported (application needs to call CreateDXGIFactory1 or later before creating DX device)
2266        *       - TextureUsesUnsupportedFormat (scene textures must be compatible with DXGI sharing rules - e.g. uncompressed, no mips, etc.)
2267        *       - InvalidTexture (usually means bad arguments passed in)
2268        *       - AlreadySubmitted (app has submitted two left textures or two right textures in a single frame - i.e. before calling WaitGetPoses again)
2269        */
2270        virtual EVRCompositorError Submit( EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t* pBounds = 0, EVRSubmitFlags nSubmitFlags = Submit_Default ) = 0;
2271
2272        /** Clears the frame that was sent with the last call to Submit. This will cause the 
2273        * compositor to show the grid until Submit is called again. */
2274        virtual void ClearLastSubmittedFrame() = 0;
2275
2276        /** Call immediately after presenting your app's window (i.e. companion window) to unblock the compositor.
2277        * This is an optional call, which only needs to be used if you can't instead call WaitGetPoses immediately after Present.
2278        * For example, if your engine's render and game loop are not on separate threads, or blocking the render thread until 3ms before the next vsync would
2279        * introduce a deadlock of some sort.  This function tells the compositor that you have finished all rendering after having Submitted buffers for both
2280        * eyes, and it is free to start its rendering work.  This should only be called from the same thread you are rendering on. */
2281        virtual void PostPresentHandoff() = 0;
2282
2283        /** Returns true if timing data is filled it.  Sets oldest timing info if nFramesAgo is larger than the stored history.
2284        * Be sure to set timing.size = sizeof(Compositor_FrameTiming) on struct passed in before calling this function. */
2285        virtual bool GetFrameTiming( Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0 ) = 0;
2286
2287        /** Interface for copying a range of timing data.  Frames are returned in ascending order (oldest to newest) with the last being the most recent frame.
2288        * Only the first entry's m_nSize needs to be set, as the rest will be inferred from that.  Returns total number of entries filled out. */
2289        virtual uint32_t GetFrameTimings( Compositor_FrameTiming *pTiming, uint32_t nFrames ) = 0;
2290
2291        /** Returns the time in seconds left in the current (as identified by FrameTiming's frameIndex) frame.
2292        * Due to "running start", this value may roll over to the next frame before ever reaching 0.0. */
2293        virtual float GetFrameTimeRemaining() = 0;
2294
2295        /** Fills out stats accumulated for the last connected application.  Pass in sizeof( Compositor_CumulativeStats ) as second parameter. */
2296        virtual void GetCumulativeStats( Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes ) = 0;
2297
2298        /** Fades the view on the HMD to the specified color. The fade will take fSeconds, and the color values are between
2299        * 0.0 and 1.0. This color is faded on top of the scene based on the alpha parameter. Removing the fade color instantly 
2300        * would be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ).  Values are in un-premultiplied alpha space. */
2301        virtual void FadeToColor( float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false ) = 0;
2302
2303        /** Get current fade color value. */
2304        virtual HmdColor_t GetCurrentFadeColor( bool bBackground = false ) = 0;
2305
2306        /** Fading the Grid in or out in fSeconds */
2307        virtual void FadeGrid( float fSeconds, bool bFadeIn ) = 0;
2308
2309        /** Get current alpha value of grid. */
2310        virtual float GetCurrentGridAlpha() = 0;
2311
2312        /** Override the skybox used in the compositor (e.g. for during level loads when the app can't feed scene images fast enough)
2313        * Order is Front, Back, Left, Right, Top, Bottom.  If only a single texture is passed, it is assumed in lat-long format.
2314        * If two are passed, it is assumed a lat-long stereo pair. */
2315        virtual EVRCompositorError SetSkyboxOverride( VR_ARRAY_COUNT( unTextureCount ) const Texture_t *pTextures, uint32_t unTextureCount ) = 0;
2316
2317        /** Resets compositor skybox back to defaults. */
2318        virtual void ClearSkyboxOverride() = 0;
2319
2320        /** Brings the compositor window to the front. This is useful for covering any other window that may be on the HMD
2321        * and is obscuring the compositor window. */
2322        virtual void CompositorBringToFront() = 0;
2323
2324        /** Pushes the compositor window to the back. This is useful for allowing other applications to draw directly to the HMD. */
2325        virtual void CompositorGoToBack() = 0;
2326
2327        /** Tells the compositor process to clean up and exit. You do not need to call this function at shutdown. Under normal 
2328        * circumstances the compositor will manage its own life cycle based on what applications are running. */
2329        virtual void CompositorQuit() = 0;
2330        
2331        /** Return whether the compositor is fullscreen */
2332        virtual bool IsFullscreen() = 0;
2333
2334        /** Returns the process ID of the process that is currently rendering the scene */
2335        virtual uint32_t GetCurrentSceneFocusProcess() = 0;
2336
2337        /** Returns the process ID of the process that rendered the last frame (or 0 if the compositor itself rendered the frame.)
2338        * Returns 0 when fading out from an app and the app's process Id when fading into an app. */
2339        virtual uint32_t GetLastFrameRenderer() = 0;
2340
2341        /** Returns true if the current process has the scene focus */
2342        virtual bool CanRenderScene() = 0;
2343
2344        /** Creates a window on the primary monitor to display what is being shown in the headset. */
2345        virtual void ShowMirrorWindow() = 0;
2346
2347        /** Closes the mirror window. */
2348        virtual void HideMirrorWindow() = 0;
2349
2350        /** Returns true if the mirror window is shown. */
2351        virtual bool IsMirrorWindowVisible() = 0;
2352
2353        /** Writes all images that the compositor knows about (including overlays) to a 'screenshots' folder in the SteamVR runtime root. */
2354        virtual void CompositorDumpImages() = 0;
2355
2356        /** Let an app know it should be rendering with low resources. */
2357        virtual bool ShouldAppRenderWithLowResources() = 0;
2358
2359        /** Override interleaved reprojection logic to force on. */
2360        virtual void ForceInterleavedReprojectionOn( bool bOverride ) = 0;
2361
2362        /** Force reconnecting to the compositor process. */
2363        virtual void ForceReconnectProcess() = 0;
2364
2365        /** Temporarily suspends rendering (useful for finer control over scene transitions). */
2366        virtual void SuspendRendering( bool bSuspend ) = 0;
2367
2368        /** Opens a shared D3D11 texture with the undistorted composited image for each eye.  Use ReleaseMirrorTextureD3D11 when finished
2369        * instead of calling Release on the resource itself. */
2370        virtual vr::EVRCompositorError GetMirrorTextureD3D11( vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView ) = 0;
2371        virtual void ReleaseMirrorTextureD3D11( void *pD3D11ShaderResourceView ) = 0;
2372
2373        /** Access to mirror textures from OpenGL. */
2374        virtual vr::EVRCompositorError GetMirrorTextureGL( vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle ) = 0;
2375        virtual bool ReleaseSharedGLTexture( vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
2376        virtual void LockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
2377        virtual void UnlockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
2378
2379        /** [Vulkan Only]
2380        * return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
2381        * null.  The string will be a space separated list of-required instance extensions to enable in VkCreateInstance */
2382        virtual uint32_t GetVulkanInstanceExtensionsRequired( VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
2383
2384        /** [Vulkan only]
2385        * return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
2386        * null.  The string will be a space separated list of required device extensions to enable in VkCreateDevice */
2387        virtual uint32_t GetVulkanDeviceExtensionsRequired( VkPhysicalDevice_T *pPhysicalDevice, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
2388
2389        /** [ Vulkan/D3D12 Only ]
2390        * There are two purposes for SetExplicitTimingMode:
2391        *       1. To get a more accurate GPU timestamp for when the frame begins in Vulkan/D3D12 applications.
2392        *       2. (Optional) To avoid having WaitGetPoses access the Vulkan queue so that the queue can be accessed from
2393        *       another thread while WaitGetPoses is executing.
2394        *
2395        * More accurate GPU timestamp for the start of the frame is achieved by the application calling
2396        * SubmitExplicitTimingData immediately before its first submission to the Vulkan/D3D12 queue.
2397        * This is more accurate because normally this GPU timestamp is recorded during WaitGetPoses.  In D3D11, 
2398        * WaitGetPoses queues a GPU timestamp write, but it does not actually get submitted to the GPU until the 
2399        * application flushes.  By using SubmitExplicitTimingData, the timestamp is recorded at the same place for 
2400        * Vulkan/D3D12 as it is for D3D11, resulting in a more accurate GPU time measurement for the frame.
2401        *
2402        * Avoiding WaitGetPoses accessing the Vulkan queue can be achieved using SetExplicitTimingMode as well.  If this is desired,
2403        * the application *MUST* call PostPresentHandoff itself prior to WaitGetPoses.  If SetExplicitTimingMode is true and the
2404        * application calls PostPresentHandoff, then WaitGetPoses is guaranteed not to access the queue.  Note that PostPresentHandoff
2405        * and SubmitExplicitTimingData will access the queue, so only WaitGetPoses becomes safe for accessing the queue from another
2406        * thread. */
2407        virtual void SetExplicitTimingMode( bool bExplicitTimingMode ) = 0;
2408
2409        /** [ Vulkan/D3D12 Only ]
2410        * Submit explicit timing data.  When SetExplicitTimingMode is true, this must be called immediately before
2411        * the application's first vkQueueSubmit (Vulkan) or ID3D12CommandQueue::ExecuteCommandLists (D3D12) of each frame.
2412        * This function will insert a GPU timestamp write just before the application starts its rendering.  This function
2413        * will perform a vkQueueSubmit on Vulkan so must not be done simultaneously with VkQueue operations on another thread.
2414        * Returns VRCompositorError_RequestFailed if SetExplicitTimingMode is not enabled. */
2415        virtual EVRCompositorError SubmitExplicitTimingData() = 0;
2416 };
2417
2418 static const char * const IVRCompositor_Version = "IVRCompositor_021";
2419
2420 } // namespace vr
2421
2422
2423
2424 // ivrnotifications.h
2425 namespace vr
2426 {
2427
2428 #pragma pack( push, 8 )
2429
2430 // Used for passing graphic data
2431 struct NotificationBitmap_t
2432 {
2433        NotificationBitmap_t()
2434               : m_pImageData( nullptr )
2435               , m_nWidth( 0 )
2436               , m_nHeight( 0 )
2437               , m_nBytesPerPixel( 0 )
2438        {
2439        };
2440
2441        void *m_pImageData;
2442        int32_t m_nWidth;
2443        int32_t m_nHeight;
2444        int32_t m_nBytesPerPixel;
2445 };
2446
2447
2448 /** Be aware that the notification type is used as 'priority' to pick the next notification */
2449 enum EVRNotificationType
2450 {
2451        /** Transient notifications are automatically hidden after a period of time set by the user. 
2452        * They are used for things like information and chat messages that do not require user interaction. */
2453        EVRNotificationType_Transient = 0,
2454
2455        /** Persistent notifications are shown to the user until they are hidden by calling RemoveNotification().
2456        * They are used for things like phone calls and alarms that require user interaction. */
2457        EVRNotificationType_Persistent = 1,
2458
2459        /** System notifications are shown no matter what. It is expected, that the ulUserValue is used as ID.
2460         * If there is already a system notification in the queue with that ID it is not accepted into the queue
2461         * to prevent spamming with system notification */
2462        EVRNotificationType_Transient_SystemWithUserValue = 2,
2463 };
2464
2465 enum EVRNotificationStyle
2466 {
2467        /** Creates a notification with minimal external styling. */
2468        EVRNotificationStyle_None = 0,
2469
2470        /** Used for notifications about overlay-level status. In Steam this is used for events like downloads completing. */
2471        EVRNotificationStyle_Application = 100,
2472
2473        /** Used for notifications about contacts that are unknown or not available. In Steam this is used for friend invitations and offline friends. */
2474        EVRNotificationStyle_Contact_Disabled = 200,
2475
2476        /** Used for notifications about contacts that are available but inactive. In Steam this is used for friends that are online but not playing a game. */
2477        EVRNotificationStyle_Contact_Enabled = 201,
2478
2479        /** Used for notifications about contacts that are available and active. In Steam this is used for friends that are online and currently running a game. */
2480        EVRNotificationStyle_Contact_Active = 202,
2481 };
2482
2483 static const uint32_t k_unNotificationTextMaxSize = 256;
2484
2485 typedef uint32_t VRNotificationId;
2486
2487
2488
2489 #pragma pack( pop )
2490
2491 /** Allows notification sources to interact with the VR system
2492        This current interface is not yet implemented. Do not use yet. */
2493 class IVRNotifications
2494 {
2495 public:
2496        /** Create a notification and enqueue it to be shown to the user.
2497        * An overlay handle is required to create a notification, as otherwise it would be impossible for a user to act on it.
2498        * To create a two-line notification, use a line break ('\n') to split the text into two lines.
2499        * The pImage argument may be NULL, in which case the specified overlay's icon will be used instead. */
2500        virtual EVRNotificationError CreateNotification( VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char *pchText, EVRNotificationStyle style, const NotificationBitmap_t *pImage, /* out */ VRNotificationId *pNotificationId ) = 0;
2501
2502        /** Destroy a notification, hiding it first if it currently shown to the user. */
2503        virtual EVRNotificationError RemoveNotification( VRNotificationId notificationId ) = 0;
2504
2505 };
2506
2507 static const char * const IVRNotifications_Version = "IVRNotifications_002";
2508
2509 } // namespace vr
2510
2511
2512
2513 // ivroverlay.h
2514 namespace vr
2515 {
2516
2517        /** The maximum length of an overlay key in bytes, counting the terminating null character. */
2518        static const uint32_t k_unVROverlayMaxKeyLength = 128;
2519
2520        /** The maximum length of an overlay name in bytes, counting the terminating null character. */
2521        static const uint32_t k_unVROverlayMaxNameLength = 128;
2522
2523        /** The maximum number of overlays that can exist in the system at one time. */
2524        static const uint32_t k_unMaxOverlayCount = 64;
2525
2526        /** The maximum number of overlay intersection mask primitives per overlay */
2527        static const uint32_t k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
2528
2529        /** Types of input supported by VR Overlays */
2530        enum VROverlayInputMethod
2531        {
2532               VROverlayInputMethod_None              = 0, // No input events will be generated automatically for this overlay
2533               VROverlayInputMethod_Mouse              = 1, // Tracked controllers will get mouse events automatically
2534        };
2535
2536        /** Allows the caller to figure out which overlay transform getter to call. */
2537        enum VROverlayTransformType
2538        {
2539               VROverlayTransform_Absolute                                   = 0,
2540               VROverlayTransform_TrackedDeviceRelative       = 1,
2541               VROverlayTransform_SystemOverlay                     = 2,
2542               VROverlayTransform_TrackedComponent               = 3,
2543        };
2544
2545        /** Overlay control settings */
2546        enum VROverlayFlags
2547        {
2548               VROverlayFlags_None                     = 0,
2549
2550               // The following only take effect when rendered using the high quality render path (see SetHighQualityOverlay).
2551               VROverlayFlags_Curved              = 1,
2552               VROverlayFlags_RGSS4X              = 2,
2553
2554               // Set this flag on a dashboard overlay to prevent a tab from showing up for that overlay
2555               VROverlayFlags_NoDashboardTab = 3,
2556
2557               // Set this flag on a dashboard that is able to deal with gamepad focus events
2558               VROverlayFlags_AcceptsGamepadEvents = 4,
2559
2560               // Indicates that the overlay should dim/brighten to show gamepad focus
2561               VROverlayFlags_ShowGamepadFocus = 5,
2562
2563               // When in VROverlayInputMethod_Mouse you can optionally enable sending VRScroll_t 
2564               VROverlayFlags_SendVRScrollEvents = 6,
2565               VROverlayFlags_SendVRTouchpadEvents = 7,
2566
2567               // If set this will render a vertical scroll wheel on the primary controller, 
2568               //  only needed if not using VROverlayFlags_SendVRScrollEvents but you still want to represent a scroll wheel
2569               VROverlayFlags_ShowTouchPadScrollWheel = 8,
2570
2571               // If this is set ownership and render access to the overlay are transferred 
2572               // to the new scene process on a call to IVRApplications::LaunchInternalProcess
2573               VROverlayFlags_TransferOwnershipToInternalProcess = 9,
2574
2575               // If set, renders 50% of the texture in each eye, side by side
2576               VROverlayFlags_SideBySide_Parallel = 10, // Texture is left/right
2577               VROverlayFlags_SideBySide_Crossed = 11, // Texture is crossed and right/left
2578
2579               VROverlayFlags_Panorama = 12, // Texture is a panorama
2580               VROverlayFlags_StereoPanorama = 13, // Texture is a stereo panorama
2581
2582               // If this is set on an overlay owned by the scene application that overlay
2583               // will be sorted with the "Other" overlays on top of all other scene overlays
2584               VROverlayFlags_SortWithNonSceneOverlays = 14,
2585
2586               // If set, the overlay will be shown in the dashboard, otherwise it will be hidden.
2587               VROverlayFlags_VisibleInDashboard = 15,
2588        };
2589
2590        enum VRMessageOverlayResponse
2591        {
2592               VRMessageOverlayResponse_ButtonPress_0 = 0,
2593               VRMessageOverlayResponse_ButtonPress_1 = 1,
2594               VRMessageOverlayResponse_ButtonPress_2 = 2,
2595               VRMessageOverlayResponse_ButtonPress_3 = 3,
2596               VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
2597               VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay= 5,
2598               VRMessageOverlayResponse_ApplicationQuit = 6
2599        };
2600
2601        struct VROverlayIntersectionParams_t
2602        {
2603               HmdVector3_t vSource;
2604               HmdVector3_t vDirection;
2605               ETrackingUniverseOrigin eOrigin;
2606        };
2607
2608        struct VROverlayIntersectionResults_t
2609        {
2610               HmdVector3_t vPoint;
2611               HmdVector3_t vNormal;
2612               HmdVector2_t vUVs;
2613               float fDistance;
2614        };
2615
2616        // Input modes for the Big Picture gamepad text entry
2617        enum EGamepadTextInputMode
2618        {
2619               k_EGamepadTextInputModeNormal = 0,
2620               k_EGamepadTextInputModePassword = 1,
2621               k_EGamepadTextInputModeSubmit = 2,
2622        };
2623
2624        // Controls number of allowed lines for the Big Picture gamepad text entry
2625        enum EGamepadTextInputLineMode
2626        {
2627               k_EGamepadTextInputLineModeSingleLine = 0,
2628               k_EGamepadTextInputLineModeMultipleLines = 1
2629        };
2630
2631        /** Directions for changing focus between overlays with the gamepad */
2632        enum EOverlayDirection
2633        {
2634               OverlayDirection_Up = 0,
2635               OverlayDirection_Down = 1,
2636               OverlayDirection_Left = 2,
2637               OverlayDirection_Right = 3,
2638               
2639               OverlayDirection_Count = 4,
2640        };
2641
2642        enum EVROverlayIntersectionMaskPrimitiveType
2643        {
2644               OverlayIntersectionPrimitiveType_Rectangle,
2645               OverlayIntersectionPrimitiveType_Circle,
2646        };
2647
2648        struct IntersectionMaskRectangle_t
2649        {
2650               float m_flTopLeftX;
2651               float m_flTopLeftY;
2652               float m_flWidth;
2653               float m_flHeight;
2654        };
2655
2656        struct IntersectionMaskCircle_t
2657        {
2658               float m_flCenterX;
2659               float m_flCenterY;
2660               float m_flRadius;
2661        };
2662
2663        /** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py and openvr_api_flat.h.py */
2664        typedef union
2665        {
2666               IntersectionMaskRectangle_t m_Rectangle;
2667               IntersectionMaskCircle_t m_Circle;
2668        } VROverlayIntersectionMaskPrimitive_Data_t;
2669
2670        struct VROverlayIntersectionMaskPrimitive_t
2671        {
2672               EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
2673               VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
2674        };
2675
2676        class IVROverlay
2677        {
2678        public:
2679
2680               // ---------------------------------------------
2681               // Overlay management methods
2682               // ---------------------------------------------
2683
2684               /** Finds an existing overlay with the specified key. */
2685               virtual EVROverlayError FindOverlay( const char *pchOverlayKey, VROverlayHandle_t * pOverlayHandle ) = 0;
2686
2687               /** Creates a new named overlay. All overlays start hidden and with default settings. */
2688               virtual EVROverlayError CreateOverlay( const char *pchOverlayKey, const char *pchOverlayName, VROverlayHandle_t * pOverlayHandle ) = 0;
2689
2690               /** Destroys the specified overlay. When an application calls VR_Shutdown all overlays created by that app are
2691               * automatically destroyed. */
2692               virtual EVROverlayError DestroyOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
2693
2694               /** Specify which overlay to use the high quality render path.  This overlay will be composited in during the distortion pass which
2695               * results in it drawing on top of everything else, but also at a higher quality as it samples the source texture directly rather than
2696               * rasterizing into each eye's render texture first.  Because if this, only one of these is supported at any given time.  It is most useful
2697               * for overlays that are expected to take up most of the user's view (e.g. streaming video).
2698               * This mode does not support mouse input to your overlay. */
2699               virtual EVROverlayError SetHighQualityOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
2700
2701               /** Returns the overlay handle of the current overlay being rendered using the single high quality overlay render path.
2702               * Otherwise it will return k_ulOverlayHandleInvalid. */
2703               virtual vr::VROverlayHandle_t GetHighQualityOverlay() = 0;
2704
2705               /** Fills the provided buffer with the string key of the overlay. Returns the size of buffer required to store the key, including
2706               * the terminating null character. k_unVROverlayMaxKeyLength will be enough bytes to fit the string. */
2707               virtual uint32_t GetOverlayKey( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L ) = 0;
2708
2709               /** Fills the provided buffer with the friendly name of the overlay. Returns the size of buffer required to store the key, including
2710               * the terminating null character. k_unVROverlayMaxNameLength will be enough bytes to fit the string. */
2711               virtual uint32_t GetOverlayName( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L ) = 0;
2712
2713               /** set the name to use for this overlay */
2714               virtual EVROverlayError SetOverlayName( VROverlayHandle_t ulOverlayHandle, const char *pchName ) = 0;
2715
2716               /** Gets the raw image data from an overlay. Overlay image data is always returned as RGBA data, 4 bytes per pixel. If the buffer is not large enough, width and height 
2717               * will be set and VROverlayError_ArrayTooSmall is returned. */
2718               virtual EVROverlayError GetOverlayImageData( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight ) = 0;
2719
2720               /** returns a string that corresponds with the specified overlay error. The string will be the name 
2721               * of the error enum value for all valid error codes */
2722               virtual const char *GetOverlayErrorNameFromEnum( EVROverlayError error ) = 0;
2723
2724               // ---------------------------------------------
2725               // Overlay rendering methods
2726               // ---------------------------------------------
2727
2728               /** Sets the pid that is allowed to render to this overlay (the creator pid is always allow to render),
2729               *       by default this is the pid of the process that made the overlay */
2730               virtual EVROverlayError SetOverlayRenderingPid( VROverlayHandle_t ulOverlayHandle, uint32_t unPID ) = 0;
2731
2732               /** Gets the pid that is allowed to render to this overlay */
2733               virtual uint32_t GetOverlayRenderingPid( VROverlayHandle_t ulOverlayHandle ) = 0;
2734
2735               /** Specify flag setting for a given overlay */
2736               virtual EVROverlayError SetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled ) = 0;
2737
2738               /** Sets flag setting for a given overlay */
2739               virtual EVROverlayError GetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled ) = 0;
2740
2741               /** Sets the color tint of the overlay quad. Use 0.0 to 1.0 per channel. */
2742               virtual EVROverlayError SetOverlayColor( VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue ) = 0;
2743
2744               /** Gets the color tint of the overlay quad. */
2745               virtual EVROverlayError GetOverlayColor( VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue ) = 0;
2746
2747               /** Sets the alpha of the overlay quad. Use 1.0 for 100 percent opacity to 0.0 for 0 percent opacity. */
2748               virtual EVROverlayError SetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float fAlpha ) = 0;
2749
2750               /** Gets the alpha of the overlay quad. By default overlays are rendering at 100 percent alpha (1.0). */
2751               virtual EVROverlayError GetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float *pfAlpha ) = 0;
2752
2753               /** Sets the aspect ratio of the texels in the overlay. 1.0 means the texels are square. 2.0 means the texels
2754               * are twice as wide as they are tall. Defaults to 1.0. */
2755               virtual EVROverlayError SetOverlayTexelAspect( VROverlayHandle_t ulOverlayHandle, float fTexelAspect ) = 0;
2756
2757               /** Gets the aspect ratio of the texels in the overlay. Defaults to 1.0 */
2758               virtual EVROverlayError GetOverlayTexelAspect( VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect ) = 0;
2759
2760               /** Sets the rendering sort order for the overlay. Overlays are rendered this order:
2761               *      Overlays owned by the scene application
2762               *      Overlays owned by some other application
2763               *
2764               *       Within a category overlays are rendered lowest sort order to highest sort order. Overlays with the same 
2765               *       sort order are rendered back to front base on distance from the HMD.
2766               *
2767               *       Sort order defaults to 0. */
2768               virtual EVROverlayError SetOverlaySortOrder( VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder ) = 0;
2769
2770               /** Gets the sort order of the overlay. See SetOverlaySortOrder for how this works. */
2771               virtual EVROverlayError GetOverlaySortOrder( VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder ) = 0;
2772
2773               /** Sets the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
2774               virtual EVROverlayError SetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float fWidthInMeters ) = 0;
2775
2776               /** Returns the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
2777               virtual EVROverlayError GetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters ) = 0;
2778
2779               /** For high-quality curved overlays only, sets the distance range in meters from the overlay used to automatically curve
2780               * the surface around the viewer.  Min is distance is when the surface will be most curved.  Max is when least curved. */
2781               virtual EVROverlayError SetOverlayAutoCurveDistanceRangeInMeters( VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters ) = 0;
2782
2783               /** For high-quality curved overlays only, gets the distance range in meters from the overlay used to automatically curve
2784               * the surface around the viewer.  Min is distance is when the surface will be most curved.  Max is when least curved. */
2785               virtual EVROverlayError GetOverlayAutoCurveDistanceRangeInMeters( VROverlayHandle_t ulOverlayHandle, float *pfMinDistanceInMeters, float *pfMaxDistanceInMeters ) = 0;
2786
2787               /** Sets the colorspace the overlay texture's data is in.  Defaults to 'auto'.
2788               * If the texture needs to be resolved, you should call SetOverlayTexture with the appropriate colorspace instead. */
2789               virtual EVROverlayError SetOverlayTextureColorSpace( VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace ) = 0;
2790
2791               /** Gets the overlay's current colorspace setting. */
2792               virtual EVROverlayError GetOverlayTextureColorSpace( VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace ) = 0;
2793
2794               /** Sets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
2795               virtual EVROverlayError SetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, const VRTextureBounds_t *pOverlayTextureBounds ) = 0;
2796
2797               /** Gets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
2798               virtual EVROverlayError GetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t *pOverlayTextureBounds ) = 0;
2799
2800               /** Gets render model to draw behind this overlay */
2801               virtual uint32_t GetOverlayRenderModel( vr::VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, HmdColor_t *pColor, vr::EVROverlayError *pError ) = 0;
2802
2803               /** Sets render model to draw behind this overlay and the vertex color to use, pass null for pColor to match the overlays vertex color. 
2804                      The model is scaled by the same amount as the overlay, with a default of 1m. */
2805               virtual vr::EVROverlayError SetOverlayRenderModel( vr::VROverlayHandle_t ulOverlayHandle, const char *pchRenderModel, const HmdColor_t *pColor ) = 0;
2806
2807               /** Returns the transform type of this overlay. */
2808               virtual EVROverlayError GetOverlayTransformType( VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType ) = 0;
2809
2810               /** Sets the transform to absolute tracking origin. */
2811               virtual EVROverlayError SetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) = 0;
2812
2813               /** Gets the transform if it is absolute. Returns an error if the transform is some other type. */
2814               virtual EVROverlayError GetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) = 0;
2815
2816               /** Sets the transform to relative to the transform of the specified tracked device. */
2817               virtual EVROverlayError SetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, const HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) = 0;
2818
2819               /** Gets the transform if it is relative to a tracked device. Returns an error if the transform is some other type. */
2820               virtual EVROverlayError GetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) = 0;
2821
2822               /** Sets the transform to draw the overlay on a rendermodel component mesh instead of a quad. This will only draw when the system is
2823               * drawing the device. Overlays with this transform type cannot receive mouse events. */
2824               virtual EVROverlayError SetOverlayTransformTrackedDeviceComponent( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char *pchComponentName ) = 0;
2825
2826               /** Gets the transform information when the overlay is rendering on a component. */
2827               virtual EVROverlayError GetOverlayTransformTrackedDeviceComponent( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, char *pchComponentName, uint32_t unComponentNameSize ) = 0;
2828
2829               /** Gets the transform if it is relative to another overlay. Returns an error if the transform is some other type. */
2830               virtual vr::EVROverlayError GetOverlayTransformOverlayRelative( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, HmdMatrix34_t *pmatParentOverlayToOverlayTransform ) = 0;
2831               
2832               /** Sets the transform to relative to the transform of the specified overlay. This overlays visibility will also track the parents visibility */
2833               virtual vr::EVROverlayError SetOverlayTransformOverlayRelative( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, const HmdMatrix34_t *pmatParentOverlayToOverlayTransform ) = 0;
2834
2835               /** Shows the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
2836               virtual EVROverlayError ShowOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
2837
2838               /** Hides the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
2839               virtual EVROverlayError HideOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
2840
2841               /** Returns true if the overlay is visible. */
2842               virtual bool IsOverlayVisible( VROverlayHandle_t ulOverlayHandle ) = 0;
2843
2844               /** Get the transform in 3d space associated with a specific 2d point in the overlay's coordinate space (where 0,0 is the lower left). -Z points out of the overlay */
2845               virtual EVROverlayError GetTransformForOverlayCoordinates( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t *pmatTransform ) = 0;
2846
2847               // ---------------------------------------------
2848               // Overlay input methods
2849               // ---------------------------------------------
2850
2851               /** Returns true and fills the event with the next event on the overlay's event queue, if there is one. 
2852               * If there are no events this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
2853               virtual bool PollNextOverlayEvent( VROverlayHandle_t ulOverlayHandle, VREvent_t *pEvent, uint32_t uncbVREvent ) = 0;
2854
2855               /** Returns the current input settings for the specified overlay. */
2856               virtual EVROverlayError GetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod ) = 0;
2857
2858               /** Sets the input settings for the specified overlay. */
2859               virtual EVROverlayError SetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod ) = 0;
2860
2861               /** Gets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
2862               * typically the size of the underlying UI in pixels. */
2863               virtual EVROverlayError GetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvecMouseScale ) = 0;
2864
2865               /** Sets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
2866               * typically the size of the underlying UI in pixels (not in world space). */
2867               virtual EVROverlayError SetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvecMouseScale ) = 0;
2868
2869               /** Computes the overlay-space pixel coordinates of where the ray intersects the overlay with the
2870               * specified settings. Returns false if there is no intersection. */
2871               virtual bool ComputeOverlayIntersection( VROverlayHandle_t ulOverlayHandle, const VROverlayIntersectionParams_t *pParams, VROverlayIntersectionResults_t *pResults ) = 0;
2872
2873               /** Processes mouse input from the specified controller as though it were a mouse pointed at a compositor overlay with the
2874               * specified settings. The controller is treated like a laser pointer on the -z axis. The point where the laser pointer would
2875               * intersect with the overlay is the mouse position, the trigger is left mouse, and the track pad is right mouse. 
2876               *
2877               * Return true if the controller is pointed at the overlay and an event was generated. */
2878               virtual bool HandleControllerOverlayInteractionAsMouse( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex ) = 0;
2879
2880               /** Returns true if the specified overlay is the hover target. An overlay is the hover target when it is the last overlay "moused over" 
2881               * by the virtual mouse pointer */
2882               virtual bool IsHoverTargetOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
2883
2884               /** Returns the current Gamepad focus overlay */
2885               virtual vr::VROverlayHandle_t GetGamepadFocusOverlay() = 0;
2886
2887               /** Sets the current Gamepad focus overlay */
2888               virtual EVROverlayError SetGamepadFocusOverlay( VROverlayHandle_t ulNewFocusOverlay ) = 0;
2889
2890               /** Sets an overlay's neighbor. This will also set the neighbor of the "to" overlay
2891               * to point back to the "from" overlay. If an overlay's neighbor is set to invalid both
2892               * ends will be cleared */
2893               virtual EVROverlayError SetOverlayNeighbor( EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo ) = 0;
2894
2895               /** Changes the Gamepad focus from one overlay to one of its neighbors. Returns VROverlayError_NoNeighbor if there is no
2896               * neighbor in that direction */
2897               virtual EVROverlayError MoveGamepadFocusToNeighbor( EOverlayDirection eDirection, VROverlayHandle_t ulFrom ) = 0;