openvr_mingw.h

Go to the documentation of this file.

#pragma once
 
// openvr.h
//========= Copyright Valve Corporation ============//
// Dynamically generated file. Do not modify this file directly.
 
#ifndef _OPENVR_API
#define _OPENVR_API
 
#include <stdint.h>
 
 
 
// vrtypes.h
#ifndef _INCLUDE_VRTYPES_H
#define _INCLUDE_VRTYPES_H
 
// Forward declarations to avoid requiring vulkan.h
struct VkDevice_T;
struct VkPhysicalDevice_T;
struct VkInstance_T;
struct VkQueue_T;
 
// Forward declarations to avoid requiring d3d12.h
struct ID3D12Resource;
struct ID3D12CommandQueue;
 
namespace vr
{
#pragma pack( push, 8 )
 
typedef void* glSharedTextureHandle_t;
typedef int32_t glInt_t;
typedef uint32_t glUInt_t;
 
// right-handed system
// +y is up
// +x is to the right
// -z is forward
// Distance unit is  meters
struct HmdMatrix34_t
{
    float m[3][4];
};
 
struct HmdMatrix44_t
{
    float m[4][4];
};
 
struct HmdVector3_t
{
    float v[3];
};
 
struct HmdVector4_t
{
    float v[4];
};
 
struct HmdVector3d_t
{
    double v[3];
};
 
struct HmdVector2_t
{
    float v[2];
};
 
struct HmdQuaternion_t
{
    double w, x, y, z;
};
 
struct HmdColor_t
{
    float r, g, b, a;
};
 
struct HmdQuad_t
{
    HmdVector3_t vCorners[ 4 ];
};
 
struct HmdRect2_t
{
    HmdVector2_t vTopLeft;
    HmdVector2_t vBottomRight;
};

struct DistortionCoordinates_t
{
    float rfRed[2];
    float rfGreen[2];
    float rfBlue[2];
};
 
enum EVREye
{
    Eye_Left = 0,
    Eye_Right = 1
};
 
enum ETextureType
{
    TextureType_DirectX = 0, // Handle is an ID3D11Texture
    TextureType_OpenGL = 1,  // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
    TextureType_Vulkan = 2, // Handle is a pointer to a VRVulkanTextureData_t structure
    TextureType_IOSurface = 3, // Handle is a macOS cross-process-sharable IOSurfaceRef
    TextureType_DirectX12 = 4, // Handle is a pointer to a D3D12TextureData_t structure
};
 
enum EColorSpace
{
    ColorSpace_Auto = 0,    // Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
    ColorSpace_Gamma = 1,   // Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
    ColorSpace_Linear = 2,  // Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
};
 
struct Texture_t
{
    void* handle; // See ETextureType definition above
    ETextureType eType;
    EColorSpace eColorSpace;
};
 
// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
typedef uint64_t SharedTextureHandle_t;
#define INVALID_SHARED_TEXTURE_HANDLE   ((vr::SharedTextureHandle_t)0)
 
enum ETrackingResult
{
    TrackingResult_Uninitialized            = 1,
 
    TrackingResult_Calibrating_InProgress   = 100,
    TrackingResult_Calibrating_OutOfRange   = 101,
 
    TrackingResult_Running_OK               = 200,
    TrackingResult_Running_OutOfRange       = 201,
};
 
typedef uint32_t DriverId_t;
static const uint32_t k_nDriverNone = 0xFFFFFFFF;
 
static const uint32_t k_unMaxDriverDebugResponseSize = 32768;

typedef uint32_t TrackedDeviceIndex_t;
static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
static const uint32_t k_unMaxTrackedDeviceCount = 64;
static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;

enum ETrackedDeviceClass
{
    TrackedDeviceClass_Invalid = 0,             // the ID was not valid.
    TrackedDeviceClass_HMD = 1,                 // Head-Mounted Displays
    TrackedDeviceClass_Controller = 2,          // Tracked controllers
    TrackedDeviceClass_GenericTracker = 3,      // Generic trackers, similar to controllers
    TrackedDeviceClass_TrackingReference = 4,   // Camera and base stations that serve as tracking reference points
    TrackedDeviceClass_DisplayRedirect = 5,     // Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
};
 

enum ETrackedControllerRole
{
    TrackedControllerRole_Invalid = 0,                  // Invalid value for controller type
    TrackedControllerRole_LeftHand = 1,                 // Tracked device associated with the left hand
    TrackedControllerRole_RightHand = 2,                // Tracked device associated with the right hand
};
 

struct TrackedDevicePose_t
{
    HmdMatrix34_t mDeviceToAbsoluteTracking;
    HmdVector3_t vVelocity;             // velocity in tracker space in m/s
    HmdVector3_t vAngularVelocity;      // angular velocity in radians/s (?)
    ETrackingResult eTrackingResult;
    bool bPoseIsValid;
 
    // This indicates that there is a device connected for this spot in the pose array.
    // It could go from true to false if the user unplugs the device.
    bool bDeviceIsConnected;
};

enum ETrackingUniverseOrigin
{
    TrackingUniverseSeated = 0,     // Poses are provided relative to the seated zero pose
    TrackingUniverseStanding = 1,   // Poses are provided relative to the safe bounds configured by the user
    TrackingUniverseRawAndUncalibrated = 2, // Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
};
 
// Refers to a single container of properties
typedef uint64_t PropertyContainerHandle_t;
typedef uint32_t PropertyTypeTag_t;
 
static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
 
// Use these tags to set/get common types as struct properties
static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
static const PropertyTypeTag_t k_unStringPropertyTag = 5;
 
static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
 
static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
static const PropertyTypeTag_t k_unPathHandleInfoTag = 31;
static const PropertyTypeTag_t k_unActionPropertyTag = 32;
static const PropertyTypeTag_t k_unInputValuePropertyTag = 33;
static const PropertyTypeTag_t k_unWildcardPropertyTag = 34;
static const PropertyTypeTag_t k_unHapticVibrationPropertyTag = 35;
 
static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
 

enum ETrackedDeviceProperty
{
    Prop_Invalid                                = 0,
 
    // general properties that apply to all device classes
    Prop_TrackingSystemName_String              = 1000,
    Prop_ModelNumber_String                     = 1001,
    Prop_SerialNumber_String                    = 1002,
    Prop_RenderModelName_String                 = 1003,
    Prop_WillDriftInYaw_Bool                    = 1004,
    Prop_ManufacturerName_String                = 1005,
    Prop_TrackingFirmwareVersion_String         = 1006,
    Prop_HardwareRevision_String                = 1007,
    Prop_AllWirelessDongleDescriptions_String   = 1008,
    Prop_ConnectedWirelessDongle_String         = 1009,
    Prop_DeviceIsWireless_Bool                  = 1010,
    Prop_DeviceIsCharging_Bool                  = 1011,
    Prop_DeviceBatteryPercentage_Float          = 1012, // 0 is empty, 1 is full
    Prop_StatusDisplayTransform_Matrix34        = 1013,
    Prop_Firmware_UpdateAvailable_Bool          = 1014,
    Prop_Firmware_ManualUpdate_Bool             = 1015,
    Prop_Firmware_ManualUpdateURL_String        = 1016,
    Prop_HardwareRevision_Uint64                = 1017,
    Prop_FirmwareVersion_Uint64                 = 1018,
    Prop_FPGAVersion_Uint64                     = 1019,
    Prop_VRCVersion_Uint64                      = 1020,
    Prop_RadioVersion_Uint64                    = 1021,
    Prop_DongleVersion_Uint64                   = 1022,
    Prop_BlockServerShutdown_Bool               = 1023,
    Prop_CanUnifyCoordinateSystemWithHmd_Bool   = 1024,
    Prop_ContainsProximitySensor_Bool           = 1025,
    Prop_DeviceProvidesBatteryStatus_Bool       = 1026,
    Prop_DeviceCanPowerOff_Bool                 = 1027,
    Prop_Firmware_ProgrammingTarget_String      = 1028,
    Prop_DeviceClass_Int32                      = 1029,
    Prop_HasCamera_Bool                         = 1030,
    Prop_DriverVersion_String                   = 1031,
    Prop_Firmware_ForceUpdateRequired_Bool      = 1032,
    Prop_ViveSystemButtonFixRequired_Bool       = 1033,
    Prop_ParentDriver_Uint64                    = 1034,
    Prop_ResourceRoot_String                    = 1035,
    Prop_RegisteredDeviceType_String            = 1036,
    Prop_InputProfilePath_String                = 1037, // input profile to use for this device in the input system. Will default to tracking system name if this isn't provided
 
    // Properties that are unique to TrackedDeviceClass_HMD
    Prop_ReportsTimeSinceVSync_Bool             = 2000,
    Prop_SecondsFromVsyncToPhotons_Float        = 2001,
    Prop_DisplayFrequency_Float                 = 2002,
    Prop_UserIpdMeters_Float                    = 2003,
    Prop_CurrentUniverseId_Uint64               = 2004, 
    Prop_PreviousUniverseId_Uint64              = 2005, 
    Prop_DisplayFirmwareVersion_Uint64          = 2006,
    Prop_IsOnDesktop_Bool                       = 2007,
    Prop_DisplayMCType_Int32                    = 2008,
    Prop_DisplayMCOffset_Float                  = 2009,
    Prop_DisplayMCScale_Float                   = 2010,
    Prop_EdidVendorID_Int32                     = 2011,
    Prop_DisplayMCImageLeft_String              = 2012,
    Prop_DisplayMCImageRight_String             = 2013,
    Prop_DisplayGCBlackClamp_Float              = 2014,
    Prop_EdidProductID_Int32                    = 2015,
    Prop_CameraToHeadTransform_Matrix34         = 2016,
    Prop_DisplayGCType_Int32                    = 2017,
    Prop_DisplayGCOffset_Float                  = 2018,
    Prop_DisplayGCScale_Float                   = 2019,
    Prop_DisplayGCPrescale_Float                = 2020,
    Prop_DisplayGCImage_String                  = 2021,
    Prop_LensCenterLeftU_Float                  = 2022,
    Prop_LensCenterLeftV_Float                  = 2023,
    Prop_LensCenterRightU_Float                 = 2024,
    Prop_LensCenterRightV_Float                 = 2025,
    Prop_UserHeadToEyeDepthMeters_Float         = 2026,
    Prop_CameraFirmwareVersion_Uint64           = 2027,
    Prop_CameraFirmwareDescription_String       = 2028,
    Prop_DisplayFPGAVersion_Uint64              = 2029,
    Prop_DisplayBootloaderVersion_Uint64        = 2030,
    Prop_DisplayHardwareVersion_Uint64          = 2031,
    Prop_AudioFirmwareVersion_Uint64            = 2032,
    Prop_CameraCompatibilityMode_Int32          = 2033,
    Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
    Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
    Prop_DisplaySuppressed_Bool                 = 2036,
    Prop_DisplayAllowNightMode_Bool             = 2037,
    Prop_DisplayMCImageWidth_Int32              = 2038,
    Prop_DisplayMCImageHeight_Int32             = 2039,
    Prop_DisplayMCImageNumChannels_Int32        = 2040,
    Prop_DisplayMCImageData_Binary              = 2041,
    Prop_SecondsFromPhotonsToVblank_Float       = 2042,
    Prop_DriverDirectModeSendsVsyncEvents_Bool  = 2043,
    Prop_DisplayDebugMode_Bool                  = 2044,
    Prop_GraphicsAdapterLuid_Uint64             = 2045,
    Prop_DriverProvidedChaperonePath_String     = 2048,
    Prop_ExpectedTrackingReferenceCount_Int32   = 2049, // expected number of sensors or basestations to reserve UI space for
    Prop_ExpectedControllerCount_Int32          = 2050, // expected number of tracked controllers to reserve UI space for
    Prop_NamedIconPathControllerLeftDeviceOff_String    = 2051, // placeholder icon for "left" controller if not yet detected/loaded
    Prop_NamedIconPathControllerRightDeviceOff_String   = 2052, // placeholder icon for "right" controller if not yet detected/loaded
    Prop_NamedIconPathTrackingReferenceDeviceOff_String = 2053, // placeholder icon for sensor/base if not yet detected/loaded
    Prop_DoNotApplyPrediction_Bool              = 2054,
    Prop_CameraToHeadTransforms_Matrix34_Array  = 2055,
    Prop_DriverIsDrawingControllers_Bool        = 2057,
    Prop_DriverRequestsApplicationPause_Bool    = 2058,
    Prop_DriverRequestsReducedRendering_Bool    = 2059,
 
    // Properties that are unique to TrackedDeviceClass_Controller
    Prop_AttachedDeviceId_String                = 3000,
    Prop_SupportedButtons_Uint64                = 3001,
    Prop_Axis0Type_Int32                        = 3002, // Return value is of type EVRControllerAxisType
    Prop_Axis1Type_Int32                        = 3003, // Return value is of type EVRControllerAxisType
    Prop_Axis2Type_Int32                        = 3004, // Return value is of type EVRControllerAxisType
    Prop_Axis3Type_Int32                        = 3005, // Return value is of type EVRControllerAxisType
    Prop_Axis4Type_Int32                        = 3006, // Return value is of type EVRControllerAxisType
    Prop_ControllerRoleHint_Int32               = 3007, // Return value is of type ETrackedControllerRole
 
    // Properties that are unique to TrackedDeviceClass_TrackingReference
    Prop_FieldOfViewLeftDegrees_Float           = 4000,
    Prop_FieldOfViewRightDegrees_Float          = 4001,
    Prop_FieldOfViewTopDegrees_Float            = 4002,
    Prop_FieldOfViewBottomDegrees_Float         = 4003,
    Prop_TrackingRangeMinimumMeters_Float       = 4004,
    Prop_TrackingRangeMaximumMeters_Float       = 4005,
    Prop_ModeLabel_String                       = 4006,
 
    // Properties that are used for user interface like icons names
    Prop_IconPathName_String                        = 5000, // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
    Prop_NamedIconPathDeviceOff_String              = 5001, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
    Prop_NamedIconPathDeviceSearching_String        = 5002, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
    Prop_NamedIconPathDeviceSearchingAlert_String   = 5003, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
    Prop_NamedIconPathDeviceReady_String            = 5004, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
    Prop_NamedIconPathDeviceReadyAlert_String       = 5005, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
    Prop_NamedIconPathDeviceNotReady_String         = 5006, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
    Prop_NamedIconPathDeviceStandby_String          = 5007, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
    Prop_NamedIconPathDeviceAlertLow_String         = 5008, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
 
    // Properties that are used by helpers, but are opaque to applications
    Prop_DisplayHiddenArea_Binary_Start             = 5100,
    Prop_DisplayHiddenArea_Binary_End               = 5150,
    Prop_ParentContainer                            = 5151,
 
    // Properties that are unique to drivers
    Prop_UserConfigPath_String                  = 6000,
    Prop_InstallPath_String                     = 6001,
    Prop_HasDisplayComponent_Bool               = 6002,
    Prop_HasControllerComponent_Bool            = 6003,
    Prop_HasCameraComponent_Bool                = 6004,
    Prop_HasDriverDirectModeComponent_Bool      = 6005,
    Prop_HasVirtualDisplayComponent_Bool        = 6006,
 
    // Properties that are set internally based on other information provided by drivers
    Prop_ControllerType_String                  = 7000,
    Prop_LegacyInputProfile_String              = 7001,
 
    // Vendors are free to expose private debug data in this reserved region
    Prop_VendorSpecific_Reserved_Start          = 10000,
    Prop_VendorSpecific_Reserved_End            = 10999,
    
    Prop_TrackedDeviceProperty_Max              = 1000000,
};

static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;

enum ETrackedPropertyError
{
    TrackedProp_Success                     = 0,
    TrackedProp_WrongDataType               = 1,
    TrackedProp_WrongDeviceClass            = 2,
    TrackedProp_BufferTooSmall              = 3,
    TrackedProp_UnknownProperty             = 4, // Driver has not set the property (and may not ever).
    TrackedProp_InvalidDevice               = 5,
    TrackedProp_CouldNotContactServer       = 6,
    TrackedProp_ValueNotProvidedByDevice    = 7,
    TrackedProp_StringExceedsMaximumLength  = 8,
    TrackedProp_NotYetAvailable             = 9, // The property value isn't known yet, but is expected soon. Call again later.
    TrackedProp_PermissionDenied            = 10,
    TrackedProp_InvalidOperation            = 11,
    TrackedProp_CannotWriteToWildcards      = 12,
};

struct VRTextureBounds_t
{
    float uMin, vMin;
    float uMax, vMax;
};

struct VRTextureWithPose_t : public Texture_t
{
    HmdMatrix34_t mDeviceToAbsoluteTracking; // Actual pose used to render scene textures.
};
 
struct VRTextureDepthInfo_t
{
    void* handle; // See ETextureType definition above
    HmdMatrix44_t mProjection;
    HmdVector2_t vRange; // 0..1
};
 
struct VRTextureWithDepth_t : public Texture_t
{
    VRTextureDepthInfo_t depth;
};
 
struct VRTextureWithPoseAndDepth_t : public VRTextureWithPose_t
{
    VRTextureDepthInfo_t depth;
};

enum EVRSubmitFlags
{
    // Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
    Submit_Default = 0x00,
 
    // App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
    // barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
    // vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
    Submit_LensDistortionAlreadyApplied = 0x01,
 
    // If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
    Submit_GlRenderBuffer = 0x02,
 
    // Do not use
    Submit_Reserved = 0x04,
 
    // Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
    // This flag can be combined with Submit_TextureWithDepth to pass a VRTextureWithPoseAndDepth_t.
    Submit_TextureWithPose = 0x08,
 
    // Set to indicate that pTexture is a pointer to a VRTextureWithDepth_t.
    // This flag can be combined with Submit_TextureWithPose to pass a VRTextureWithPoseAndDepth_t.
    Submit_TextureWithDepth = 0x10,
};

struct VRVulkanTextureData_t
{
    uint64_t m_nImage; // VkImage
    VkDevice_T *m_pDevice;
    VkPhysicalDevice_T *m_pPhysicalDevice;
    VkInstance_T *m_pInstance;
    VkQueue_T *m_pQueue;
    uint32_t m_nQueueFamilyIndex;
    uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
};

struct D3D12TextureData_t
{
    ID3D12Resource *m_pResource;
    ID3D12CommandQueue *m_pCommandQueue;
    uint32_t m_nNodeMask;
};

enum EVRState
{
    VRState_Undefined = -1,
    VRState_Off = 0,
    VRState_Searching = 1,
    VRState_Searching_Alert = 2,
    VRState_Ready = 3,
    VRState_Ready_Alert = 4,
    VRState_NotReady = 5,
    VRState_Standby = 6,
    VRState_Ready_Alert_Low = 7,
};

enum EVREventType
{
    VREvent_None = 0,
 
    VREvent_TrackedDeviceActivated      = 100,
    VREvent_TrackedDeviceDeactivated    = 101,
    VREvent_TrackedDeviceUpdated        = 102,
    VREvent_TrackedDeviceUserInteractionStarted = 103,
    VREvent_TrackedDeviceUserInteractionEnded   = 104,
    VREvent_IpdChanged                  = 105,
    VREvent_EnterStandbyMode            = 106,
    VREvent_LeaveStandbyMode            = 107,
    VREvent_TrackedDeviceRoleChanged    = 108,
    VREvent_WatchdogWakeUpRequested     = 109,
    VREvent_LensDistortionChanged       = 110,
    VREvent_PropertyChanged             = 111,
    VREvent_WirelessDisconnect          = 112,
    VREvent_WirelessReconnect           = 113,
 
    VREvent_ButtonPress                 = 200, // data is controller
    VREvent_ButtonUnpress               = 201, // data is controller
    VREvent_ButtonTouch                 = 202, // data is controller
    VREvent_ButtonUntouch               = 203, // data is controller
 
    VREvent_DualAnalog_Press            = 250, // data is dualAnalog
    VREvent_DualAnalog_Unpress          = 251, // data is dualAnalog
    VREvent_DualAnalog_Touch            = 252, // data is dualAnalog
    VREvent_DualAnalog_Untouch          = 253, // data is dualAnalog
    VREvent_DualAnalog_Move             = 254, // data is dualAnalog
    VREvent_DualAnalog_ModeSwitch1      = 255, // data is dualAnalog
    VREvent_DualAnalog_ModeSwitch2      = 256, // data is dualAnalog
    VREvent_DualAnalog_Cancel           = 257, // data is dualAnalog
 
    VREvent_MouseMove                   = 300, // data is mouse
    VREvent_MouseButtonDown             = 301, // data is mouse
    VREvent_MouseButtonUp               = 302, // data is mouse
    VREvent_FocusEnter                  = 303, // data is overlay
    VREvent_FocusLeave                  = 304, // data is overlay
    VREvent_Scroll                      = 305, // data is mouse
    VREvent_TouchPadMove                = 306, // data is mouse
    VREvent_OverlayFocusChanged         = 307, // data is overlay, global event
 
    VREvent_InputFocusCaptured          = 400, // data is process DEPRECATED
    VREvent_InputFocusReleased          = 401, // data is process DEPRECATED
    VREvent_SceneFocusLost              = 402, // data is process
    VREvent_SceneFocusGained            = 403, // data is process
    VREvent_SceneApplicationChanged     = 404, // data is process - The App actually drawing the scene changed (usually to or from the compositor)
    VREvent_SceneFocusChanged           = 405, // data is process - New app got access to draw the scene
    VREvent_InputFocusChanged           = 406, // data is process
    VREvent_SceneApplicationSecondaryRenderingStarted = 407, // data is process
 
    VREvent_HideRenderModels            = 410, // Sent to the scene application to request hiding render models temporarily
    VREvent_ShowRenderModels            = 411, // Sent to the scene application to request restoring render model visibility
 
    VREvent_ConsoleOpened               = 420,
    VREvent_ConsoleClosed               = 421,
 
    VREvent_OverlayShown                = 500,
    VREvent_OverlayHidden               = 501,
    VREvent_DashboardActivated          = 502,
    VREvent_DashboardDeactivated        = 503,
    VREvent_DashboardThumbSelected      = 504, // Sent to the overlay manager - data is overlay
    VREvent_DashboardRequested          = 505, // Sent to the overlay manager - data is overlay
    VREvent_ResetDashboard              = 506, // Send to the overlay manager
    VREvent_RenderToast                 = 507, // Send to the dashboard to render a toast - data is the notification ID
    VREvent_ImageLoaded                 = 508, // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
    VREvent_ShowKeyboard                = 509, // Sent to keyboard renderer in the dashboard to invoke it
    VREvent_HideKeyboard                = 510, // Sent to keyboard renderer in the dashboard to hide it
    VREvent_OverlayGamepadFocusGained   = 511, // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
    VREvent_OverlayGamepadFocusLost     = 512, // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
    VREvent_OverlaySharedTextureChanged = 513,
    VREvent_DashboardGuideButtonDown    = 514,
    VREvent_DashboardGuideButtonUp      = 515,
    VREvent_ScreenshotTriggered         = 516, // Screenshot button combo was pressed, Dashboard should request a screenshot
    VREvent_ImageFailed                 = 517, // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
    VREvent_DashboardOverlayCreated     = 518,
 
    // Screenshot API
    VREvent_RequestScreenshot               = 520, // Sent by vrclient application to compositor to take a screenshot
    VREvent_ScreenshotTaken                 = 521, // Sent by compositor to the application that the screenshot has been taken
    VREvent_ScreenshotFailed                = 522, // Sent by compositor to the application that the screenshot failed to be taken
    VREvent_SubmitScreenshotToDashboard     = 523, // Sent by compositor to the dashboard that a completed screenshot was submitted
    VREvent_ScreenshotProgressToDashboard   = 524, // Sent by compositor to the dashboard that a completed screenshot was submitted
 
    VREvent_PrimaryDashboardDeviceChanged   = 525,
 
    VREvent_Notification_Shown              = 600,
    VREvent_Notification_Hidden             = 601,
    VREvent_Notification_BeginInteraction   = 602,
    VREvent_Notification_Destroyed          = 603,
 
    VREvent_Quit                            = 700, // data is process
    VREvent_ProcessQuit                     = 701, // data is process
    VREvent_QuitAborted_UserPrompt          = 702, // data is process
    VREvent_QuitAcknowledged                = 703, // data is process
    VREvent_DriverRequestedQuit             = 704, // The driver has requested that SteamVR shut down
 
    VREvent_ChaperoneDataHasChanged         = 800,
    VREvent_ChaperoneUniverseHasChanged     = 801,
    VREvent_ChaperoneTempDataHasChanged     = 802,
    VREvent_ChaperoneSettingsHaveChanged    = 803,
    VREvent_SeatedZeroPoseReset             = 804,
 
    VREvent_AudioSettingsHaveChanged        = 820,
 
    VREvent_BackgroundSettingHasChanged        = 850,
    VREvent_CameraSettingsHaveChanged          = 851,
    VREvent_ReprojectionSettingHasChanged      = 852,
    VREvent_ModelSkinSettingsHaveChanged       = 853,
    VREvent_EnvironmentSettingsHaveChanged     = 854,
    VREvent_PowerSettingsHaveChanged           = 855,
    VREvent_EnableHomeAppSettingsHaveChanged   = 856,
    VREvent_SteamVRSectionSettingChanged       = 857,
    VREvent_LighthouseSectionSettingChanged    = 858,
    VREvent_NullSectionSettingChanged          = 859,
    VREvent_UserInterfaceSectionSettingChanged = 860,
    VREvent_NotificationsSectionSettingChanged = 861,
    VREvent_KeyboardSectionSettingChanged      = 862,
    VREvent_PerfSectionSettingChanged          = 863,
    VREvent_DashboardSectionSettingChanged     = 864,
    VREvent_WebInterfaceSectionSettingChanged  = 865,
 
    VREvent_StatusUpdate                    = 900,
 
    VREvent_WebInterface_InstallDriverCompleted = 950,
 
    VREvent_MCImageUpdated                  = 1000,
 
    VREvent_FirmwareUpdateStarted           = 1100,
    VREvent_FirmwareUpdateFinished          = 1101,
 
    VREvent_KeyboardClosed                  = 1200,
    VREvent_KeyboardCharInput               = 1201,
    VREvent_KeyboardDone                    = 1202, // Sent when DONE button clicked on keyboard
 
    VREvent_ApplicationTransitionStarted        = 1300,
    VREvent_ApplicationTransitionAborted        = 1301,
    VREvent_ApplicationTransitionNewAppStarted  = 1302,
    VREvent_ApplicationListUpdated              = 1303,
    VREvent_ApplicationMimeTypeLoad             = 1304,
    VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
    VREvent_ProcessConnected                    = 1306,
    VREvent_ProcessDisconnected                 = 1307,
 
    VREvent_Compositor_MirrorWindowShown        = 1400,
    VREvent_Compositor_MirrorWindowHidden       = 1401,
    VREvent_Compositor_ChaperoneBoundsShown     = 1410,
    VREvent_Compositor_ChaperoneBoundsHidden    = 1411,
 
    VREvent_TrackedCamera_StartVideoStream  = 1500,
    VREvent_TrackedCamera_StopVideoStream   = 1501,
    VREvent_TrackedCamera_PauseVideoStream  = 1502,
    VREvent_TrackedCamera_ResumeVideoStream = 1503,
    VREvent_TrackedCamera_EditingSurface    = 1550,
 
    VREvent_PerformanceTest_EnableCapture   = 1600,
    VREvent_PerformanceTest_DisableCapture  = 1601,
    VREvent_PerformanceTest_FidelityLevel   = 1602,
 
    VREvent_MessageOverlay_Closed           = 1650,
    VREvent_MessageOverlayCloseRequested    = 1651,
    
    VREvent_Input_HapticVibration           = 1700, // data is hapticVibration
 
    // Vendors are free to expose private events in this reserved region
    VREvent_VendorSpecific_Reserved_Start   = 10000,
    VREvent_VendorSpecific_Reserved_End     = 19999,
};
 

// UserInteraction_Timeout means the device is in the process of timing out.
// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
enum EDeviceActivityLevel
{   
    k_EDeviceActivityLevel_Unknown = -1,                                    
    k_EDeviceActivityLevel_Idle = 0,                        // No activity for the last 10 seconds
    k_EDeviceActivityLevel_UserInteraction = 1,             // Activity (movement or prox sensor) is happening now  
    k_EDeviceActivityLevel_UserInteraction_Timeout = 2,     // No activity for the last 0.5 seconds
    k_EDeviceActivityLevel_Standby = 3,                     // Idle for at least 5 seconds (configurable in Settings -> Power Management)
};
 

enum EVRButtonId
{
    k_EButton_System            = 0,
    k_EButton_ApplicationMenu   = 1,
    k_EButton_Grip              = 2,
    k_EButton_DPad_Left         = 3,
    k_EButton_DPad_Up           = 4,
    k_EButton_DPad_Right        = 5,
    k_EButton_DPad_Down         = 6,
    k_EButton_A                 = 7,
    
    k_EButton_ProximitySensor   = 31,
 
    k_EButton_Axis0             = 32,
    k_EButton_Axis1             = 33,
    k_EButton_Axis2             = 34,
    k_EButton_Axis3             = 35,
    k_EButton_Axis4             = 36,
 
    // aliases for well known controllers
    k_EButton_SteamVR_Touchpad  = k_EButton_Axis0,
    k_EButton_SteamVR_Trigger   = k_EButton_Axis1,
 
    k_EButton_Dashboard_Back    = k_EButton_Grip,
 
    k_EButton_Max               = 64
};
 
inline uint64_t ButtonMaskFromId( EVRButtonId id ) { return 1ull << id; }

struct VREvent_Controller_t
{
    uint32_t button; // EVRButtonId enum
};
 

enum EVRMouseButton
{
    VRMouseButton_Left                  = 0x0001,
    VRMouseButton_Right                 = 0x0002,
    VRMouseButton_Middle                = 0x0004,
};
 

struct VREvent_Mouse_t
{
    float x, y; // co-ords are in GL space, bottom left of the texture is 0,0
    uint32_t button; // EVRMouseButton enum
};

struct VREvent_Scroll_t
{
    float xdelta, ydelta; // movement in fraction of the pad traversed since last delta, 1.0 for a full swipe
    uint32_t repeatCount;
};

struct VREvent_TouchPadMove_t
{
    // true if the users finger is detected on the touch pad
    bool bFingerDown;
 
    // How long the finger has been down in seconds
    float flSecondsFingerDown;
 
    // These values indicate the starting finger position (so you can do some basic swipe stuff)
    float fValueXFirst;
    float fValueYFirst;
 
    // This is the raw sampled coordinate without deadzoning
    float fValueXRaw;
    float fValueYRaw;
};

struct VREvent_Notification_t
{
    uint64_t ulUserValue;
    uint32_t notificationId;
};

struct VREvent_Process_t
{
    uint32_t pid;
    uint32_t oldPid;
    bool bForced;
};
 

struct VREvent_Overlay_t
{
    uint64_t overlayHandle;
};
 

struct VREvent_Status_t
{
    uint32_t statusState; // EVRState enum
};

struct VREvent_Keyboard_t
{
    char cNewInput[8];  // Up to 11 bytes of new input
    uint64_t uUserValue;    // Possible flags about the new input
};
 
struct VREvent_Ipd_t
{
    float ipdMeters;
};
 
struct VREvent_Chaperone_t
{
    uint64_t m_nPreviousUniverse;
    uint64_t m_nCurrentUniverse;
};

struct VREvent_Reserved_t
{
    uint64_t reserved0;
    uint64_t reserved1;
};
 
struct VREvent_PerformanceTest_t
{
    uint32_t m_nFidelityLevel;
};
 
struct VREvent_SeatedZeroPoseReset_t
{
    bool bResetBySystemMenu;
};
 
struct VREvent_Screenshot_t
{
    uint32_t handle;
    uint32_t type;
};
 
struct VREvent_ScreenshotProgress_t
{
    float progress;
};
 
struct VREvent_ApplicationLaunch_t
{
    uint32_t pid;
    uint32_t unArgsHandle;
};
 
struct VREvent_EditingCameraSurface_t
{
    uint64_t overlayHandle;
    uint32_t nVisualMode;
};
 
struct VREvent_MessageOverlay_t
{
    uint32_t unVRMessageOverlayResponse; // vr::VRMessageOverlayResponse enum
};
 
struct VREvent_Property_t
{
    PropertyContainerHandle_t container;
    ETrackedDeviceProperty prop;
};
 
enum EDualAnalogWhich
{
    k_EDualAnalog_Left = 0,
    k_EDualAnalog_Right = 1,
};
 
struct VREvent_DualAnalog_t
{
    float x, y; // coordinates are -1..1 analog values
    float transformedX, transformedY; // transformed by the center and radius numbers provided by the overlay
    EDualAnalogWhich which;
};
 
struct VREvent_HapticVibration_t
{
    uint64_t containerHandle; // property container handle of the device with the haptic component
    uint64_t componentHandle; // Which haptic component needs to vibrate
    float fDurationSeconds;
    float fFrequency;
    float fAmplitude;
};
 

typedef union
{
    VREvent_Reserved_t reserved;
    VREvent_Controller_t controller;
    VREvent_Mouse_t mouse;
    VREvent_Scroll_t scroll;
    VREvent_Process_t process;
    VREvent_Notification_t notification;
    VREvent_Overlay_t overlay;
    VREvent_Status_t status;
    VREvent_Keyboard_t keyboard;
    VREvent_Ipd_t ipd;
    VREvent_Chaperone_t chaperone;
    VREvent_PerformanceTest_t performanceTest;
    VREvent_TouchPadMove_t touchPadMove;
    VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
    VREvent_Screenshot_t screenshot;
    VREvent_ScreenshotProgress_t screenshotProgress;
    VREvent_ApplicationLaunch_t applicationLaunch;
    VREvent_EditingCameraSurface_t cameraSurface;
    VREvent_MessageOverlay_t messageOverlay;
    VREvent_Property_t property;
    VREvent_DualAnalog_t dualAnalog;
    VREvent_HapticVibration_t hapticVibration;
} VREvent_Data_t;
 
 
#if defined(__linux__) || defined(__APPLE__) 
// This structure was originally defined mis-packed on Linux, preserved for 
// compatibility. 
#pragma pack( push, 4 )
#endif

struct VREvent_t
{
    uint32_t eventType; // EVREventType enum
    TrackedDeviceIndex_t trackedDeviceIndex;
    float eventAgeSeconds;
    // event data must be the end of the struct as its size is variable
    VREvent_Data_t data;
};
 
#if defined(__linux__) || defined(__APPLE__) 
#pragma pack( pop )
#endif
 
enum EVRInputError
{
    VRInputError_None = 0,
    VRInputError_NameNotFound = 1,
    VRInputError_WrongType = 2,
    VRInputError_InvalidHandle = 3,
    VRInputError_InvalidParam = 4,
    VRInputError_NoSteam = 5,
    VRInputError_MaxCapacityReached = 6,
    VRInputError_IPCError = 7,
    VRInputError_NoActiveActionSet = 8,
    VRInputError_InvalidDevice = 9,
};
 

struct HiddenAreaMesh_t
{
    const HmdVector2_t *pVertexData;
    uint32_t unTriangleCount;
};
 
 
enum EHiddenAreaMeshType
{
    k_eHiddenAreaMesh_Standard = 0,
    k_eHiddenAreaMesh_Inverse = 1,
    k_eHiddenAreaMesh_LineLoop = 2,
 
    k_eHiddenAreaMesh_Max = 3,
};
 

enum EVRControllerAxisType
{
    k_eControllerAxis_None = 0,
    k_eControllerAxis_TrackPad = 1,
    k_eControllerAxis_Joystick = 2,
    k_eControllerAxis_Trigger = 3, // Analog trigger data is in the X axis
};
 

struct VRControllerAxis_t
{
    float x; // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
    float y; // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
};
 

static const uint32_t k_unControllerStateAxisCount = 5;
 
 
#if defined(__linux__) || defined(__APPLE__) 
// This structure was originally defined mis-packed on Linux, preserved for 
// compatibility. 
#pragma pack( push, 4 )
#endif

struct VRControllerState001_t
{
    // If packet num matches that on your prior call, then the controller state hasn't been changed since 
    // your last call and there is no need to process it
    uint32_t unPacketNum;
 
    // bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
    uint64_t ulButtonPressed;
    uint64_t ulButtonTouched;
 
    // Axis data for the controller's analog inputs
    VRControllerAxis_t rAxis[ k_unControllerStateAxisCount ];
};
#if defined(__linux__) || defined(__APPLE__) 
#pragma pack( pop )
#endif
 
 
typedef VRControllerState001_t VRControllerState_t;
 

enum EVRControllerEventOutputType
{
    ControllerEventOutput_OSEvents = 0,
    ControllerEventOutput_VREvents = 1,
};
 
 

enum ECollisionBoundsStyle
{
    COLLISION_BOUNDS_STYLE_BEGINNER = 0,
    COLLISION_BOUNDS_STYLE_INTERMEDIATE,
    COLLISION_BOUNDS_STYLE_SQUARES,
    COLLISION_BOUNDS_STYLE_ADVANCED,
    COLLISION_BOUNDS_STYLE_NONE,
 
    COLLISION_BOUNDS_STYLE_COUNT
};

struct Compositor_OverlaySettings
{
    uint32_t size; // sizeof(Compositor_OverlaySettings)
    bool curved, antialias;
    float scale, distance, alpha;
    float uOffset, vOffset, uScale, vScale;
    float gridDivs, gridWidth, gridScale;
    HmdMatrix44_t transform;
};

typedef uint64_t VROverlayHandle_t;
 
static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;

enum EVROverlayError
{
    VROverlayError_None                     = 0,
 
    VROverlayError_UnknownOverlay           = 10,
    VROverlayError_InvalidHandle            = 11,
    VROverlayError_PermissionDenied         = 12,
    VROverlayError_OverlayLimitExceeded     = 13, // No more overlays could be created because the maximum number already exist
    VROverlayError_WrongVisibilityType      = 14,
    VROverlayError_KeyTooLong               = 15,
    VROverlayError_NameTooLong              = 16,
    VROverlayError_KeyInUse                 = 17,
    VROverlayError_WrongTransformType       = 18,
    VROverlayError_InvalidTrackedDevice     = 19,
    VROverlayError_InvalidParameter         = 20,
    VROverlayError_ThumbnailCantBeDestroyed = 21,
    VROverlayError_ArrayTooSmall            = 22,
    VROverlayError_RequestFailed            = 23,
    VROverlayError_InvalidTexture           = 24,
    VROverlayError_UnableToLoadFile         = 25,
    VROverlayError_KeyboardAlreadyInUse     = 26,
    VROverlayError_NoNeighbor               = 27,
    VROverlayError_TooManyMaskPrimitives    = 29,
    VROverlayError_BadMaskPrimitive         = 30,
    VROverlayError_TextureAlreadyLocked     = 31,
    VROverlayError_TextureLockCapacityReached = 32,
    VROverlayError_TextureNotLocked         = 33,
};

enum EVRApplicationType
{
    VRApplication_Other = 0,        // Some other kind of application that isn't covered by the other entries 
    VRApplication_Scene = 1,        // Application will submit 3D frames 
    VRApplication_Overlay = 2,      // Application only interacts with overlays
    VRApplication_Background = 3,   // Application should not start SteamVR if it's not already running, and should not
                                    // keep it running if everything else quits.
    VRApplication_Utility = 4,      // Init should not try to load any drivers. The application needs access to utility
                                    // interfaces (like IVRSettings and IVRApplications) but not hardware.
    VRApplication_VRMonitor = 5,    // Reserved for vrmonitor
    VRApplication_SteamWatchdog = 6,// Reserved for Steam
    VRApplication_Bootstrapper = 7, // Start up SteamVR
 
    VRApplication_Max
};
 

enum EVRFirmwareError
{
    VRFirmwareError_None = 0,
    VRFirmwareError_Success = 1,
    VRFirmwareError_Fail = 2,
};
 

enum EVRNotificationError
{
    VRNotificationError_OK = 0,
    VRNotificationError_InvalidNotificationId = 100,
    VRNotificationError_NotificationQueueFull = 101,
    VRNotificationError_InvalidOverlayHandle = 102,
    VRNotificationError_SystemWithUserValueAlreadyExists = 103,
};
 

 
// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
enum EVRInitError
{
    VRInitError_None    = 0,
    VRInitError_Unknown = 1,
 
    VRInitError_Init_InstallationNotFound           = 100,
    VRInitError_Init_InstallationCorrupt            = 101,
    VRInitError_Init_VRClientDLLNotFound            = 102,
    VRInitError_Init_FileNotFound                   = 103,
    VRInitError_Init_FactoryNotFound                = 104,
    VRInitError_Init_InterfaceNotFound              = 105,
    VRInitError_Init_InvalidInterface               = 106,
    VRInitError_Init_UserConfigDirectoryInvalid     = 107,
    VRInitError_Init_HmdNotFound                    = 108,
    VRInitError_Init_NotInitialized                 = 109,
    VRInitError_Init_PathRegistryNotFound           = 110,
    VRInitError_Init_NoConfigPath                   = 111,
    VRInitError_Init_NoLogPath                      = 112,
    VRInitError_Init_PathRegistryNotWritable        = 113,
    VRInitError_Init_AppInfoInitFailed              = 114,
    VRInitError_Init_Retry                          = 115, // Used internally to cause retries to vrserver
    VRInitError_Init_InitCanceledByUser             = 116, // The calling application should silently exit. The user canceled app startup
    VRInitError_Init_AnotherAppLaunching            = 117, 
    VRInitError_Init_SettingsInitFailed             = 118, 
    VRInitError_Init_ShuttingDown                   = 119,
    VRInitError_Init_TooManyObjects                 = 120,
    VRInitError_Init_NoServerForBackgroundApp       = 121,
    VRInitError_Init_NotSupportedWithCompositor     = 122,
    VRInitError_Init_NotAvailableToUtilityApps      = 123,
    VRInitError_Init_Internal                       = 124,
    VRInitError_Init_HmdDriverIdIsNone              = 125,
    VRInitError_Init_HmdNotFoundPresenceFailed      = 126,
    VRInitError_Init_VRMonitorNotFound              = 127,
    VRInitError_Init_VRMonitorStartupFailed         = 128,
    VRInitError_Init_LowPowerWatchdogNotSupported   = 129, 
    VRInitError_Init_InvalidApplicationType         = 130,
    VRInitError_Init_NotAvailableToWatchdogApps     = 131,
    VRInitError_Init_WatchdogDisabledInSettings     = 132,
    VRInitError_Init_VRDashboardNotFound            = 133,
    VRInitError_Init_VRDashboardStartupFailed       = 134,
    VRInitError_Init_VRHomeNotFound                 = 135,
    VRInitError_Init_VRHomeStartupFailed            = 136,
    VRInitError_Init_RebootingBusy                  = 137,
    VRInitError_Init_FirmwareUpdateBusy             = 138,
    VRInitError_Init_FirmwareRecoveryBusy           = 139,
    VRInitError_Init_USBServiceBusy                 = 140,
 
    VRInitError_Driver_Failed                       = 200,
    VRInitError_Driver_Unknown                      = 201,
    VRInitError_Driver_HmdUnknown                   = 202,
    VRInitError_Driver_NotLoaded                    = 203,
    VRInitError_Driver_RuntimeOutOfDate             = 204,
    VRInitError_Driver_HmdInUse                     = 205,
    VRInitError_Driver_NotCalibrated                = 206,
    VRInitError_Driver_CalibrationInvalid           = 207,
    VRInitError_Driver_HmdDisplayNotFound           = 208,
    VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
    // VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
    VRInitError_Driver_HmdDriverIdOutOfBounds       = 211,
    VRInitError_Driver_HmdDisplayMirrored           = 212,
 
    VRInitError_IPC_ServerInitFailed                = 300,
    VRInitError_IPC_ConnectFailed                   = 301,
    VRInitError_IPC_SharedStateInitFailed           = 302,
    VRInitError_IPC_CompositorInitFailed            = 303,
    VRInitError_IPC_MutexInitFailed                 = 304,
    VRInitError_IPC_Failed                          = 305,
    VRInitError_IPC_CompositorConnectFailed         = 306,
    VRInitError_IPC_CompositorInvalidConnectResponse = 307,
    VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
 
    VRInitError_Compositor_Failed                   = 400,
    VRInitError_Compositor_D3D11HardwareRequired    = 401,
    VRInitError_Compositor_FirmwareRequiresUpdate   = 402,
    VRInitError_Compositor_OverlayInitFailed        = 403,
    VRInitError_Compositor_ScreenshotsInitFailed    = 404,
    VRInitError_Compositor_UnableToCreateDevice     = 405,
 
    VRInitError_VendorSpecific_UnableToConnectToOculusRuntime       = 1000,
    VRInitError_VendorSpecific_WindowsNotInDevMode                  = 1001,
 
    VRInitError_VendorSpecific_HmdFound_CantOpenDevice              = 1101,
    VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart  = 1102,
    VRInitError_VendorSpecific_HmdFound_NoStoredConfig              = 1103,
    VRInitError_VendorSpecific_HmdFound_ConfigTooBig                = 1104,
    VRInitError_VendorSpecific_HmdFound_ConfigTooSmall              = 1105,
    VRInitError_VendorSpecific_HmdFound_UnableToInitZLib            = 1106,
    VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion     = 1107,
    VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart   = 1108,
    VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart    = 1109,
    VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext     = 1110,
    VRInitError_VendorSpecific_HmdFound_UserDataAddressRange        = 1111,
    VRInitError_VendorSpecific_HmdFound_UserDataError               = 1112,
    VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck     = 1113,
 
    VRInitError_Steam_SteamInstallationNotFound = 2000,
};
 
enum EVRScreenshotType
{
    VRScreenshotType_None = 0,
    VRScreenshotType_Mono = 1, // left eye only
    VRScreenshotType_Stereo = 2,
    VRScreenshotType_Cubemap = 3,
    VRScreenshotType_MonoPanorama = 4,
    VRScreenshotType_StereoPanorama = 5
};
 
enum EVRScreenshotPropertyFilenames
{
    VRScreenshotPropertyFilenames_Preview = 0,
    VRScreenshotPropertyFilenames_VR = 1,
};
 
enum EVRTrackedCameraError
{
    VRTrackedCameraError_None                       = 0,
    VRTrackedCameraError_OperationFailed            = 100,
    VRTrackedCameraError_InvalidHandle              = 101,  
    VRTrackedCameraError_InvalidFrameHeaderVersion  = 102,
    VRTrackedCameraError_OutOfHandles               = 103,
    VRTrackedCameraError_IPCFailure                 = 104,
    VRTrackedCameraError_NotSupportedForThisDevice  = 105,
    VRTrackedCameraError_SharedMemoryFailure        = 106,
    VRTrackedCameraError_FrameBufferingFailure      = 107,
    VRTrackedCameraError_StreamSetupFailure         = 108,
    VRTrackedCameraError_InvalidGLTextureId         = 109,
    VRTrackedCameraError_InvalidSharedTextureHandle = 110,
    VRTrackedCameraError_FailedToGetGLTextureId     = 111,
    VRTrackedCameraError_SharedTextureFailure       = 112,
    VRTrackedCameraError_NoFrameAvailable           = 113,
    VRTrackedCameraError_InvalidArgument            = 114,
    VRTrackedCameraError_InvalidFrameBufferSize     = 115,
};
 
enum EVRTrackedCameraFrameType
{
    VRTrackedCameraFrameType_Distorted = 0,         // This is the camera video frame size in pixels, still distorted.
    VRTrackedCameraFrameType_Undistorted,           // In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
    VRTrackedCameraFrameType_MaximumUndistorted,    // In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
    MAX_CAMERA_FRAME_TYPES
};
 
typedef uint64_t TrackedCameraHandle_t;
#define INVALID_TRACKED_CAMERA_HANDLE   ((vr::TrackedCameraHandle_t)0)
 
struct CameraVideoStreamFrameHeader_t
{
    EVRTrackedCameraFrameType eFrameType;
 
    uint32_t nWidth;
    uint32_t nHeight;
    uint32_t nBytesPerPixel;
 
    uint32_t nFrameSequence;
 
    TrackedDevicePose_t standingTrackedDevicePose;
};
 
// Screenshot types
typedef uint32_t ScreenshotHandle_t;
 
static const uint32_t k_unScreenshotHandleInvalid = 0;

struct DriverDirectMode_FrameTiming
{
    uint32_t m_nSize; // Set to sizeof( DriverDirectMode_FrameTiming )
    uint32_t m_nNumFramePresents; // number of times frame was presented
    uint32_t m_nNumMisPresented; // number of times frame was presented on a vsync other than it was originally predicted to
    uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out (i.e. compositor missed vsync)
    uint32_t m_nReprojectionFlags;
};
 
#pragma pack( pop )
 
// figure out how to import from the VR API dll
#if defined(_WIN32)
 
#ifdef VR_API_EXPORT
#define VR_INTERFACE extern "C" __declspec( dllexport )
#else
#define VR_INTERFACE extern "C" __declspec( dllimport )
#endif
 
#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
 
#ifdef VR_API_EXPORT
#define VR_INTERFACE extern "C" __attribute__((visibility("default")))
#else
#define VR_INTERFACE extern "C" 
#endif
 
#else
#error "Unsupported Platform."
#endif
 
 
#if defined( _WIN32 )
#define VR_CALLTYPE __cdecl
#else
#define VR_CALLTYPE 
#endif
 
} // namespace vr
 
#endif // _INCLUDE_VRTYPES_H
 
 
// vrannotation.h
#ifdef API_GEN
# define VR_CLANG_ATTR(ATTR) __attribute__((annotate( ATTR )))
#else
# define VR_CLANG_ATTR(ATTR)
#endif
 
#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR( "desc:" #DESC ";" )
#define VR_IGNOREATTR() VR_CLANG_ATTR( "ignore" )
#define VR_OUT_STRUCT() VR_CLANG_ATTR( "out_struct: ;" )
#define VR_OUT_STRING() VR_CLANG_ATTR( "out_string: ;" )
#define VR_OUT_ARRAY_CALL(COUNTER,FUNCTION,PARAMS) VR_CLANG_ATTR( "out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";" )
#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "out_array_count:" #COUNTER ";" )
#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "array_count:" #COUNTER ";" )
#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR( "array_count:" #COUNTER ";desc:" #DESC )
#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "buffer_count:" #COUNTER ";" )
#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "out_buffer_count:" #COUNTER ";" )
#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR( "out_string_count:" #COUNTER ";" )
 
// ivrsystem.h
namespace vr
{
 
struct VR_IVRSystem_FnTable
{
    void (__stdcall *GetRecommendedRenderTargetSize)( uint32_t *pnWidth, uint32_t *pnHeight );
    HmdMatrix44_t (__stdcall *GetProjectionMatrix)( EVREye eEye, float fNearZ, float fFarZ );
    void (__stdcall *GetProjectionRaw)( EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom );
    bool (__stdcall *ComputeDistortion)( EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates );
    HmdMatrix34_t (__stdcall *GetEyeToHeadTransform)( EVREye eEye );
    bool (__stdcall *GetTimeSinceLastVsync)( float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter );
    int32_t (__stdcall *GetD3D9AdapterIndex)();
    void (__stdcall *GetDXGIOutputInfo)( int32_t *pnAdapterIndex );
    void (__stdcall *GetOutputDevice)( uint64_t *pnDevice, ETextureType textureType, VkInstance_T *pInstance);
    bool (__stdcall *IsDisplayOnDesktop)();
    bool (__stdcall *SetDisplayVisibility)( bool bIsVisibleOnDesktop );
    void (__stdcall *GetDeviceToAbsoluteTrackingPose)( ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow,  TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount );
    void (__stdcall *ResetSeatedZeroPose)();
    HmdMatrix34_t (__stdcall *GetSeatedZeroPoseToStandingAbsoluteTrackingPose)();
    HmdMatrix34_t (__stdcall *GetRawZeroPoseToStandingAbsoluteTrackingPose)();
    uint32_t (__stdcall *GetSortedTrackedDeviceIndicesOfClass)( ETrackedDeviceClass eTrackedDeviceClass,  vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
    EDeviceActivityLevel (__stdcall *GetTrackedDeviceActivityLevel)( vr::TrackedDeviceIndex_t unDeviceId );
    void (__stdcall *ApplyTransform)( TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform );
    vr::TrackedDeviceIndex_t (__stdcall *GetTrackedDeviceIndexForControllerRole)( vr::ETrackedControllerRole unDeviceType );
    vr::ETrackedControllerRole (__stdcall *GetControllerRoleForTrackedDeviceIndex)( vr::TrackedDeviceIndex_t unDeviceIndex );
    ETrackedDeviceClass (__stdcall *GetTrackedDeviceClass)( vr::TrackedDeviceIndex_t unDeviceIndex );
    bool (__stdcall *IsTrackedDeviceConnected)( vr::TrackedDeviceIndex_t unDeviceIndex );
    bool (__stdcall *GetBoolTrackedDeviceProperty)( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
    float (__stdcall *GetFloatTrackedDeviceProperty)( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
    int32_t (__stdcall *GetInt32TrackedDeviceProperty)( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
    uint64_t (__stdcall *GetUint64TrackedDeviceProperty)( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
    HmdMatrix34_t (__stdcall *GetMatrix34TrackedDeviceProperty)( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError);
    uint32_t (__stdcall *GetArrayTrackedDeviceProperty)( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void *pBuffer, uint32_t unBufferSize, ETrackedPropertyError *pError);
    uint32_t (__stdcall *GetStringTrackedDeviceProperty)( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop,  char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError);
    const char *(__stdcall *GetPropErrorNameFromEnum)( ETrackedPropertyError error );
    bool (__stdcall *PollNextEvent)( VREvent_t *pEvent, uint32_t uncbVREvent );
    bool (__stdcall *PollNextEventWithPose)( ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose );
    const char *(__stdcall *GetEventTypeNameFromEnum)( EVREventType eType );
    HiddenAreaMesh_t (__stdcall *GetHiddenAreaMesh)( EVREye eEye, EHiddenAreaMeshType type);
    bool (__stdcall *GetControllerState)( vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize );
    bool (__stdcall *GetControllerStateWithPose)( ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose );
    void (__stdcall *TriggerHapticPulse)( vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec );
    const char *(__stdcall *GetButtonIdNameFromEnum)( EVRButtonId eButtonId );
    const char *(__stdcall *GetControllerAxisTypeNameFromEnum)( EVRControllerAxisType eAxisType );
    bool (__stdcall *IsInputAvailable)();
    bool (__stdcall *IsSteamVRDrawingControllers)();
    bool (__stdcall *ShouldApplicationPause)();
    bool (__stdcall *ShouldApplicationReduceRenderingWork)();
    uint32_t (__stdcall *DriverDebugRequest)( vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest,  char *pchResponseBuffer, uint32_t unResponseBufferSize );
    vr::EVRFirmwareError (__stdcall *PerformFirmwareUpdate)( vr::TrackedDeviceIndex_t unDeviceIndex );
    void (__stdcall *AcknowledgeQuit_Exiting)();
    void (__stdcall *AcknowledgeQuit_UserPrompt)();
};
 
class IVRSystem
{
    VR_IVRSystem_FnTable _table;
public:
 
 
    // ------------------------------------
    // Display Methods
    // ------------------------------------

    void GetRecommendedRenderTargetSize( uint32_t *pnWidth, uint32_t *pnHeight ) { _table.GetRecommendedRenderTargetSize(pnWidth, pnHeight); }

    HmdMatrix44_t GetProjectionMatrix( EVREye eEye, float fNearZ, float fFarZ ) { return _table.GetProjectionMatrix(eEye, fNearZ, fFarZ); }

    void GetProjectionRaw( EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom ) { _table.GetProjectionRaw(eEye, pfLeft, pfRight, pfTop, pfBottom); }

    bool ComputeDistortion( EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates ) { return _table.ComputeDistortion(eEye, fU, fV, pDistortionCoordinates); }

    HmdMatrix34_t GetEyeToHeadTransform( EVREye eEye ) { return _table.GetEyeToHeadTransform(eEye); }

    bool GetTimeSinceLastVsync( float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter ) { return _table.GetTimeSinceLastVsync(pfSecondsSinceLastVsync, pulFrameCounter); }

    int32_t GetD3D9AdapterIndex() { return _table.GetD3D9AdapterIndex(); }

    void GetDXGIOutputInfo( int32_t *pnAdapterIndex ) { _table.GetDXGIOutputInfo(pnAdapterIndex); }
    
    void GetOutputDevice( uint64_t *pnDevice, ETextureType textureType, VkInstance_T *pInstance = nullptr ) { _table.GetOutputDevice(pnDevice, textureType, pInstance); }
 
    // ------------------------------------
    // Display Mode methods
    // ------------------------------------

    bool IsDisplayOnDesktop() { return _table.IsDisplayOnDesktop(); }

    bool SetDisplayVisibility( bool bIsVisibleOnDesktop ) { return _table.SetDisplayVisibility(bIsVisibleOnDesktop); }
 
    // ------------------------------------
    // Tracking Methods
    // ------------------------------------

    void GetDeviceToAbsoluteTrackingPose( ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount) TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount ) { _table.GetDeviceToAbsoluteTrackingPose(eOrigin, fPredictedSecondsToPhotonsFromNow, pTrackedDevicePoseArray, unTrackedDevicePoseArrayCount); }

    void ResetSeatedZeroPose() { _table.ResetSeatedZeroPose(); }

    HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() { return _table.GetSeatedZeroPoseToStandingAbsoluteTrackingPose(); }

    HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() { return _table.GetRawZeroPoseToStandingAbsoluteTrackingPose(); }

    uint32_t GetSortedTrackedDeviceIndicesOfClass( ETrackedDeviceClass eTrackedDeviceClass, VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount) vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex = k_unTrackedDeviceIndex_Hmd ) { return _table.GetSortedTrackedDeviceIndicesOfClass(eTrackedDeviceClass, punTrackedDeviceIndexArray, unTrackedDeviceIndexArrayCount, unRelativeToTrackedDeviceIndex); }

    EDeviceActivityLevel GetTrackedDeviceActivityLevel( vr::TrackedDeviceIndex_t unDeviceId ) { return _table.GetTrackedDeviceActivityLevel(unDeviceId); }

    void ApplyTransform( TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform ) { _table.ApplyTransform(pOutputPose, pTrackedDevicePose, pTransform); }

    vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForControllerRole( vr::ETrackedControllerRole unDeviceType ) { return _table.GetTrackedDeviceIndexForControllerRole(unDeviceType); }

    vr::ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex( vr::TrackedDeviceIndex_t unDeviceIndex ) { return _table.GetControllerRoleForTrackedDeviceIndex(unDeviceIndex); }
 
    // ------------------------------------
    // Property methods
    // ------------------------------------

    ETrackedDeviceClass GetTrackedDeviceClass( vr::TrackedDeviceIndex_t unDeviceIndex ) { return _table.GetTrackedDeviceClass(unDeviceIndex); }

    bool IsTrackedDeviceConnected( vr::TrackedDeviceIndex_t unDeviceIndex ) { return _table.IsTrackedDeviceConnected(unDeviceIndex); }

    bool GetBoolTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { return _table.GetBoolTrackedDeviceProperty(unDeviceIndex, prop, pError); }

    float GetFloatTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { return _table.GetFloatTrackedDeviceProperty(unDeviceIndex, prop, pError); }

    int32_t GetInt32TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { return _table.GetInt32TrackedDeviceProperty(unDeviceIndex, prop, pError); }

    uint64_t GetUint64TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { return _table.GetUint64TrackedDeviceProperty(unDeviceIndex, prop, pError); }

    HmdMatrix34_t GetMatrix34TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) { return _table.GetMatrix34TrackedDeviceProperty(unDeviceIndex, prop, pError); }
    
    uint32_t GetArrayTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void *pBuffer, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) { return _table.GetArrayTrackedDeviceProperty(unDeviceIndex, prop, propType, pBuffer, unBufferSize, pError); }

    uint32_t GetStringTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) { return _table.GetStringTrackedDeviceProperty(unDeviceIndex, prop, pchValue, unBufferSize, pError); }

    const char *GetPropErrorNameFromEnum( ETrackedPropertyError error ) { return _table.GetPropErrorNameFromEnum(error); }
 
    // ------------------------------------
    // Event methods
    // ------------------------------------

    bool PollNextEvent( VREvent_t *pEvent, uint32_t uncbVREvent ) { return _table.PollNextEvent(pEvent, uncbVREvent); }

    bool PollNextEventWithPose( ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose ) { return _table.PollNextEventWithPose(eOrigin, pEvent, uncbVREvent, pTrackedDevicePose); }

    const char *GetEventTypeNameFromEnum( EVREventType eType ) { return _table.GetEventTypeNameFromEnum(eType); }
 
    // ------------------------------------
    // Rendering helper methods
    // ------------------------------------

    HiddenAreaMesh_t GetHiddenAreaMesh( EVREye eEye, EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard ) { return _table.GetHiddenAreaMesh(eEye, type); }
 
    // ------------------------------------
    // Controller methods
    // ------------------------------------

    bool GetControllerState( vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize ) { return _table.GetControllerState(unControllerDeviceIndex, pControllerState, unControllerStateSize); }

    bool GetControllerStateWithPose( ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose ) { return _table.GetControllerStateWithPose(eOrigin, unControllerDeviceIndex, pControllerState, unControllerStateSize, pTrackedDevicePose); }

    void TriggerHapticPulse( vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec ) { _table.TriggerHapticPulse(unControllerDeviceIndex, unAxisId, usDurationMicroSec); }

    const char *GetButtonIdNameFromEnum( EVRButtonId eButtonId ) { return _table.GetButtonIdNameFromEnum(eButtonId); }

    const char *GetControllerAxisTypeNameFromEnum( EVRControllerAxisType eAxisType ) { return _table.GetControllerAxisTypeNameFromEnum(eAxisType); }

    bool IsInputAvailable() { return _table.IsInputAvailable(); }

    bool IsSteamVRDrawingControllers() { return _table.IsSteamVRDrawingControllers(); }

    bool ShouldApplicationPause() { return _table.ShouldApplicationPause(); }

    bool ShouldApplicationReduceRenderingWork() { return _table.ShouldApplicationReduceRenderingWork(); }
 
    // ------------------------------------
    // Debug Methods
    // ------------------------------------

    uint32_t DriverDebugRequest( vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest, VR_OUT_STRING() char *pchResponseBuffer, uint32_t unResponseBufferSize ) { return _table.DriverDebugRequest(unDeviceIndex, pchRequest, pchResponseBuffer, unResponseBufferSize); }
 
    // ------------------------------------
    // Firmware methods
    // ------------------------------------
    
    vr::EVRFirmwareError PerformFirmwareUpdate( vr::TrackedDeviceIndex_t unDeviceIndex ) { return _table.PerformFirmwareUpdate(unDeviceIndex); }
 
    // ------------------------------------
    // Application life cycle methods
    // ------------------------------------

    void AcknowledgeQuit_Exiting() { _table.AcknowledgeQuit_Exiting(); }

    void AcknowledgeQuit_UserPrompt() { _table.AcknowledgeQuit_UserPrompt(); }
 
};
 
static const char * const IVRSystem_Version = "FnTable:IVRSystem_019";
 
}
 
 
// ivrapplications.h
namespace vr
{

    enum EVRApplicationError
    {
        VRApplicationError_None = 0,
 
        VRApplicationError_AppKeyAlreadyExists = 100,   // Only one application can use any given key
        VRApplicationError_NoManifest = 101,            // the running application does not have a manifest
        VRApplicationError_NoApplication = 102,         // No application is running
        VRApplicationError_InvalidIndex = 103,
        VRApplicationError_UnknownApplication = 104,    // the application could not be found
        VRApplicationError_IPCFailed = 105,             // An IPC failure caused the request to fail
        VRApplicationError_ApplicationAlreadyRunning = 106, 
        VRApplicationError_InvalidManifest = 107,
        VRApplicationError_InvalidApplication = 108,
        VRApplicationError_LaunchFailed = 109,          // the process didn't start
        VRApplicationError_ApplicationAlreadyStarting = 110, // the system was already starting the same application
        VRApplicationError_LaunchInProgress = 111,      // The system was already starting a different application
        VRApplicationError_OldApplicationQuitting = 112, 
        VRApplicationError_TransitionAborted = 113,
        VRApplicationError_IsTemplate = 114, // error when you try to call LaunchApplication() on a template type app (use LaunchTemplateApplication)
        VRApplicationError_SteamVRIsExiting = 115,
 
        VRApplicationError_BufferTooSmall = 200,        // The provided buffer was too small to fit the requested data
        VRApplicationError_PropertyNotSet = 201,        // The requested property was not set
        VRApplicationError_UnknownProperty = 202,
        VRApplicationError_InvalidParameter = 203,
    };

    static const uint32_t k_unMaxApplicationKeyLength = 128;

    enum EVRApplicationProperty
    {
        VRApplicationProperty_Name_String               = 0,
 
        VRApplicationProperty_LaunchType_String         = 11,
        VRApplicationProperty_WorkingDirectory_String   = 12,
        VRApplicationProperty_BinaryPath_String         = 13,
        VRApplicationProperty_Arguments_String          = 14,
        VRApplicationProperty_URL_String                = 15,
 
        VRApplicationProperty_Description_String        = 50,
        VRApplicationProperty_NewsURL_String            = 51,
        VRApplicationProperty_ImagePath_String          = 52,
        VRApplicationProperty_Source_String             = 53,
        VRApplicationProperty_ActionManifestURL_String  = 54,
 
        VRApplicationProperty_IsDashboardOverlay_Bool   = 60,
        VRApplicationProperty_IsTemplate_Bool           = 61,
        VRApplicationProperty_IsInstanced_Bool          = 62,
        VRApplicationProperty_IsInternal_Bool           = 63,
        VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
 
        VRApplicationProperty_LastLaunchTime_Uint64     = 70,
    };

    enum EVRApplicationTransitionState
    {
        VRApplicationTransition_None = 0,
 
        VRApplicationTransition_OldAppQuitSent = 10,
        VRApplicationTransition_WaitingForExternalLaunch = 11,
        
        VRApplicationTransition_NewAppLaunched = 20,
    };
 
    struct AppOverrideKeys_t
    {
        const char *pchKey;
        const char *pchValue;
    };

    static const char * const k_pch_MimeType_HomeApp        = "vr/home";
    static const char * const k_pch_MimeType_GameTheater    = "vr/game_theater";
 
    struct VR_IVRApplications_FnTable
    {
        EVRApplicationError (__stdcall *AddApplicationManifest)( const char *pchApplicationManifestFullPath, bool bTemporary);
        EVRApplicationError (__stdcall *RemoveApplicationManifest)( const char *pchApplicationManifestFullPath );
        bool (__stdcall *IsApplicationInstalled)( const char *pchAppKey );
        uint32_t (__stdcall *GetApplicationCount)();
        EVRApplicationError (__stdcall *GetApplicationKeyByIndex)( uint32_t unApplicationIndex,  char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen );
        EVRApplicationError (__stdcall *GetApplicationKeyByProcessId)( uint32_t unProcessId,  char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen );
        EVRApplicationError (__stdcall *LaunchApplication)( const char *pchAppKey );
        EVRApplicationError (__stdcall *LaunchTemplateApplication)( const char *pchTemplateAppKey, const char *pchNewAppKey,  const AppOverrideKeys_t *pKeys, uint32_t unKeys );
        vr::EVRApplicationError (__stdcall *LaunchApplicationFromMimeType)( const char *pchMimeType, const char *pchArgs );
        EVRApplicationError (__stdcall *LaunchDashboardOverlay)( const char *pchAppKey );
        bool (__stdcall *CancelApplicationLaunch)( const char *pchAppKey );
        EVRApplicationError (__stdcall *IdentifyApplication)( uint32_t unProcessId, const char *pchAppKey );
        uint32_t (__stdcall *GetApplicationProcessId)( const char *pchAppKey );
        const char *(__stdcall *GetApplicationsErrorNameFromEnum)( EVRApplicationError error );
        uint32_t (__stdcall *GetApplicationPropertyString)( const char *pchAppKey, EVRApplicationProperty eProperty,  char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError);
        bool (__stdcall *GetApplicationPropertyBool)( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError);
        uint64_t (__stdcall *GetApplicationPropertyUint64)( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError);
        EVRApplicationError (__stdcall *SetApplicationAutoLaunch)( const char *pchAppKey, bool bAutoLaunch );
        bool (__stdcall *GetApplicationAutoLaunch)( const char *pchAppKey );
        EVRApplicationError (__stdcall *SetDefaultApplicationForMimeType)( const char *pchAppKey, const char *pchMimeType );
        bool (__stdcall *GetDefaultApplicationForMimeType)( const char *pchMimeType,  char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen );
        bool (__stdcall *GetApplicationSupportedMimeTypes)( const char *pchAppKey,  char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer );
        uint32_t (__stdcall *GetApplicationsThatSupportMimeType)( const char *pchMimeType,  char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer );
        uint32_t (__stdcall *GetApplicationLaunchArguments)( uint32_t unHandle,  char *pchArgs, uint32_t unArgs );
        EVRApplicationError (__stdcall *GetStartingApplication)(  char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen );
        EVRApplicationTransitionState (__stdcall *GetTransitionState)();
        EVRApplicationError (__stdcall *PerformApplicationPrelaunchCheck)( const char *pchAppKey );
        const char *(__stdcall *GetApplicationsTransitionStateNameFromEnum)( EVRApplicationTransitionState state );
        bool (__stdcall *IsQuitUserPromptRequested)();
        EVRApplicationError (__stdcall *LaunchInternalProcess)( const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory );
        uint32_t (__stdcall *GetCurrentSceneProcessId)();
    };
 
    class IVRApplications
    {
        VR_IVRApplications_FnTable _table;
    public:
 
        // ---------------  Application management  --------------- //

        EVRApplicationError AddApplicationManifest( const char *pchApplicationManifestFullPath, bool bTemporary = false ) { return _table.AddApplicationManifest(pchApplicationManifestFullPath, bTemporary); }

        EVRApplicationError RemoveApplicationManifest( const char *pchApplicationManifestFullPath ) { return _table.RemoveApplicationManifest(pchApplicationManifestFullPath); }

        bool IsApplicationInstalled( const char *pchAppKey ) { return _table.IsApplicationInstalled(pchAppKey); }

        uint32_t GetApplicationCount() { return _table.GetApplicationCount(); }

        EVRApplicationError GetApplicationKeyByIndex( uint32_t unApplicationIndex, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) { return _table.GetApplicationKeyByIndex(unApplicationIndex, pchAppKeyBuffer, unAppKeyBufferLen); }

        EVRApplicationError GetApplicationKeyByProcessId( uint32_t unProcessId, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) { return _table.GetApplicationKeyByProcessId(unProcessId, pchAppKeyBuffer, unAppKeyBufferLen); }

        EVRApplicationError LaunchApplication( const char *pchAppKey ) { return _table.LaunchApplication(pchAppKey); }

        EVRApplicationError LaunchTemplateApplication( const char *pchTemplateAppKey, const char *pchNewAppKey, VR_ARRAY_COUNT( unKeys ) const AppOverrideKeys_t *pKeys, uint32_t unKeys ) { return _table.LaunchTemplateApplication(pchTemplateAppKey, pchNewAppKey, pKeys, unKeys); }

        vr::EVRApplicationError LaunchApplicationFromMimeType( const char *pchMimeType, const char *pchArgs ) { return _table.LaunchApplicationFromMimeType(pchMimeType, pchArgs); }

        EVRApplicationError LaunchDashboardOverlay( const char *pchAppKey ) { return _table.LaunchDashboardOverlay(pchAppKey); }

        bool CancelApplicationLaunch( const char *pchAppKey ) { return _table.CancelApplicationLaunch(pchAppKey); }

        EVRApplicationError IdentifyApplication( uint32_t unProcessId, const char *pchAppKey ) { return _table.IdentifyApplication(unProcessId, pchAppKey); }

        uint32_t GetApplicationProcessId( const char *pchAppKey ) { return _table.GetApplicationProcessId(pchAppKey); }

        const char *GetApplicationsErrorNameFromEnum( EVRApplicationError error ) { return _table.GetApplicationsErrorNameFromEnum(error); }
 
        // ---------------  Application properties  --------------- //

        uint32_t GetApplicationPropertyString( const char *pchAppKey, EVRApplicationProperty eProperty, VR_OUT_STRING() char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError = nullptr ) { return _table.GetApplicationPropertyString(pchAppKey, eProperty, pchPropertyValueBuffer, unPropertyValueBufferLen, peError); }

        bool GetApplicationPropertyBool( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) { return _table.GetApplicationPropertyBool(pchAppKey, eProperty, peError); }

        uint64_t GetApplicationPropertyUint64( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) { return _table.GetApplicationPropertyUint64(pchAppKey, eProperty, peError); }

        EVRApplicationError SetApplicationAutoLaunch( const char *pchAppKey, bool bAutoLaunch ) { return _table.SetApplicationAutoLaunch(pchAppKey, bAutoLaunch); }

        bool GetApplicationAutoLaunch( const char *pchAppKey ) { return _table.GetApplicationAutoLaunch(pchAppKey); }

        EVRApplicationError SetDefaultApplicationForMimeType( const char *pchAppKey, const char *pchMimeType ) { return _table.SetDefaultApplicationForMimeType(pchAppKey, pchMimeType); }

        bool GetDefaultApplicationForMimeType( const char *pchMimeType, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) { return _table.GetDefaultApplicationForMimeType(pchMimeType, pchAppKeyBuffer, unAppKeyBufferLen); }

        bool GetApplicationSupportedMimeTypes( const char *pchAppKey, VR_OUT_STRING() char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer ) { return _table.GetApplicationSupportedMimeTypes(pchAppKey, pchMimeTypesBuffer, unMimeTypesBuffer); }

        uint32_t GetApplicationsThatSupportMimeType( const char *pchMimeType, VR_OUT_STRING() char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer ) { return _table.GetApplicationsThatSupportMimeType(pchMimeType, pchAppKeysThatSupportBuffer, unAppKeysThatSupportBuffer); }

        uint32_t GetApplicationLaunchArguments( uint32_t unHandle, VR_OUT_STRING() char *pchArgs, uint32_t unArgs ) { return _table.GetApplicationLaunchArguments(unHandle, pchArgs, unArgs); }
 
        // ---------------  Transition methods --------------- //

        EVRApplicationError GetStartingApplication( VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) { return _table.GetStartingApplication(pchAppKeyBuffer, unAppKeyBufferLen); }

        EVRApplicationTransitionState GetTransitionState() { return _table.GetTransitionState(); }

        EVRApplicationError PerformApplicationPrelaunchCheck( const char *pchAppKey ) { return _table.PerformApplicationPrelaunchCheck(pchAppKey); }

        const char *GetApplicationsTransitionStateNameFromEnum( EVRApplicationTransitionState state ) { return _table.GetApplicationsTransitionStateNameFromEnum(state); }

        bool IsQuitUserPromptRequested() { return _table.IsQuitUserPromptRequested(); }

        EVRApplicationError LaunchInternalProcess( const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory ) { return _table.LaunchInternalProcess(pchBinaryPath, pchArguments, pchWorkingDirectory); }

        uint32_t GetCurrentSceneProcessId() { return _table.GetCurrentSceneProcessId(); }
    };
 
    static const char * const IVRApplications_Version = "FnTable:IVRApplications_006";
 
} // namespace vr
 
// ivrsettings.h
namespace vr
{
    enum EVRSettingsError
    {
        VRSettingsError_None = 0,
        VRSettingsError_IPCFailed = 1,
        VRSettingsError_WriteFailed = 2,
        VRSettingsError_ReadFailed = 3,
        VRSettingsError_JsonParseFailed = 4,
        VRSettingsError_UnsetSettingHasNoDefault = 5, // This will be returned if the setting does not appear in the appropriate default file and has not been set
    };
 
    // The maximum length of a settings key
    static const uint32_t k_unMaxSettingsKeyLength = 128;
 
    struct VR_IVRSettings_FnTable
    {
        const char *(__stdcall *GetSettingsErrorNameFromEnum)( EVRSettingsError eError );
        bool (__stdcall *Sync)( bool bForce, EVRSettingsError *peError);
        void (__stdcall *SetBool)( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError);
        void (__stdcall *SetInt32)( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError);
        void (__stdcall *SetFloat)( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError);
        void (__stdcall *SetString)( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError);
        bool (__stdcall *GetBool)( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError);
        int32_t (__stdcall *GetInt32)( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError);
        float (__stdcall *GetFloat)( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError);
        void (__stdcall *GetString)( const char *pchSection, const char *pchSettingsKey,  char *pchValue, uint32_t unValueLen, EVRSettingsError *peError);
        void (__stdcall *RemoveSection)( const char *pchSection, EVRSettingsError *peError);
        void (__stdcall *RemoveKeyInSection)( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError);
    };
 
    class IVRSettings
    {
        VR_IVRSettings_FnTable _table;
    public:
        const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) { return _table.GetSettingsErrorNameFromEnum(eError); }
 
        // Returns true if file sync occurred (force or settings dirty)
        bool Sync( bool bForce = false, EVRSettingsError *peError = nullptr ) { return _table.Sync(bForce, peError); }
 
        void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr ) { _table.SetBool(pchSection, pchSettingsKey, bValue, peError); }
        void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr ) { _table.SetInt32(pchSection, pchSettingsKey, nValue, peError); }
        void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr ) { _table.SetFloat(pchSection, pchSettingsKey, flValue, peError); }
        void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr ) { _table.SetString(pchSection, pchSettingsKey, pchValue, peError); }
 
        // Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
        // of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
        bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) { return _table.GetBool(pchSection, pchSettingsKey, peError); }
        int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) { return _table.GetInt32(pchSection, pchSettingsKey, peError); }
        float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) { return _table.GetFloat(pchSection, pchSettingsKey, peError); }
        void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr ) { _table.GetString(pchSection, pchSettingsKey, pchValue, unValueLen, peError); }
 
        void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr ) { _table.RemoveSection(pchSection, peError); }
        void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) { _table.RemoveKeyInSection(pchSection, pchSettingsKey, peError); }
    };
 
    //-----------------------------------------------------------------------------
    static const char * const IVRSettings_Version = "FnTable:IVRSettings_002";
 
    //-----------------------------------------------------------------------------
    // steamvr keys
    static const char * const k_pch_SteamVR_Section = "steamvr";
    static const char * const k_pch_SteamVR_RequireHmd_String = "requireHmd";
    static const char * const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
    static const char * const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
    static const char * const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
    static const char * const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
    static const char * const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
    static const char * const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
    static const char * const k_pch_SteamVR_SendSystemButtonToAllApps_Bool= "sendSystemButtonToAllApps";
    static const char * const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
    static const char * const k_pch_SteamVR_IPD_Float = "ipd";
    static const char * const k_pch_SteamVR_Background_String = "background";
    static const char * const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
    static const char * const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
    static const char * const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
    static const char * const k_pch_SteamVR_GridColor_String = "gridColor";
    static const char * const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
    static const char * const k_pch_SteamVR_ShowStage_Bool = "showStage";
    static const char * const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
    static const char * const k_pch_SteamVR_DirectMode_Bool = "directMode";
    static const char * const k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
    static const char * const k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
    static const char * const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
    static const char * const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
    static const char * const k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
    static const char * const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
    static const char * const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
    static const char * const k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
    static const char * const k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
    static const char * const k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
    static const char * const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
    static const char * const k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
    static const char * const k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
    static const char * const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
    static const char * const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
    static const char * const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
    static const char * const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
    static const char * const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
    static const char * const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
    static const char * const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
    static const char * const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
    static const char * const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
    static const char * const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
    static const char * const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
    static const char * const k_pch_SteamVR_AllowDisplayLockedMode_Bool = "allowDisplayLockedMode";
    static const char * const k_pch_SteamVR_HaveStartedTutorialForNativeChaperoneDriver_Bool = "haveStartedTutorialForNativeChaperoneDriver";
    static const char * const k_pch_SteamVR_ForceWindows32bitVRMonitor = "forceWindows32BitVRMonitor";
 
    //-----------------------------------------------------------------------------
    // lighthouse keys
    static const char * const k_pch_Lighthouse_Section = "driver_lighthouse";
    static const char * const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
    static const char * const k_pch_Lighthouse_DisableIMUExceptHMD_Bool = "disableimuexcepthmd";
    static const char * const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
    static const char * const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
    static const char * const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
    static const char * const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
    static const char * const k_pch_Lighthouse_EnableBluetooth_Bool = "enableBluetooth";
 
    //-----------------------------------------------------------------------------
    // null keys
    static const char * const k_pch_Null_Section = "driver_null";
    static const char * const k_pch_Null_SerialNumber_String = "serialNumber";
    static const char * const k_pch_Null_ModelNumber_String = "modelNumber";
    static const char * const k_pch_Null_WindowX_Int32 = "windowX";
    static const char * const k_pch_Null_WindowY_Int32 = "windowY";
    static const char * const k_pch_Null_WindowWidth_Int32 = "windowWidth";
    static const char * const k_pch_Null_WindowHeight_Int32 = "windowHeight";
    static const char * const k_pch_Null_RenderWidth_Int32 = "renderWidth";
    static const char * const k_pch_Null_RenderHeight_Int32 = "renderHeight";
    static const char * const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
    static const char * const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
 
    //-----------------------------------------------------------------------------
    // user interface keys
    static const char * const k_pch_UserInterface_Section = "userinterface";
    static const char * const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
    static const char * const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
    static const char * const k_pch_UserInterface_Screenshots_Bool = "screenshots";
    static const char * const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
 
    //-----------------------------------------------------------------------------
    // notification keys
    static const char * const k_pch_Notifications_Section = "notifications";
    static const char * const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
 
    //-----------------------------------------------------------------------------
    // keyboard keys
    static const char * const k_pch_Keyboard_Section = "keyboard";
    static const char * const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
    static const char * const k_pch_Keyboard_ScaleX = "ScaleX";
    static const char * const k_pch_Keyboard_ScaleY = "ScaleY";
    static const char * const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
    static const char * const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
    static const char * const k_pch_Keyboard_OffsetY = "OffsetY";
    static const char * const k_pch_Keyboard_Smoothing = "Smoothing";
 
    //-----------------------------------------------------------------------------
    // perf keys
    static const char * const k_pch_Perf_Section = "perfcheck";
    static const char * const k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
    static const char * const k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
    static const char * const k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
    static const char * const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
    static const char * const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
    static const char * const k_pch_Perf_TestData_Float = "perfTestData";
    static const char * const k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
 
    //-----------------------------------------------------------------------------
    // collision bounds keys
    static const char * const k_pch_CollisionBounds_Section = "collisionBounds";
    static const char * const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
    static const char * const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
    static const char * const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
    static const char * const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
    static const char * const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
    static const char * const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
    static const char * const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
    static const char * const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
    static const char * const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
 
    //-----------------------------------------------------------------------------
    // camera keys
    static const char * const k_pch_Camera_Section = "camera";
    static const char * const k_pch_Camera_EnableCamera_Bool = "enableCamera";
    static const char * const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
    static const char * const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
    static const char * const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
    static const char * const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
    static const char * const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
    static const char * const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
    static const char * const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
    static const char * const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
 
    //-----------------------------------------------------------------------------
    // audio keys
    static const char * const k_pch_audio_Section = "audio";
    static const char * const k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
    static const char * const k_pch_audio_OnRecordDevice_String = "onRecordDevice";
    static const char * const k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
    static const char * const k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
    static const char * const k_pch_audio_OffRecordDevice_String = "offRecordDevice";
    static const char * const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
 
    //-----------------------------------------------------------------------------
    // power management keys
    static const char * const k_pch_Power_Section = "power";
    static const char * const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
    static const char * const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
    static const char * const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
    static const char * const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
    static const char * const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
    static const char * const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
 
    //-----------------------------------------------------------------------------
    // dashboard keys
    static const char * const k_pch_Dashboard_Section = "dashboard";
    static const char * const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
    static const char * const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
 
    //-----------------------------------------------------------------------------
    // model skin keys
    static const char * const k_pch_modelskin_Section = "modelskins";
 
    //-----------------------------------------------------------------------------
    // driver keys - These could be checked in any driver_<name> section
    static const char * const k_pch_Driver_Enable_Bool = "enable";
 
} // namespace vr
 
// ivrchaperone.h
namespace vr
{
 
#pragma pack( push, 8 )
 
enum ChaperoneCalibrationState
{
    // OK!
    ChaperoneCalibrationState_OK = 1,                                   // Chaperone is fully calibrated and working correctly
 
    // Warnings
    ChaperoneCalibrationState_Warning = 100,
    ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,    // A base station thinks that it might have moved
    ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,         // There are less base stations than when calibrated
    ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,        // Seated bounds haven't been calibrated for the current tracking center
 
    // Errors
    ChaperoneCalibrationState_Error = 200,                              // The UniverseID is invalid
    ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,     // Tracking center hasn't be calibrated for at least one of the base stations
    ChaperoneCalibrationState_Error_BaseStationConflict = 202,          // Tracking center is calibrated, but base stations disagree on the tracking space
    ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,              // Play Area hasn't been calibrated for the current tracking center
    ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,       // Collision Bounds haven't been calibrated for the current tracking center
};
 

struct VR_IVRChaperone_FnTable
{
    ChaperoneCalibrationState (__stdcall *GetCalibrationState)();
    bool (__stdcall *GetPlayAreaSize)( float *pSizeX, float *pSizeZ );
    bool (__stdcall *GetPlayAreaRect)( HmdQuad_t *rect );
    void (__stdcall *ReloadInfo)( void );
    void (__stdcall *SetSceneColor)( HmdColor_t color );
    void (__stdcall *GetBoundsColor)( HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t *pOutputCameraColor );
    bool (__stdcall *AreBoundsVisible)();
    void (__stdcall *ForceBoundsVisible)( bool bForce );
};
 
class IVRChaperone
{
    VR_IVRChaperone_FnTable _table;
public:

    ChaperoneCalibrationState GetCalibrationState() { return _table.GetCalibrationState(); }

    bool GetPlayAreaSize( float *pSizeX, float *pSizeZ ) { return _table.GetPlayAreaSize(pSizeX, pSizeZ); }

    bool GetPlayAreaRect( HmdQuad_t *rect ) { return _table.GetPlayAreaRect(rect); }

    void ReloadInfo( void ) { _table.ReloadInfo(); }

    void SetSceneColor( HmdColor_t color ) { _table.SetSceneColor(color); }

    void GetBoundsColor( HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t *pOutputCameraColor ) { _table.GetBoundsColor(pOutputColorArray, nNumOutputColors, flCollisionBoundsFadeDistance, pOutputCameraColor); }

    bool AreBoundsVisible() { return _table.AreBoundsVisible(); }

    void ForceBoundsVisible( bool bForce ) { _table.ForceBoundsVisible(bForce); }
};
 
static const char * const IVRChaperone_Version = "FnTable:IVRChaperone_003";
 
#pragma pack( pop )
 
}
 
// ivrchaperonesetup.h
namespace vr
{
 
enum EChaperoneConfigFile
{
    EChaperoneConfigFile_Live = 1,      // The live chaperone config, used by most applications and games
    EChaperoneConfigFile_Temp = 2,      // The temporary chaperone config, used to live-preview collision bounds in room setup
};
 
enum EChaperoneImportFlags
{
    EChaperoneImport_BoundsOnly = 0x0001,
};

struct VR_IVRChaperoneSetup_FnTable
{
    bool (__stdcall *CommitWorkingCopy)( EChaperoneConfigFile configFile );
    void (__stdcall *RevertWorkingCopy)();
    bool (__stdcall *GetWorkingPlayAreaSize)( float *pSizeX, float *pSizeZ );
    bool (__stdcall *GetWorkingPlayAreaRect)( HmdQuad_t *rect );
    bool (__stdcall *GetWorkingCollisionBoundsInfo)(  HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount );
    bool (__stdcall *GetLiveCollisionBoundsInfo)(  HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount );
    bool (__stdcall *GetWorkingSeatedZeroPoseToRawTrackingPose)( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose );
    bool (__stdcall *GetWorkingStandingZeroPoseToRawTrackingPose)( HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose );
    void (__stdcall *SetWorkingPlayAreaSize)( float sizeX, float sizeZ );
    void (__stdcall *SetWorkingCollisionBoundsInfo)(  HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount );
    void (__stdcall *SetWorkingSeatedZeroPoseToRawTrackingPose)( const HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose );
    void (__stdcall *SetWorkingStandingZeroPoseToRawTrackingPose)( const HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose );
    void (__stdcall *ReloadFromDisk)( EChaperoneConfigFile configFile );
    bool (__stdcall *GetLiveSeatedZeroPoseToRawTrackingPose)( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose );
    void (__stdcall *SetWorkingCollisionBoundsTagsInfo)(  uint8_t *pTagsBuffer, uint32_t unTagCount );
    bool (__stdcall *GetLiveCollisionBoundsTagsInfo)(  uint8_t *pTagsBuffer, uint32_t *punTagCount );
    bool (__stdcall *SetWorkingPhysicalBoundsInfo)(  HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount );
    bool (__stdcall *GetLivePhysicalBoundsInfo)(  HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount );
    bool (__stdcall *ExportLiveToBuffer)(  char *pBuffer, uint32_t *pnBufferLength );
    bool (__stdcall *ImportFromBufferToWorking)( const char *pBuffer, uint32_t nImportFlags );
};
 
class IVRChaperoneSetup
{
    VR_IVRChaperoneSetup_FnTable _table;
public:

    bool CommitWorkingCopy( EChaperoneConfigFile configFile ) { return _table.CommitWorkingCopy(configFile); }

    void RevertWorkingCopy() { _table.RevertWorkingCopy(); }

    bool GetWorkingPlayAreaSize( float *pSizeX, float *pSizeZ ) { return _table.GetWorkingPlayAreaSize(pSizeX, pSizeZ); }

    bool GetWorkingPlayAreaRect( HmdQuad_t *rect ) { return _table.GetWorkingPlayAreaRect(rect); }

    bool GetWorkingCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) { return _table.GetWorkingCollisionBoundsInfo(pQuadsBuffer, punQuadsCount); }

    bool GetLiveCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) { return _table.GetLiveCollisionBoundsInfo(pQuadsBuffer, punQuadsCount); }

    bool GetWorkingSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) { return _table.GetWorkingSeatedZeroPoseToRawTrackingPose(pmatSeatedZeroPoseToRawTrackingPose); }

    bool GetWorkingStandingZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose ) { return _table.GetWorkingStandingZeroPoseToRawTrackingPose(pmatStandingZeroPoseToRawTrackingPose); }

    void SetWorkingPlayAreaSize( float sizeX, float sizeZ ) { _table.SetWorkingPlayAreaSize(sizeX, sizeZ); }

    void SetWorkingCollisionBoundsInfo( VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount ) { _table.SetWorkingCollisionBoundsInfo(pQuadsBuffer, unQuadsCount); }

    void SetWorkingSeatedZeroPoseToRawTrackingPose( const HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose ) { _table.SetWorkingSeatedZeroPoseToRawTrackingPose(pMatSeatedZeroPoseToRawTrackingPose); }

    void SetWorkingStandingZeroPoseToRawTrackingPose( const HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose ) { _table.SetWorkingStandingZeroPoseToRawTrackingPose(pMatStandingZeroPoseToRawTrackingPose); }

    void ReloadFromDisk( EChaperoneConfigFile configFile ) { _table.ReloadFromDisk(configFile); }

    bool GetLiveSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) { return _table.GetLiveSeatedZeroPoseToRawTrackingPose(pmatSeatedZeroPoseToRawTrackingPose); }
 
    void SetWorkingCollisionBoundsTagsInfo( VR_ARRAY_COUNT(unTagCount) uint8_t *pTagsBuffer, uint32_t unTagCount ) { _table.SetWorkingCollisionBoundsTagsInfo(pTagsBuffer, unTagCount); }
    bool GetLiveCollisionBoundsTagsInfo( VR_OUT_ARRAY_COUNT(punTagCount) uint8_t *pTagsBuffer, uint32_t *punTagCount ) { return _table.GetLiveCollisionBoundsTagsInfo(pTagsBuffer, punTagCount); }
 
    bool SetWorkingPhysicalBoundsInfo( VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount ) { return _table.SetWorkingPhysicalBoundsInfo(pQuadsBuffer, unQuadsCount); }
    bool GetLivePhysicalBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) { return _table.GetLivePhysicalBoundsInfo(pQuadsBuffer, punQuadsCount); }
 
    bool ExportLiveToBuffer( VR_OUT_STRING() char *pBuffer, uint32_t *pnBufferLength ) { return _table.ExportLiveToBuffer(pBuffer, pnBufferLength); }
    bool ImportFromBufferToWorking( const char *pBuffer, uint32_t nImportFlags ) { return _table.ImportFromBufferToWorking(pBuffer, nImportFlags); }
};
 
static const char * const IVRChaperoneSetup_Version = "FnTable:IVRChaperoneSetup_005";
 
 
}
 
// ivrcompositor.h
namespace vr
{
 
#pragma pack( push, 8 )

enum EVRCompositorError
{
    VRCompositorError_None                      = 0,
    VRCompositorError_RequestFailed             = 1,
    VRCompositorError_IncompatibleVersion       = 100,
    VRCompositorError_DoNotHaveFocus            = 101,
    VRCompositorError_InvalidTexture            = 102,
    VRCompositorError_IsNotSceneApplication     = 103,
    VRCompositorError_TextureIsOnWrongDevice    = 104,
    VRCompositorError_TextureUsesUnsupportedFormat = 105,
    VRCompositorError_SharedTexturesNotSupported = 106,
    VRCompositorError_IndexOutOfRange           = 107,
    VRCompositorError_AlreadySubmitted          = 108,
    VRCompositorError_InvalidBounds             = 109,
};

enum EVRCompositorTimingMode
{
    VRCompositorTimingMode_Implicit                                         = 0,
    VRCompositorTimingMode_Explicit_RuntimePerformsPostPresentHandoff       = 1,
    VRCompositorTimingMode_Explicit_ApplicationPerformsPostPresentHandoff   = 2,
};
 
const uint32_t VRCompositor_ReprojectionReason_Cpu = 0x01;
const uint32_t VRCompositor_ReprojectionReason_Gpu = 0x02;
const uint32_t VRCompositor_ReprojectionAsync      = 0x04;  // This flag indicates the async reprojection mode is active,
                                                            // but does not indicate if reprojection actually happened or not.
                                                            // Use the ReprojectionReason flags above to check if reprojection
                                                            // was actually applied (i.e. scene texture was reused).
                                                            // NumFramePresents > 1 also indicates the scene texture was reused,
                                                            // and also the number of times that it was presented in total.

struct Compositor_FrameTiming
{
    uint32_t m_nSize; // Set to sizeof( Compositor_FrameTiming )
    uint32_t m_nFrameIndex;
    uint32_t m_nNumFramePresents; // number of times this frame was presented
    uint32_t m_nNumMisPresented; // number of times this frame was presented on a vsync other than it was originally predicted to
    uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out
    uint32_t m_nReprojectionFlags;

    double m_flSystemTimeInSeconds;

    float m_flPreSubmitGpuMs; // time spent rendering the scene (gpu work submitted between WaitGetPoses and second Submit)
    float m_flPostSubmitGpuMs; // additional time spent rendering by application (e.g. companion window)
    float m_flTotalRenderGpuMs; // time between work submitted immediately after present (ideally vsync) until the end of compositor submitted work
    float m_flCompositorRenderGpuMs; // time spend performing distortion correction, rendering chaperone, overlays, etc.
    float m_flCompositorRenderCpuMs; // time spent on cpu submitting the above work for this frame
    float m_flCompositorIdleCpuMs; // time spent waiting for running start (application could have used this much more time)

    float m_flClientFrameIntervalMs; // time between calls to WaitGetPoses
    float m_flPresentCallCpuMs; // time blocked on call to present (usually 0.0, but can go long)
    float m_flWaitForPresentCpuMs; // time spent spin-waiting for frame index to change (not near-zero indicates wait object failure)
    float m_flSubmitFrameMs; // time spent in IVRCompositor::Submit (not near-zero indicates driver issue)

    float m_flWaitGetPosesCalledMs;
    float m_flNewPosesReadyMs;
    float m_flNewFrameReadyMs; // second call to IVRCompositor::Submit
    float m_flCompositorUpdateStartMs;
    float m_flCompositorUpdateEndMs;
    float m_flCompositorRenderStartMs;
 
    vr::TrackedDevicePose_t m_HmdPose; // pose used by app to render this frame
};

struct Compositor_CumulativeStats
{
    uint32_t m_nPid; // Process id associated with these stats (may no longer be running).
    uint32_t m_nNumFramePresents; // total number of times we called present (includes reprojected frames)
    uint32_t m_nNumDroppedFrames; // total number of times an old frame was re-scanned out (without reprojection)
    uint32_t m_nNumReprojectedFrames; // total number of times a frame was scanned out a second time (with reprojection)

    uint32_t m_nNumFramePresentsOnStartup;
    uint32_t m_nNumDroppedFramesOnStartup;
    uint32_t m_nNumReprojectedFramesOnStartup;

    uint32_t m_nNumLoading;
    uint32_t m_nNumFramePresentsLoading;
    uint32_t m_nNumDroppedFramesLoading;
    uint32_t m_nNumReprojectedFramesLoading;

    uint32_t m_nNumTimedOut;
    uint32_t m_nNumFramePresentsTimedOut;
    uint32_t m_nNumDroppedFramesTimedOut;
    uint32_t m_nNumReprojectedFramesTimedOut;
};
 
#pragma pack( pop )

struct VR_IVRCompositor_FnTable
{
    void (__stdcall *SetTrackingSpace)( ETrackingUniverseOrigin eOrigin );
    ETrackingUniverseOrigin (__stdcall *GetTrackingSpace)();
    EVRCompositorError (__stdcall *WaitGetPoses)(  TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
         TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount );
    EVRCompositorError (__stdcall *GetLastPoses)(  TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
         TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount );
    EVRCompositorError (__stdcall *GetLastPoseForTrackedDeviceIndex)( TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose );
    EVRCompositorError (__stdcall *Submit)( EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t* pBounds, EVRSubmitFlags nSubmitFlags);
    void (__stdcall *ClearLastSubmittedFrame)();
    void (__stdcall *PostPresentHandoff)();
    bool (__stdcall *GetFrameTiming)( Compositor_FrameTiming *pTiming, uint32_t unFramesAgo);
    uint32_t (__stdcall *GetFrameTimings)( Compositor_FrameTiming *pTiming, uint32_t nFrames );
    float (__stdcall *GetFrameTimeRemaining)();
    void (__stdcall *GetCumulativeStats)( Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes );
    void (__stdcall *FadeToColor)( float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
    HmdColor_t (__stdcall *GetCurrentFadeColor)( bool bBackground);
    void (__stdcall *FadeGrid)( float fSeconds, bool bFadeIn );
    float (__stdcall *GetCurrentGridAlpha)();
    EVRCompositorError (__stdcall *SetSkyboxOverride)(  const Texture_t *pTextures, uint32_t unTextureCount );
    void (__stdcall *ClearSkyboxOverride)();
    void (__stdcall *CompositorBringToFront)();
    void (__stdcall *CompositorGoToBack)();
    void (__stdcall *CompositorQuit)();
    bool (__stdcall *IsFullscreen)();
    uint32_t (__stdcall *GetCurrentSceneFocusProcess)();
    uint32_t (__stdcall *GetLastFrameRenderer)();
    bool (__stdcall *CanRenderScene)();
    void (__stdcall *ShowMirrorWindow)();
    void (__stdcall *HideMirrorWindow)();
    bool (__stdcall *IsMirrorWindowVisible)();
    void (__stdcall *CompositorDumpImages)();
    bool (__stdcall *ShouldAppRenderWithLowResources)();
    void (__stdcall *ForceInterleavedReprojectionOn)( bool bOverride );
    void (__stdcall *ForceReconnectProcess)();
    void (__stdcall *SuspendRendering)( bool bSuspend );
    vr::EVRCompositorError (__stdcall *GetMirrorTextureD3D11)( vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView );
    void (__stdcall *ReleaseMirrorTextureD3D11)( void *pD3D11ShaderResourceView );
    vr::EVRCompositorError (__stdcall *GetMirrorTextureGL)( vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle );
    bool (__stdcall *ReleaseSharedGLTexture)( vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle );
    void (__stdcall *LockGLSharedTextureForAccess)( vr::glSharedTextureHandle_t glSharedTextureHandle );
    void (__stdcall *UnlockGLSharedTextureForAccess)( vr::glSharedTextureHandle_t glSharedTextureHandle );
    uint32_t (__stdcall *GetVulkanInstanceExtensionsRequired)(  char *pchValue, uint32_t unBufferSize );
    uint32_t (__stdcall *GetVulkanDeviceExtensionsRequired)( VkPhysicalDevice_T *pPhysicalDevice,  char *pchValue, uint32_t unBufferSize );
    void (__stdcall *SetExplicitTimingMode)( EVRCompositorTimingMode eTimingMode );
    EVRCompositorError (__stdcall *SubmitExplicitTimingData)();
};
 
class IVRCompositor
{
    VR_IVRCompositor_FnTable _table;
public:
    void SetTrackingSpace( ETrackingUniverseOrigin eOrigin ) { _table.SetTrackingSpace(eOrigin); }

    ETrackingUniverseOrigin GetTrackingSpace() { return _table.GetTrackingSpace(); }

    EVRCompositorError WaitGetPoses( VR_ARRAY_COUNT(unRenderPoseArrayCount) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
        VR_ARRAY_COUNT(unGamePoseArrayCount) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) { return _table.WaitGetPoses(pRenderPoseArray, unRenderPoseArrayCount, pGamePoseArray, unGamePoseArrayCount); }

    EVRCompositorError GetLastPoses( VR_ARRAY_COUNT( unRenderPoseArrayCount ) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
        VR_ARRAY_COUNT( unGamePoseArrayCount ) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) { return _table.GetLastPoses(pRenderPoseArray, unRenderPoseArrayCount, pGamePoseArray, unGamePoseArrayCount); }

    EVRCompositorError GetLastPoseForTrackedDeviceIndex( TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose ) { return _table.GetLastPoseForTrackedDeviceIndex(unDeviceIndex, pOutputPose, pOutputGamePose); }

    EVRCompositorError Submit( EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t* pBounds = 0, EVRSubmitFlags nSubmitFlags = Submit_Default ) { return _table.Submit(eEye, pTexture, pBounds, nSubmitFlags); }

    void ClearLastSubmittedFrame() { _table.ClearLastSubmittedFrame(); }

    void PostPresentHandoff() { _table.PostPresentHandoff(); }

    bool GetFrameTiming( Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0 ) { return _table.GetFrameTiming(pTiming, unFramesAgo); }

    uint32_t GetFrameTimings( Compositor_FrameTiming *pTiming, uint32_t nFrames ) { return _table.GetFrameTimings(pTiming, nFrames); }

    float GetFrameTimeRemaining() { return _table.GetFrameTimeRemaining(); }

    void GetCumulativeStats( Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes ) { _table.GetCumulativeStats(pStats, nStatsSizeInBytes); }

    void FadeToColor( float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false ) { _table.FadeToColor(fSeconds, fRed, fGreen, fBlue, fAlpha, bBackground); }

    HmdColor_t GetCurrentFadeColor( bool bBackground = false ) { return _table.GetCurrentFadeColor(bBackground); }

    void FadeGrid( float fSeconds, bool bFadeIn ) { _table.FadeGrid(fSeconds, bFadeIn); }

    float GetCurrentGridAlpha() { return _table.GetCurrentGridAlpha(); }

    EVRCompositorError SetSkyboxOverride( VR_ARRAY_COUNT( unTextureCount ) const Texture_t *pTextures, uint32_t unTextureCount ) { return _table.SetSkyboxOverride(pTextures, unTextureCount); }

    void ClearSkyboxOverride() { _table.ClearSkyboxOverride(); }

    void CompositorBringToFront() { _table.CompositorBringToFront(); }

    void CompositorGoToBack() { _table.CompositorGoToBack(); }

    void CompositorQuit() { _table.CompositorQuit(); }
    
    bool IsFullscreen() { return _table.IsFullscreen(); }

    uint32_t GetCurrentSceneFocusProcess() { return _table.GetCurrentSceneFocusProcess(); }

    uint32_t GetLastFrameRenderer() { return _table.GetLastFrameRenderer(); }

    bool CanRenderScene() { return _table.CanRenderScene(); }

    void ShowMirrorWindow() { _table.ShowMirrorWindow(); }

    void HideMirrorWindow() { _table.HideMirrorWindow(); }

    bool IsMirrorWindowVisible() { return _table.IsMirrorWindowVisible(); }

    void CompositorDumpImages() { _table.CompositorDumpImages(); }

    bool ShouldAppRenderWithLowResources() { return _table.ShouldAppRenderWithLowResources(); }

    void ForceInterleavedReprojectionOn( bool bOverride ) { _table.ForceInterleavedReprojectionOn(bOverride); }

    void ForceReconnectProcess() { _table.ForceReconnectProcess(); }

    void SuspendRendering( bool bSuspend ) { _table.SuspendRendering(bSuspend); }

    vr::EVRCompositorError GetMirrorTextureD3D11( vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView ) { return _table.GetMirrorTextureD3D11(eEye, pD3D11DeviceOrResource, ppD3D11ShaderResourceView); }
    void ReleaseMirrorTextureD3D11( void *pD3D11ShaderResourceView ) { _table.ReleaseMirrorTextureD3D11(pD3D11ShaderResourceView); }

    vr::EVRCompositorError GetMirrorTextureGL( vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle ) { return _table.GetMirrorTextureGL(eEye, pglTextureId, pglSharedTextureHandle); }
    bool ReleaseSharedGLTexture( vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle ) { return _table.ReleaseSharedGLTexture(glTextureId, glSharedTextureHandle); }
    void LockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) { _table.LockGLSharedTextureForAccess(glSharedTextureHandle); }
    void UnlockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) { _table.UnlockGLSharedTextureForAccess(glSharedTextureHandle); }

    uint32_t GetVulkanInstanceExtensionsRequired( VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) { return _table.GetVulkanInstanceExtensionsRequired(pchValue, unBufferSize); }

    uint32_t GetVulkanDeviceExtensionsRequired( VkPhysicalDevice_T *pPhysicalDevice, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) { return _table.GetVulkanDeviceExtensionsRequired(pPhysicalDevice, pchValue, unBufferSize); }

    void SetExplicitTimingMode( EVRCompositorTimingMode eTimingMode ) { _table.SetExplicitTimingMode(eTimingMode); }

    EVRCompositorError SubmitExplicitTimingData() { return _table.SubmitExplicitTimingData(); }
};
 
static const char * const IVRCompositor_Version = "FnTable:IVRCompositor_022";
 
} // namespace vr
 
 
 
// ivrnotifications.h
namespace vr
{
 
#pragma pack( push, 8 )
 
// Used for passing graphic data
struct NotificationBitmap_t
{
    NotificationBitmap_t()
        : m_pImageData( nullptr )
        , m_nWidth( 0 )
        , m_nHeight( 0 )
        , m_nBytesPerPixel( 0 )
    {
    };
 
    void *m_pImageData;
    int32_t m_nWidth;
    int32_t m_nHeight;
    int32_t m_nBytesPerPixel;
};
 

enum EVRNotificationType
{
    EVRNotificationType_Transient = 0,

    EVRNotificationType_Persistent = 1,

    EVRNotificationType_Transient_SystemWithUserValue = 2,
};
 
enum EVRNotificationStyle
{
    EVRNotificationStyle_None = 0,

    EVRNotificationStyle_Application = 100,

    EVRNotificationStyle_Contact_Disabled = 200,

    EVRNotificationStyle_Contact_Enabled = 201,

    EVRNotificationStyle_Contact_Active = 202,
};
 
static const uint32_t k_unNotificationTextMaxSize = 256;
 
typedef uint32_t VRNotificationId;
 
 
 
#pragma pack( pop )

struct VR_IVRNotifications_FnTable
{
    EVRNotificationError (__stdcall *CreateNotification)( VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char *pchText, EVRNotificationStyle style, const NotificationBitmap_t *pImage, /* out */ VRNotificationId *pNotificationId );
    EVRNotificationError (__stdcall *RemoveNotification)( VRNotificationId notificationId );
};
 
class IVRNotifications
{
    VR_IVRNotifications_FnTable _table;
public:
    EVRNotificationError CreateNotification( VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char *pchText, EVRNotificationStyle style, const NotificationBitmap_t *pImage, /* out */ VRNotificationId *pNotificationId ) { return _table.CreateNotification(ulOverlayHandle, ulUserValue, type, pchText, style, pImage, pNotificationId); }

    EVRNotificationError RemoveNotification( VRNotificationId notificationId ) { return _table.RemoveNotification(notificationId); }
 
};
 
static const char * const IVRNotifications_Version = "FnTable:IVRNotifications_002";
 
} // namespace vr
 
 
 
// ivroverlay.h
namespace vr
{

    static const uint32_t k_unVROverlayMaxKeyLength = 128;

    static const uint32_t k_unVROverlayMaxNameLength = 128;

    static const uint32_t k_unMaxOverlayCount = 64;

    static const uint32_t k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;

    enum VROverlayInputMethod
    {
        VROverlayInputMethod_None       = 0, // No input events will be generated automatically for this overlay
        VROverlayInputMethod_Mouse      = 1, // Tracked controllers will get mouse events automatically
        VROverlayInputMethod_DualAnalog = 2, // Analog inputs from tracked controllers are turned into DualAnalog events
    };

    enum VROverlayTransformType
    {
        VROverlayTransform_Absolute                 = 0,
        VROverlayTransform_TrackedDeviceRelative    = 1,
        VROverlayTransform_SystemOverlay            = 2,
        VROverlayTransform_TrackedComponent         = 3,
    };

    enum VROverlayFlags
    {
        VROverlayFlags_None         = 0,
 
        // The following only take effect when rendered using the high quality render path (see SetHighQualityOverlay).
        VROverlayFlags_Curved       = 1,
        VROverlayFlags_RGSS4X       = 2,
 
        // Set this flag on a dashboard overlay to prevent a tab from showing up for that overlay
        VROverlayFlags_NoDashboardTab = 3,
 
        // Set this flag on a dashboard that is able to deal with gamepad focus events
        VROverlayFlags_AcceptsGamepadEvents = 4,
 
        // Indicates that the overlay should dim/brighten to show gamepad focus
        VROverlayFlags_ShowGamepadFocus = 5,
 
        // When in VROverlayInputMethod_Mouse you can optionally enable sending VRScroll_t 
        VROverlayFlags_SendVRScrollEvents = 6,
        VROverlayFlags_SendVRTouchpadEvents = 7,
 
        // If set this will render a vertical scroll wheel on the primary controller, 
        //  only needed if not using VROverlayFlags_SendVRScrollEvents but you still want to represent a scroll wheel
        VROverlayFlags_ShowTouchPadScrollWheel = 8,
 
        // If this is set ownership and render access to the overlay are transferred 
        // to the new scene process on a call to IVRApplications::LaunchInternalProcess
        VROverlayFlags_TransferOwnershipToInternalProcess = 9,
 
        // If set, renders 50% of the texture in each eye, side by side
        VROverlayFlags_SideBySide_Parallel = 10, // Texture is left/right
        VROverlayFlags_SideBySide_Crossed = 11, // Texture is crossed and right/left
 
        VROverlayFlags_Panorama = 12, // Texture is a panorama
        VROverlayFlags_StereoPanorama = 13, // Texture is a stereo panorama
 
        // If this is set on an overlay owned by the scene application that overlay
        // will be sorted with the "Other" overlays on top of all other scene overlays
        VROverlayFlags_SortWithNonSceneOverlays = 14,
 
        // If set, the overlay will be shown in the dashboard, otherwise it will be hidden.
        VROverlayFlags_VisibleInDashboard = 15,
    };
 
    enum VRMessageOverlayResponse
    {
        VRMessageOverlayResponse_ButtonPress_0 = 0,
        VRMessageOverlayResponse_ButtonPress_1 = 1,
        VRMessageOverlayResponse_ButtonPress_2 = 2,
        VRMessageOverlayResponse_ButtonPress_3 = 3,
        VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
        VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay= 5,
        VRMessageOverlayResponse_ApplicationQuit = 6
    };
 
    struct VROverlayIntersectionParams_t
    {
        HmdVector3_t vSource;
        HmdVector3_t vDirection;
        ETrackingUniverseOrigin eOrigin;
    };
 
    struct VROverlayIntersectionResults_t
    {
        HmdVector3_t vPoint;
        HmdVector3_t vNormal;
        HmdVector2_t vUVs;
        float fDistance;
    };
 
    // Input modes for the Big Picture gamepad text entry
    enum EGamepadTextInputMode
    {
        k_EGamepadTextInputModeNormal = 0,
        k_EGamepadTextInputModePassword = 1,
        k_EGamepadTextInputModeSubmit = 2,
    };
 
    // Controls number of allowed lines for the Big Picture gamepad text entry
    enum EGamepadTextInputLineMode
    {
        k_EGamepadTextInputLineModeSingleLine = 0,
        k_EGamepadTextInputLineModeMultipleLines = 1
    };

    enum EOverlayDirection
    {
        OverlayDirection_Up = 0,
        OverlayDirection_Down = 1,
        OverlayDirection_Left = 2,
        OverlayDirection_Right = 3,
        
        OverlayDirection_Count = 4,
    };
 
    enum EVROverlayIntersectionMaskPrimitiveType
    {
        OverlayIntersectionPrimitiveType_Rectangle,
        OverlayIntersectionPrimitiveType_Circle,
    };
 
    struct IntersectionMaskRectangle_t
    {
        float m_flTopLeftX;
        float m_flTopLeftY;
        float m_flWidth;
        float m_flHeight;
    };
 
    struct IntersectionMaskCircle_t
    {
        float m_flCenterX;
        float m_flCenterY;
        float m_flRadius;
    };

    typedef union
    {
        IntersectionMaskRectangle_t m_Rectangle;
        IntersectionMaskCircle_t m_Circle;
    } VROverlayIntersectionMaskPrimitive_Data_t;
 
    struct VROverlayIntersectionMaskPrimitive_t
    {
        EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
        VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
    };
 
    struct VR_IVROverlay_FnTable
    {
        EVROverlayError (__stdcall *FindOverlay)( const char *pchOverlayKey, VROverlayHandle_t * pOverlayHandle );
        EVROverlayError (__stdcall *CreateOverlay)( const char *pchOverlayKey, const char *pchOverlayName, VROverlayHandle_t * pOverlayHandle );
        EVROverlayError (__stdcall *DestroyOverlay)( VROverlayHandle_t ulOverlayHandle );
        EVROverlayError (__stdcall *SetHighQualityOverlay)( VROverlayHandle_t ulOverlayHandle );
        vr::VROverlayHandle_t (__stdcall *GetHighQualityOverlay)();
        uint32_t (__stdcall *GetOverlayKey)( VROverlayHandle_t ulOverlayHandle,  char *pchValue, uint32_t unBufferSize, EVROverlayError *pError);
        uint32_t (__stdcall *GetOverlayName)( VROverlayHandle_t ulOverlayHandle,  char *pchValue, uint32_t unBufferSize, EVROverlayError *pError);
        EVROverlayError (__stdcall *SetOverlayName)( VROverlayHandle_t ulOverlayHandle, const char *pchName );
        EVROverlayError (__stdcall *GetOverlayImageData)( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight );
        const char *(__stdcall *GetOverlayErrorNameFromEnum)( EVROverlayError error );
        EVROverlayError (__stdcall *SetOverlayRenderingPid)( VROverlayHandle_t ulOverlayHandle, uint32_t unPID );
        uint32_t (__stdcall *GetOverlayRenderingPid)( VROverlayHandle_t ulOverlayHandle );
        EVROverlayError (__stdcall *SetOverlayFlag)( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled );
        EVROverlayError (__stdcall *GetOverlayFlag)( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled );
        EVROverlayError (__stdcall *SetOverlayColor)( VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue );
        EVROverlayError (__stdcall *GetOverlayColor)( VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue );
        EVROverlayError (__stdcall *SetOverlayAlpha)( VROverlayHandle_t ulOverlayHandle, float fAlpha );
        EVROverlayError (__stdcall *GetOverlayAlpha)( VROverlayHandle_t ulOverlayHandle, float *pfAlpha );
        EVROverlayError (__stdcall *SetOverlayTexelAspect)( VROverlayHandle_t ulOverlayHandle, float fTexelAspect );
        EVROverlayError (__stdcall *GetOverlayTexelAspect)( VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect );
        EVROverlayError (__stdcall *SetOverlaySortOrder)( VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder );
        EVROverlayError (__stdcall *GetOverlaySortOrder)( VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder );
        EVROverlayError (__stdcall *SetOverlayWidthInMeters)( VROverlayHandle_t ulOverlayHandle, float fWidthInMeters );
        EVROverlayError (__stdcall *GetOverlayWidthInMeters)( VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters );
        EVROverlayError (__stdcall *SetOverlayAutoCurveDistanceRangeInMeters)( VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters );
        EVROverlayError (__stdcall *GetOverlayAutoCurveDistanceRangeInMeters)( VROverlayHandle_t ulOverlayHandle, float *pfMinDistanceInMeters, float *pfMaxDistanceInMeters );
        EVROverlayError (__stdcall *SetOverlayTextureColorSpace)( VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace );
        EVROverlayError (__stdcall *GetOverlayTextureColorSpace)( VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace );
        EVROverlayError (__stdcall *SetOverlayTextureBounds)( VROverlayHandle_t ulOverlayHandle, const VRTextureBounds_t *pOverlayTextureBounds );
        EVROverlayError (__stdcall *GetOverlayTextureBounds)( VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t *pOverlayTextureBounds );
        uint32_t (__stdcall *GetOverlayRenderModel)( vr::VROverlayHandle_t ulOverlayHandle,  char *pchValue, uint32_t unBufferSize, HmdColor_t *pColor, vr::EVROverlayError *pError );
        vr::EVROverlayError (__stdcall *SetOverlayRenderModel)( vr::VROverlayHandle_t ulOverlayHandle, const char *pchRenderModel, const HmdColor_t *pColor );
        EVROverlayError (__stdcall *GetOverlayTransformType)( VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType );
        EVROverlayError (__stdcall *SetOverlayTransformAbsolute)( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToOverlayTransform );
        EVROverlayError (__stdcall *GetOverlayTransformAbsolute)( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, HmdMatrix34_t *pmatTrackingOriginToOverlayTransform );
        EVROverlayError (__stdcall *SetOverlayTransformTrackedDeviceRelative)( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, const HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform );
        EVROverlayError (__stdcall *GetOverlayTransformTrackedDeviceRelative)( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform );
        EVROverlayError (__stdcall *SetOverlayTransformTrackedDeviceComponent)( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char *pchComponentName );
        EVROverlayError (__stdcall *GetOverlayTransformTrackedDeviceComponent)( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex,  char *pchComponentName, uint32_t unComponentNameSize );
        vr::EVROverlayError (__stdcall *GetOverlayTransformOverlayRelative)( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, HmdMatrix34_t *pmatParentOverlayToOverlayTransform );
        vr::EVROverlayError (__stdcall *SetOverlayTransformOverlayRelative)( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, const HmdMatrix34_t *pmatParentOverlayToOverlayTransform );
        EVROverlayError (__stdcall *ShowOverlay)( VROverlayHandle_t ulOverlayHandle );
        EVROverlayError (__stdcall *HideOverlay)( VROverlayHandle_t ulOverlayHandle );
        bool (__stdcall *IsOverlayVisible)( VROverlayHandle_t ulOverlayHandle );
        EVROverlayError (__stdcall *GetTransformForOverlayCoordinates)( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t *pmatTransform );
        bool (__stdcall *PollNextOverlayEvent)( VROverlayHandle_t ulOverlayHandle, VREvent_t *pEvent, uint32_t uncbVREvent );
        EVROverlayError (__stdcall *GetOverlayInputMethod)( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod );
        EVROverlayError (__stdcall *SetOverlayInputMethod)( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod );
        EVROverlayError (__stdcall *GetOverlayMouseScale)( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvecMouseScale );
        EVROverlayError (__stdcall *SetOverlayMouseScale)( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvecMouseScale );
        bool (__stdcall *ComputeOverlayIntersection)( VROverlayHandle_t ulOverlayHandle, const VROverlayIntersectionParams_t *pParams, VROverlayIntersectionResults_t *pResults );
        bool (__stdcall *IsHoverTargetOverlay)( VROverlayHandle_t ulOverlayHandle );
        vr::VROverlayHandle_t (__stdcall *GetGamepadFocusOverlay)();
        EVROverlayError (__stdcall *SetGamepadFocusOverlay)( VROverlayHandle_t ulNewFocusOverlay );
        EVROverlayError (__stdcall *SetOverlayNeighbor)( EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo );
        EVROverlayError (__stdcall *MoveGamepadFocusToNeighbor)( EOverlayDirection eDirection, VROverlayHandle_t ulFrom );
        EVROverlayError (__stdcall *SetOverlayDualAnalogTransform)( VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, const HmdVector2_t & vCenter, float fRadius );
        EVROverlayError (__stdcall *GetOverlayDualAnalogTransform)( VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t *pvCenter, float *pfRadius );
        EVROverlayError (__stdcall *SetOverlayTexture)( VROverlayHandle_t ulOverlayHandle, const Texture_t *pTexture );
        EVROverlayError (__stdcall *ClearOverlayTexture)( VROverlayHandle_t ulOverlayHandle );
        EVROverlayError (__stdcall *SetOverlayRaw)( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth );
        EVROverlayError (__stdcall *SetOverlayFromFile)( VROverlayHandle_t ulOverlayHandle, const char *pchFilePath );
        EVROverlayError (__stdcall *GetOverlayTexture)( VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, VRTextureBounds_t *pTextureBounds );
        EVROverlayError (__stdcall *ReleaseNativeOverlayHandle)( VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle );
        EVROverlayError (__stdcall *GetOverlayTextureSize)( VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight );
        EVROverlayError (__stdcall *CreateDashboardOverlay)( const char *pchOverlayKey, const char *pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t *pThumbnailHandle );
        bool (__stdcall *IsDashboardVisible)();
        bool (__stdcall *IsActiveDashboardOverlay)( VROverlayHandle_t ulOverlayHandle );
        EVROverlayError (__stdcall *SetDashboardOverlaySceneProcess)( VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId );
        EVROverlayError (__stdcall *GetDashboardOverlaySceneProcess)( VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId );
        void (__stdcall *ShowDashboard)( const char *pchOverlayToShow );
        vr::TrackedDeviceIndex_t (__stdcall *GetPrimaryDashboardDevice)();
        EVROverlayError (__stdcall *ShowKeyboard)( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue );
        EVROverlayError (__stdcall *ShowKeyboardForOverlay)( VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue );
        uint32_t (__stdcall *GetKeyboardText)(  char *pchText, uint32_t cchText );
        void (__stdcall *HideKeyboard)();
        void (__stdcall *SetKeyboardTransformAbsolute)( ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform );
        void (__stdcall *SetKeyboardPositionForOverlay)( VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect );
        EVROverlayError (__stdcall *SetOverlayIntersectionMask)( VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
        EVROverlayError (__stdcall *GetOverlayFlags)( VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags );
        VRMessageOverlayResponse (__stdcall *ShowMessageOverlay)( const char* pchText, const char* pchCaption, const char* pchButton0Text, const char* pchButton1Text, const char* pchButton2Text, const char* pchButton3Text);
        void (__stdcall *CloseMessageOverlay)();
    };
 
    class IVROverlay
    {
        VR_IVROverlay_FnTable _table;
    public:
 
        // ---------------------------------------------
        // Overlay management methods
        // ---------------------------------------------

        EVROverlayError FindOverlay( const char *pchOverlayKey, VROverlayHandle_t * pOverlayHandle ) { return _table.FindOverlay(pchOverlayKey, pOverlayHandle); }

        EVROverlayError CreateOverlay( const char *pchOverlayKey, const char *pchOverlayName, VROverlayHandle_t * pOverlayHandle ) { return _table.CreateOverlay(pchOverlayKey, pchOverlayName, pOverlayHandle); }

        EVROverlayError DestroyOverlay( VROverlayHandle_t ulOverlayHandle ) { return _table.DestroyOverlay(ulOverlayHandle); }

        EVROverlayError SetHighQualityOverlay( VROverlayHandle_t ulOverlayHandle ) { return _table.SetHighQualityOverlay(ulOverlayHandle); }

        vr::VROverlayHandle_t GetHighQualityOverlay() { return _table.GetHighQualityOverlay(); }

        uint32_t GetOverlayKey( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L ) { return _table.GetOverlayKey(ulOverlayHandle, pchValue, unBufferSize, pError); }

        uint32_t GetOverlayName( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L ) { return _table.GetOverlayName(ulOverlayHandle, pchValue, unBufferSize, pError); }

        EVROverlayError SetOverlayName( VROverlayHandle_t ulOverlayHandle, const char *pchName ) { return _table.SetOverlayName(ulOverlayHandle, pchName); }

        EVROverlayError GetOverlayImageData( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight ) { return _table.GetOverlayImageData(ulOverlayHandle, pvBuffer, unBufferSize, punWidth, punHeight); }

        const char *GetOverlayErrorNameFromEnum( EVROverlayError error ) { return _table.GetOverlayErrorNameFromEnum(error); }
 
        // ---------------------------------------------
        // Overlay rendering methods
        // ---------------------------------------------

        EVROverlayError SetOverlayRenderingPid( VROverlayHandle_t ulOverlayHandle, uint32_t unPID ) { return _table.SetOverlayRenderingPid(ulOverlayHandle, unPID); }

        uint32_t GetOverlayRenderingPid( VROverlayHandle_t ulOverlayHandle ) { return _table.GetOverlayRenderingPid(ulOverlayHandle); }

        EVROverlayError SetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled ) { return _table.SetOverlayFlag(ulOverlayHandle, eOverlayFlag, bEnabled); }

        EVROverlayError GetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled ) { return _table.GetOverlayFlag(ulOverlayHandle, eOverlayFlag, pbEnabled); }

        EVROverlayError SetOverlayColor( VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue ) { return _table.SetOverlayColor(ulOverlayHandle, fRed, fGreen, fBlue); }

        EVROverlayError GetOverlayColor( VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue ) { return _table.GetOverlayColor(ulOverlayHandle, pfRed, pfGreen, pfBlue); }

        EVROverlayError SetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float fAlpha ) { return _table.SetOverlayAlpha(ulOverlayHandle, fAlpha); }

        EVROverlayError GetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float *pfAlpha ) { return _table.GetOverlayAlpha(ulOverlayHandle, pfAlpha); }

        EVROverlayError SetOverlayTexelAspect( VROverlayHandle_t ulOverlayHandle, float fTexelAspect ) { return _table.SetOverlayTexelAspect(ulOverlayHandle, fTexelAspect); }

        EVROverlayError GetOverlayTexelAspect( VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect ) { return _table.GetOverlayTexelAspect(ulOverlayHandle, pfTexelAspect); }

        EVROverlayError SetOverlaySortOrder( VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder ) { return _table.SetOverlaySortOrder(ulOverlayHandle, unSortOrder); }

        EVROverlayError GetOverlaySortOrder( VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder ) { return _table.GetOverlaySortOrder(ulOverlayHandle, punSortOrder); }

        EVROverlayError SetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float fWidthInMeters ) { return _table.SetOverlayWidthInMeters(ulOverlayHandle, fWidthInMeters); }

        EVROverlayError GetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters ) { return _table.GetOverlayWidthInMeters(ulOverlayHandle, pfWidthInMeters); }

        EVROverlayError SetOverlayAutoCurveDistanceRangeInMeters( VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters ) { return _table.SetOverlayAutoCurveDistanceRangeInMeters(ulOverlayHandle, fMinDistanceInMeters, fMaxDistanceInMeters); }

        EVROverlayError GetOverlayAutoCurveDistanceRangeInMeters( VROverlayHandle_t ulOverlayHandle, float *pfMinDistanceInMeters, float *pfMaxDistanceInMeters ) { return _table.GetOverlayAutoCurveDistanceRangeInMeters(ulOverlayHandle, pfMinDistanceInMeters, pfMaxDistanceInMeters); }

        EVROverlayError SetOverlayTextureColorSpace( VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace ) { return _table.SetOverlayTextureColorSpace(ulOverlayHandle, eTextureColorSpace); }

        EVROverlayError GetOverlayTextureColorSpace( VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace ) { return _table.GetOverlayTextureColorSpace(ulOverlayHandle, peTextureColorSpace); }

        EVROverlayError SetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, const VRTextureBounds_t *pOverlayTextureBounds ) { return _table.SetOverlayTextureBounds(ulOverlayHandle, pOverlayTextureBounds); }

        EVROverlayError GetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t *pOverlayTextureBounds ) { return _table.GetOverlayTextureBounds(ulOverlayHandle, pOverlayTextureBounds); }

        uint32_t GetOverlayRenderModel( vr::VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, HmdColor_t *pColor, vr::EVROverlayError *pError ) { return _table.GetOverlayRenderModel(ulOverlayHandle, pchValue, unBufferSize, pColor, pError); }

        vr::EVROverlayError SetOverlayRenderModel( vr::VROverlayHandle_t ulOverlayHandle, const char *pchRenderModel, const HmdColor_t *pColor ) { return _table.SetOverlayRenderModel(ulOverlayHandle, pchRenderModel, pColor); }

        EVROverlayError GetOverlayTransformType( VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType ) { return _table.GetOverlayTransformType(ulOverlayHandle, peTransformType); }

        EVROverlayError SetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) { return _table.SetOverlayTransformAbsolute(ulOverlayHandle, eTrackingOrigin, pmatTrackingOriginToOverlayTransform); }

        EVROverlayError GetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) { return _table.GetOverlayTransformAbsolute(ulOverlayHandle, peTrackingOrigin, pmatTrackingOriginToOverlayTransform); }

        EVROverlayError SetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, const HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) { return _table.SetOverlayTransformTrackedDeviceRelative(ulOverlayHandle, unTrackedDevice, pmatTrackedDeviceToOverlayTransform); }

        EVROverlayError GetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) { return _table.GetOverlayTransformTrackedDeviceRelative(ulOverlayHandle, punTrackedDevice, pmatTrackedDeviceToOverlayTransform); }

        EVROverlayError SetOverlayTransformTrackedDeviceComponent( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char *pchComponentName ) { return _table.SetOverlayTransformTrackedDeviceComponent(ulOverlayHandle, unDeviceIndex, pchComponentName); }

        EVROverlayError GetOverlayTransformTrackedDeviceComponent( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, VR_OUT_STRING() char *pchComponentName, uint32_t unComponentNameSize ) { return _table.GetOverlayTransformTrackedDeviceComponent(ulOverlayHandle, punDeviceIndex, pchComponentName, unComponentNameSize); }

        vr::EVROverlayError GetOverlayTransformOverlayRelative( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, HmdMatrix34_t *pmatParentOverlayToOverlayTransform ) { return _table.GetOverlayTransformOverlayRelative(ulOverlayHandle, ulOverlayHandleParent, pmatParentOverlayToOverlayTransform); }
        
        vr::EVROverlayError SetOverlayTransformOverlayRelative( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, const HmdMatrix34_t *pmatParentOverlayToOverlayTransform ) { return _table.SetOverlayTransformOverlayRelative(ulOverlayHandle, ulOverlayHandleParent, pmatParentOverlayToOverlayTransform); }

        EVROverlayError ShowOverlay( VROverlayHandle_t ulOverlayHandle ) { return _table.ShowOverlay(ulOverlayHandle); }

        EVROverlayError HideOverlay( VROverlayHandle_t ulOverlayHandle ) { return _table.HideOverlay(ulOverlayHandle); }

        bool IsOverlayVisible( VROverlayHandle_t ulOverlayHandle ) { return _table.IsOverlayVisible(ulOverlayHandle); }

        EVROverlayError GetTransformForOverlayCoordinates( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t *pmatTransform ) { return _table.GetTransformForOverlayCoordinates(ulOverlayHandle, eTrackingOrigin, coordinatesInOverlay, pmatTransform); }
 
        // ---------------------------------------------
        // Overlay input methods
        // ---------------------------------------------

        bool PollNextOverlayEvent( VROverlayHandle_t ulOverlayHandle, VREvent_t *pEvent, uint32_t uncbVREvent ) { return _table.PollNextOverlayEvent(ulOverlayHandle, pEvent, uncbVREvent); }

        EVROverlayError GetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod ) { return _table.GetOverlayInputMethod(ulOverlayHandle, peInputMethod); }

        EVROverlayError SetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod ) { return _table.SetOverlayInputMethod(ulOverlayHandle, eInputMethod); }

        EVROverlayError GetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvecMouseScale ) { return _table.GetOverlayMouseScale(ulOverlayHandle, pvecMouseScale); }

        EVROverlayError SetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvecMouseScale ) { return _table.SetOverlayMouseScale(ulOverlayHandle, pvecMouseScale); }

        bool ComputeOverlayIntersection( VROverlayHandle_t ulOverlayHandle, const VROverlayIntersectionParams_t *pParams, VROverlayIntersectionResults_t *pResults ) { return _table.ComputeOverlayIntersection(ulOverlayHandle, pParams, pResults); }

        bool IsHoverTargetOverlay( VROverlayHandle_t ulOverlayHandle ) { return _table.IsHoverTargetOverlay(ulOverlayHandle); }

        vr::VROverlayHandle_t GetGamepadFocusOverlay() { return _table.GetGamepadFocusOverlay(); }

        EVROverlayError SetGamepadFocusOverlay( VROverlayHandle_t ulNewFocusOverlay ) { return _table.SetGamepadFocusOverlay(ulNewFocusOverlay); }

        EVROverlayError SetOverlayNeighbor( EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo ) { return _table.SetOverlayNeighbor(eDirection, ulFrom, ulTo); }

        EVROverlayError MoveGamepadFocusToNeighbor( EOverlayDirection eDirection, VROverlayHandle_t ulFrom ) { return _table.MoveGamepadFocusToNeighbor(eDirection, ulFrom); }

        EVROverlayError SetOverlayDualAnalogTransform( VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, const HmdVector2_t & vCenter, float fRadius ) { return _table.SetOverlayDualAnalogTransform(ulOverlay, eWhich, vCenter, fRadius); }

        EVROverlayError GetOverlayDualAnalogTransform( VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t *pvCenter, float *pfRadius ) { return _table.GetOverlayDualAnalogTransform(ulOverlay, eWhich, pvCenter, pfRadius); }
 
        // ---------------------------------------------
        // Overlay texture methods
        // ---------------------------------------------

        EVROverlayError SetOverlayTexture( VROverlayHandle_t ulOverlayHandle, const Texture_t *pTexture ) { return _table.SetOverlayTexture(ulOverlayHandle, pTexture); }

        EVROverlayError ClearOverlayTexture( VROverlayHandle_t ulOverlayHandle ) { return _table.ClearOverlayTexture(ulOverlayHandle); }

        EVROverlayError SetOverlayRaw( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth ) { return _table.SetOverlayRaw(ulOverlayHandle, pvBuffer, unWidth, unHeight, unDepth); }

        EVROverlayError SetOverlayFromFile( VROverlayHandle_t ulOverlayHandle, const char *pchFilePath ) { return _table.SetOverlayFromFile(ulOverlayHandle, pchFilePath); }

        EVROverlayError GetOverlayTexture( VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, VRTextureBounds_t *pTextureBounds ) { return _table.GetOverlayTexture(ulOverlayHandle, pNativeTextureHandle, pNativeTextureRef, pWidth, pHeight, pNativeFormat, pAPIType, pColorSpace, pTextureBounds); }

        EVROverlayError ReleaseNativeOverlayHandle( VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle ) { return _table.ReleaseNativeOverlayHandle(ulOverlayHandle, pNativeTextureHandle); }

        EVROverlayError GetOverlayTextureSize( VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight ) { return _table.GetOverlayTextureSize(ulOverlayHandle, pWidth, pHeight); }
 
        // ----------------------------------------------
        // Dashboard Overlay Methods
        // ----------------------------------------------

        EVROverlayError CreateDashboardOverlay( const char *pchOverlayKey, const char *pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t *pThumbnailHandle ) { return _table.CreateDashboardOverlay(pchOverlayKey, pchOverlayFriendlyName, pMainHandle, pThumbnailHandle); }

        bool IsDashboardVisible() { return _table.IsDashboardVisible(); }

        bool IsActiveDashboardOverlay( VROverlayHandle_t ulOverlayHandle ) { return _table.IsActiveDashboardOverlay(ulOverlayHandle); }

        EVROverlayError SetDashboardOverlaySceneProcess( VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId ) { return _table.SetDashboardOverlaySceneProcess(ulOverlayHandle, unProcessId); }

        EVROverlayError GetDashboardOverlaySceneProcess( VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId ) { return _table.GetDashboardOverlaySceneProcess(ulOverlayHandle, punProcessId); }

        void ShowDashboard( const char *pchOverlayToShow ) { _table.ShowDashboard(pchOverlayToShow); }

        vr::TrackedDeviceIndex_t GetPrimaryDashboardDevice() { return _table.GetPrimaryDashboardDevice(); }
 
        // ---------------------------------------------
        // Keyboard methods
        // ---------------------------------------------
        
        EVROverlayError ShowKeyboard( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue ) { return _table.ShowKeyboard(eInputMode, eLineInputMode, pchDescription, unCharMax, pchExistingText, bUseMinimalMode, uUserValue); }
 
        EVROverlayError ShowKeyboardForOverlay( VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue ) { return _table.ShowKeyboardForOverlay(ulOverlayHandle, eInputMode, eLineInputMode, pchDescription, unCharMax, pchExistingText, bUseMinimalMode, uUserValue); }

        uint32_t GetKeyboardText( VR_OUT_STRING() char *pchText, uint32_t cchText ) { return _table.GetKeyboardText(pchText, cchText); }

        void HideKeyboard() { _table.HideKeyboard(); }

        void SetKeyboardTransformAbsolute( ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform ) { _table.SetKeyboardTransformAbsolute(eTrackingOrigin, pmatTrackingOriginToKeyboardTransform); }

        void SetKeyboardPositionForOverlay( VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect ) { _table.SetKeyboardPositionForOverlay(ulOverlayHandle, avoidRect); }
 
        // ---------------------------------------------
        // Overlay input methods
        // ---------------------------------------------

        EVROverlayError SetOverlayIntersectionMask( VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize = sizeof( VROverlayIntersectionMaskPrimitive_t ) ) { return _table.SetOverlayIntersectionMask(ulOverlayHandle, pMaskPrimitives, unNumMaskPrimitives, unPrimitiveSize); }
 
        EVROverlayError GetOverlayFlags( VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags ) { return _table.GetOverlayFlags(ulOverlayHandle, pFlags); }
 
        // ---------------------------------------------
        // Message box methods
        // ---------------------------------------------

        VRMessageOverlayResponse ShowMessageOverlay( const char* pchText, const char* pchCaption, const char* pchButton0Text, const char* pchButton1Text = nullptr, const char* pchButton2Text = nullptr, const char* pchButton3Text = nullptr ) { return _table.ShowMessageOverlay(pchText, pchCaption, pchButton0Text, pchButton1Text, pchButton2Text, pchButton3Text); }

        void CloseMessageOverlay() { _table.CloseMessageOverlay(); }
    };
 
    static const char * const IVROverlay_Version = "FnTable:IVROverlay_018";
 
} // namespace vr
 
// ivrrendermodels.h
namespace vr
{
 
static const char * const k_pch_Controller_Component_GDC2015 = "gdc2015";   // Canonical coordinate system of the gdc 2015 wired controller, provided for backwards compatibility
static const char * const k_pch_Controller_Component_Base = "base";         // For controllers with an unambiguous 'base'.
static const char * const k_pch_Controller_Component_Tip = "tip";           // For controllers with an unambiguous 'tip' (used for 'laser-pointing')
static const char * const k_pch_Controller_Component_HandGrip = "handgrip"; // Neutral, ambidextrous hand-pose when holding controller. On plane between neutrally posed index finger and thumb
static const char * const k_pch_Controller_Component_Status = "status";     // 1:1 aspect ratio status area, with canonical [0,1] uv mapping
 
#pragma pack( push, 8 )

enum EVRRenderModelError
{
    VRRenderModelError_None = 0,
    VRRenderModelError_Loading = 100,
    VRRenderModelError_NotSupported = 200,
    VRRenderModelError_InvalidArg = 300,
    VRRenderModelError_InvalidModel = 301,
    VRRenderModelError_NoShapes = 302,
    VRRenderModelError_MultipleShapes = 303,
    VRRenderModelError_TooManyVertices = 304,
    VRRenderModelError_MultipleTextures = 305,
    VRRenderModelError_BufferTooSmall = 306,
    VRRenderModelError_NotEnoughNormals = 307,
    VRRenderModelError_NotEnoughTexCoords = 308,
 
    VRRenderModelError_InvalidTexture = 400,
};
 
typedef uint32_t VRComponentProperties;
 
enum EVRComponentProperty
{
    VRComponentProperty_IsStatic = (1 << 0),
    VRComponentProperty_IsVisible = (1 << 1),
    VRComponentProperty_IsTouched = (1 << 2),
    VRComponentProperty_IsPressed = (1 << 3),
    VRComponentProperty_IsScrolled = (1 << 4),
};

struct RenderModel_ComponentState_t
{
    HmdMatrix34_t mTrackingToComponentRenderModel;  // Transform required when drawing the component render model
    HmdMatrix34_t mTrackingToComponentLocal;        // Transform available for attaching to a local component coordinate system (-Z out from surface )
    VRComponentProperties uProperties;
};

struct RenderModel_Vertex_t
{
    HmdVector3_t vPosition;     // position in meters in device space
    HmdVector3_t vNormal;
    float rfTextureCoord[2];
};

#if defined(__linux__) || defined(__APPLE__) 
// This structure was originally defined mis-packed on Linux, preserved for 
// compatibility. 
#pragma pack( push, 4 )
#endif
 
struct RenderModel_TextureMap_t
{
    uint16_t unWidth, unHeight; // width and height of the texture map in pixels
    const uint8_t *rubTextureMapData;   // Map texture data. All textures are RGBA with 8 bits per channel per pixel. Data size is width * height * 4ub
};
#if defined(__linux__) || defined(__APPLE__) 
#pragma pack( pop )
#endif

 
typedef int32_t TextureID_t;
 
const TextureID_t INVALID_TEXTURE_ID = -1;
 
#if defined(__linux__) || defined(__APPLE__) 
// This structure was originally defined mis-packed on Linux, preserved for 
// compatibility. 
#pragma pack( push, 4 )
#endif
 
struct RenderModel_t
{
    const RenderModel_Vertex_t *rVertexData;    // Vertex data for the mesh
    uint32_t unVertexCount;                     // Number of vertices in the vertex data
    const uint16_t *rIndexData;                 // Indices into the vertex data for each triangle
    uint32_t unTriangleCount;                   // Number of triangles in the mesh. Index count is 3 * TriangleCount
    TextureID_t diffuseTextureId;               // Session unique texture identifier. Rendermodels which share the same texture will have the same id. <0 == texture not present
};
#if defined(__linux__) || defined(__APPLE__) 
#pragma pack( pop )
#endif
 
 
struct RenderModel_ControllerMode_State_t
{
    bool bScrollWheelVisible; // is this controller currently set to be in a scroll wheel mode
};
 
#pragma pack( pop )
 
struct VR_IVRRenderModels_FnTable
{
    EVRRenderModelError (__stdcall *LoadRenderModel_Async)( const char *pchRenderModelName, RenderModel_t **ppRenderModel );
    void (__stdcall *FreeRenderModel)( RenderModel_t *pRenderModel );
    EVRRenderModelError (__stdcall *LoadTexture_Async)( TextureID_t textureId, RenderModel_TextureMap_t **ppTexture );
    void (__stdcall *FreeTexture)( RenderModel_TextureMap_t *pTexture );
    EVRRenderModelError (__stdcall *LoadTextureD3D11_Async)( TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D );
    EVRRenderModelError (__stdcall *LoadIntoTextureD3D11_Async)( TextureID_t textureId, void *pDstTexture );
    void (__stdcall *FreeTextureD3D11)( void *pD3D11Texture2D );
    uint32_t (__stdcall *GetRenderModelName)( uint32_t unRenderModelIndex,  char *pchRenderModelName, uint32_t unRenderModelNameLen );
    uint32_t (__stdcall *GetRenderModelCount)();
    uint32_t (__stdcall *GetComponentCount)( const char *pchRenderModelName );
    uint32_t (__stdcall *GetComponentName)( const char *pchRenderModelName, uint32_t unComponentIndex,  char *pchComponentName, uint32_t unComponentNameLen );
    uint64_t (__stdcall *GetComponentButtonMask)( const char *pchRenderModelName, const char *pchComponentName );
    uint32_t (__stdcall *GetComponentRenderModelName)( const char *pchRenderModelName, const char *pchComponentName,  char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen );
    bool (__stdcall *GetComponentState)( const char *pchRenderModelName, const char *pchComponentName, const vr::VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState );
    bool (__stdcall *RenderModelHasComponent)( const char *pchRenderModelName, const char *pchComponentName );
    uint32_t (__stdcall *GetRenderModelThumbnailURL)( const char *pchRenderModelName,  char *pchThumbnailURL, uint32_t unThumbnailURLLen, vr::EVRRenderModelError *peError );
    uint32_t (__stdcall *GetRenderModelOriginalPath)( const char *pchRenderModelName,  char *pchOriginalPath, uint32_t unOriginalPathLen, vr::EVRRenderModelError *peError );
    const char *(__stdcall *GetRenderModelErrorNameFromEnum)( vr::EVRRenderModelError error );
};
 
class IVRRenderModels
{
    VR_IVRRenderModels_FnTable _table;
public:

    EVRRenderModelError LoadRenderModel_Async( const char *pchRenderModelName, RenderModel_t **ppRenderModel ) { return _table.LoadRenderModel_Async(pchRenderModelName, ppRenderModel); }

    void FreeRenderModel( RenderModel_t *pRenderModel ) { _table.FreeRenderModel(pRenderModel); }

    EVRRenderModelError LoadTexture_Async( TextureID_t textureId, RenderModel_TextureMap_t **ppTexture ) { return _table.LoadTexture_Async(textureId, ppTexture); }

    void FreeTexture( RenderModel_TextureMap_t *pTexture ) { _table.FreeTexture(pTexture); }

    EVRRenderModelError LoadTextureD3D11_Async( TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D ) { return _table.LoadTextureD3D11_Async(textureId, pD3D11Device, ppD3D11Texture2D); }

    EVRRenderModelError LoadIntoTextureD3D11_Async( TextureID_t textureId, void *pDstTexture ) { return _table.LoadIntoTextureD3D11_Async(textureId, pDstTexture); }

    void FreeTextureD3D11( void *pD3D11Texture2D ) { _table.FreeTextureD3D11(pD3D11Texture2D); }

    uint32_t GetRenderModelName( uint32_t unRenderModelIndex, VR_OUT_STRING() char *pchRenderModelName, uint32_t unRenderModelNameLen ) { return _table.GetRenderModelName(unRenderModelIndex, pchRenderModelName, unRenderModelNameLen); }

    uint32_t GetRenderModelCount() { return _table.GetRenderModelCount(); }
 

    uint32_t GetComponentCount( const char *pchRenderModelName ) { return _table.GetComponentCount(pchRenderModelName); }

    uint32_t GetComponentName( const char *pchRenderModelName, uint32_t unComponentIndex, VR_OUT_STRING( ) char *pchComponentName, uint32_t unComponentNameLen ) { return _table.GetComponentName(pchRenderModelName, unComponentIndex, pchComponentName, unComponentNameLen); }

    uint64_t GetComponentButtonMask( const char *pchRenderModelName, const char *pchComponentName ) { return _table.GetComponentButtonMask(pchRenderModelName, pchComponentName); }

    uint32_t GetComponentRenderModelName( const char *pchRenderModelName, const char *pchComponentName, VR_OUT_STRING( ) char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen ) { return _table.GetComponentRenderModelName(pchRenderModelName, pchComponentName, pchComponentRenderModelName, unComponentRenderModelNameLen); }

    bool GetComponentState( const char *pchRenderModelName, const char *pchComponentName, const vr::VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState ) { return _table.GetComponentState(pchRenderModelName, pchComponentName, pControllerState, pState, pComponentState); }

    bool RenderModelHasComponent( const char *pchRenderModelName, const char *pchComponentName ) { return _table.RenderModelHasComponent(pchRenderModelName, pchComponentName); }

    uint32_t GetRenderModelThumbnailURL( const char *pchRenderModelName, VR_OUT_STRING() char *pchThumbnailURL, uint32_t unThumbnailURLLen, vr::EVRRenderModelError *peError ) { return _table.GetRenderModelThumbnailURL(pchRenderModelName, pchThumbnailURL, unThumbnailURLLen, peError); }

    uint32_t GetRenderModelOriginalPath( const char *pchRenderModelName, VR_OUT_STRING() char *pchOriginalPath, uint32_t unOriginalPathLen, vr::EVRRenderModelError *peError ) { return _table.GetRenderModelOriginalPath(pchRenderModelName, pchOriginalPath, unOriginalPathLen, peError); }

    const char *GetRenderModelErrorNameFromEnum( vr::EVRRenderModelError error ) { return _table.GetRenderModelErrorNameFromEnum(error); }
};
 
static const char * const IVRRenderModels_Version = "FnTable:IVRRenderModels_005";
 
}
 
 
// ivrextendeddisplay.h
namespace vr
{

    struct VR_IVRExtendedDisplay_FnTable
    {
        void (__stdcall *GetWindowBounds)( int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight );
        void (__stdcall *GetEyeOutputViewport)( EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight );
        void (__stdcall *GetDXGIOutputInfo)( int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex );
    };
 
    class IVRExtendedDisplay
    {
        VR_IVRExtendedDisplay_FnTable _table;
    public:

        void GetWindowBounds( int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) { _table.GetWindowBounds(pnX, pnY, pnWidth, pnHeight); }

        void GetEyeOutputViewport( EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) { _table.GetEyeOutputViewport(eEye, pnX, pnY, pnWidth, pnHeight); }

        void GetDXGIOutputInfo( int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex ) { _table.GetDXGIOutputInfo(pnAdapterIndex, pnAdapterOutputIndex); }
 
    };
 
    static const char * const IVRExtendedDisplay_Version = "FnTable:IVRExtendedDisplay_001";
 
}
 
 
// ivrtrackedcamera.h
namespace vr
{
 
struct VR_IVRTrackedCamera_FnTable
{
    const char *(__stdcall *GetCameraErrorNameFromEnum)( vr::EVRTrackedCameraError eCameraError );
    vr::EVRTrackedCameraError (__stdcall *HasCamera)( vr::TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera );
    vr::EVRTrackedCameraError (__stdcall *GetCameraFrameSize)( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize );
    vr::EVRTrackedCameraError (__stdcall *GetCameraIntrinsics)( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::HmdVector2_t *pFocalLength, vr::HmdVector2_t *pCenter );
    vr::EVRTrackedCameraError (__stdcall *GetCameraProjection)( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection );
    vr::EVRTrackedCameraError (__stdcall *AcquireVideoStreamingService)( vr::TrackedDeviceIndex_t nDeviceIndex, vr::TrackedCameraHandle_t *pHandle );
    vr::EVRTrackedCameraError (__stdcall *ReleaseVideoStreamingService)( vr::TrackedCameraHandle_t hTrackedCamera );
    vr::EVRTrackedCameraError (__stdcall *GetVideoStreamFrameBuffer)( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize );
    vr::EVRTrackedCameraError (__stdcall *GetVideoStreamTextureSize)( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight );
    vr::EVRTrackedCameraError (__stdcall *GetVideoStreamTextureD3D11)( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize );
    vr::EVRTrackedCameraError (__stdcall *GetVideoStreamTextureGL)( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, vr::glUInt_t *pglTextureId, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize );
    vr::EVRTrackedCameraError (__stdcall *ReleaseVideoStreamTextureGL)( vr::TrackedCameraHandle_t hTrackedCamera, vr::glUInt_t glTextureId );
};
 
class IVRTrackedCamera
{
    VR_IVRTrackedCamera_FnTable _table;
public:
    const char *GetCameraErrorNameFromEnum( vr::EVRTrackedCameraError eCameraError ) { return _table.GetCameraErrorNameFromEnum(eCameraError); }

    vr::EVRTrackedCameraError HasCamera( vr::TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera ) { return _table.HasCamera(nDeviceIndex, pHasCamera); }

    vr::EVRTrackedCameraError GetCameraFrameSize( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize ) { return _table.GetCameraFrameSize(nDeviceIndex, eFrameType, pnWidth, pnHeight, pnFrameBufferSize); }
 
    vr::EVRTrackedCameraError GetCameraIntrinsics( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::HmdVector2_t *pFocalLength, vr::HmdVector2_t *pCenter ) { return _table.GetCameraIntrinsics(nDeviceIndex, eFrameType, pFocalLength, pCenter); }
 
    vr::EVRTrackedCameraError GetCameraProjection( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection ) { return _table.GetCameraProjection(nDeviceIndex, eFrameType, flZNear, flZFar, pProjection); }

    vr::EVRTrackedCameraError AcquireVideoStreamingService( vr::TrackedDeviceIndex_t nDeviceIndex, vr::TrackedCameraHandle_t *pHandle ) { return _table.AcquireVideoStreamingService(nDeviceIndex, pHandle); }
    vr::EVRTrackedCameraError ReleaseVideoStreamingService( vr::TrackedCameraHandle_t hTrackedCamera ) { return _table.ReleaseVideoStreamingService(hTrackedCamera); }

    vr::EVRTrackedCameraError GetVideoStreamFrameBuffer( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) { return _table.GetVideoStreamFrameBuffer(hTrackedCamera, eFrameType, pFrameBuffer, nFrameBufferSize, pFrameHeader, nFrameHeaderSize); }

    vr::EVRTrackedCameraError GetVideoStreamTextureSize( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight ) { return _table.GetVideoStreamTextureSize(nDeviceIndex, eFrameType, pTextureBounds, pnWidth, pnHeight); }

    vr::EVRTrackedCameraError GetVideoStreamTextureD3D11( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) { return _table.GetVideoStreamTextureD3D11(hTrackedCamera, eFrameType, pD3D11DeviceOrResource, ppD3D11ShaderResourceView, pFrameHeader, nFrameHeaderSize); }

    vr::EVRTrackedCameraError GetVideoStreamTextureGL( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, vr::glUInt_t *pglTextureId, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) { return _table.GetVideoStreamTextureGL(hTrackedCamera, eFrameType, pglTextureId, pFrameHeader, nFrameHeaderSize); }
    vr::EVRTrackedCameraError ReleaseVideoStreamTextureGL( vr::TrackedCameraHandle_t hTrackedCamera, vr::glUInt_t glTextureId ) { return _table.ReleaseVideoStreamTextureGL(hTrackedCamera, glTextureId); }
};
 
static const char * const IVRTrackedCamera_Version = "FnTable:IVRTrackedCamera_003";
 
} // namespace vr
 
 
// ivrscreenshots.h
namespace vr
{

enum EVRScreenshotError
{
    VRScreenshotError_None                          = 0,
    VRScreenshotError_RequestFailed                 = 1,
    VRScreenshotError_IncompatibleVersion           = 100,
    VRScreenshotError_NotFound                      = 101,
    VRScreenshotError_BufferTooSmall                = 102,
    VRScreenshotError_ScreenshotAlreadyInProgress   = 108,
};

struct VR_IVRScreenshots_FnTable
{
    vr::EVRScreenshotError (__stdcall *RequestScreenshot)( vr::ScreenshotHandle_t *pOutScreenshotHandle, vr::EVRScreenshotType type, const char *pchPreviewFilename, const char *pchVRFilename );
    vr::EVRScreenshotError (__stdcall *HookScreenshot)(  const vr::EVRScreenshotType *pSupportedTypes, int numTypes );
    vr::EVRScreenshotType (__stdcall *GetScreenshotPropertyType)( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotError *pError );
    uint32_t (__stdcall *GetScreenshotPropertyFilename)( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotPropertyFilenames filenameType,  char *pchFilename, uint32_t cchFilename, vr::EVRScreenshotError *pError );
    vr::EVRScreenshotError (__stdcall *UpdateScreenshotProgress)( vr::ScreenshotHandle_t screenshotHandle, float flProgress );
    vr::EVRScreenshotError (__stdcall *TakeStereoScreenshot)( vr::ScreenshotHandle_t *pOutScreenshotHandle, const char *pchPreviewFilename, const char *pchVRFilename );
    vr::EVRScreenshotError (__stdcall *SubmitScreenshot)( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotType type, const char *pchSourcePreviewFilename, const char *pchSourceVRFilename );
};
 
class IVRScreenshots
{
    VR_IVRScreenshots_FnTable _table;
public:
    vr::EVRScreenshotError RequestScreenshot( vr::ScreenshotHandle_t *pOutScreenshotHandle, vr::EVRScreenshotType type, const char *pchPreviewFilename, const char *pchVRFilename ) { return _table.RequestScreenshot(pOutScreenshotHandle, type, pchPreviewFilename, pchVRFilename); }

    vr::EVRScreenshotError HookScreenshot( VR_ARRAY_COUNT( numTypes ) const vr::EVRScreenshotType *pSupportedTypes, int numTypes ) { return _table.HookScreenshot(pSupportedTypes, numTypes); }

    vr::EVRScreenshotType GetScreenshotPropertyType( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotError *pError ) { return _table.GetScreenshotPropertyType(screenshotHandle, pError); }

    uint32_t GetScreenshotPropertyFilename( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotPropertyFilenames filenameType, VR_OUT_STRING() char *pchFilename, uint32_t cchFilename, vr::EVRScreenshotError *pError ) { return _table.GetScreenshotPropertyFilename(screenshotHandle, filenameType, pchFilename, cchFilename, pError); }

    vr::EVRScreenshotError UpdateScreenshotProgress( vr::ScreenshotHandle_t screenshotHandle, float flProgress ) { return _table.UpdateScreenshotProgress(screenshotHandle, flProgress); }

    vr::EVRScreenshotError TakeStereoScreenshot( vr::ScreenshotHandle_t *pOutScreenshotHandle, const char *pchPreviewFilename, const char *pchVRFilename ) { return _table.TakeStereoScreenshot(pOutScreenshotHandle, pchPreviewFilename, pchVRFilename); }

    vr::EVRScreenshotError SubmitScreenshot( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotType type, const char *pchSourcePreviewFilename, const char *pchSourceVRFilename ) { return _table.SubmitScreenshot(screenshotHandle, type, pchSourcePreviewFilename, pchSourceVRFilename); }
};
 
static const char * const IVRScreenshots_Version = "FnTable:IVRScreenshots_001";
 
} // namespace vr
 
 
 
// ivrresources.h
namespace vr
{
 
struct VR_IVRResources_FnTable
{
    uint32_t (__stdcall *LoadSharedResource)( const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen );
    uint32_t (__stdcall *GetResourceFullPath)( const char *pchResourceName, const char *pchResourceTypeDirectory,  char *pchPathBuffer, uint32_t unBufferLen );
};
 
class IVRResources
{
    VR_IVRResources_FnTable _table;
public:
 
    // ------------------------------------
    // Shared Resource Methods
    // ------------------------------------

    uint32_t LoadSharedResource( const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen ) { return _table.LoadSharedResource(pchResourceName, pchBuffer, unBufferLen); }

    uint32_t GetResourceFullPath( const char *pchResourceName, const char *pchResourceTypeDirectory, VR_OUT_STRING() char *pchPathBuffer, uint32_t unBufferLen ) { return _table.GetResourceFullPath(pchResourceName, pchResourceTypeDirectory, pchPathBuffer, unBufferLen); }
};
 
static const char * const IVRResources_Version = "FnTable:IVRResources_001";
 
 
}
// ivrdrivermanager.h
namespace vr
{
 
struct VR_IVRDriverManager_FnTable
{
    uint32_t (__stdcall *GetDriverName)( vr::DriverId_t nDriver,  char *pchValue, uint32_t unBufferSize );
};
 
class IVRDriverManager
{
    VR_IVRDriverManager_FnTable _table;
public:
    virtual uint32_t GetDriverCount() const = 0;

    uint32_t GetDriverName( vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) { return _table.GetDriverName(nDriver, pchValue, unBufferSize); }
};
 
static const char * const IVRDriverManager_Version = "FnTable:IVRDriverManager_001";
 
} // namespace vr
 
 
// End
 
#endif // _OPENVR_API
 
 
namespace vr
{
    inline IVRSystem *VR_Init( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo = nullptr );

    inline void VR_Shutdown();

    VR_INTERFACE bool VR_CALLTYPE VR_IsHmdPresent();

    VR_INTERFACE bool VR_CALLTYPE VR_IsRuntimeInstalled();

    VR_INTERFACE const char *VR_CALLTYPE VR_RuntimePath();

    VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsSymbol( EVRInitError error );

    VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsEnglishDescription( EVRInitError error );

    VR_INTERFACE void *VR_CALLTYPE VR_GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError );

    VR_INTERFACE bool VR_CALLTYPE VR_IsInterfaceVersionValid( const char *pchInterfaceVersion );

    VR_INTERFACE uint32_t VR_CALLTYPE VR_GetInitToken();
 
    // These typedefs allow old enum names from SDK 0.9.11 to be used in applications.
    // They will go away in the future.
    typedef EVRInitError HmdError;
    typedef EVREye Hmd_Eye;
    typedef EColorSpace ColorSpace;
    typedef ETrackingResult HmdTrackingResult;
    typedef ETrackedDeviceClass TrackedDeviceClass;
    typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
    typedef ETrackedDeviceProperty TrackedDeviceProperty;
    typedef ETrackedPropertyError TrackedPropertyError;
    typedef EVRSubmitFlags VRSubmitFlags_t;
    typedef EVRState VRState_t;
    typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
    typedef EVROverlayError VROverlayError;
    typedef EVRFirmwareError VRFirmwareError;
    typedef EVRCompositorError VRCompositorError;
    typedef EVRScreenshotError VRScreenshotsError;
 
    inline uint32_t &VRToken()
    {
        static uint32_t token;
        return token;
    }
 
    class COpenVRContext
    {
    public:
        COpenVRContext() { Clear(); }
        void Clear();
 
        inline void CheckClear()
        {
            if ( VRToken() != VR_GetInitToken() )
            {
                Clear();
                VRToken() = VR_GetInitToken();
            }
        }
 
        IVRSystem *VRSystem()
        {
            CheckClear();
            if ( m_pVRSystem == nullptr )
            {
                EVRInitError eError;
                m_pVRSystem = ( IVRSystem * )VR_GetGenericInterface( IVRSystem_Version, &eError );
            }
            return m_pVRSystem;
        }
        IVRChaperone *VRChaperone()
        {
            CheckClear();
            if ( m_pVRChaperone == nullptr )
            {
                EVRInitError eError;
                m_pVRChaperone = ( IVRChaperone * )VR_GetGenericInterface( IVRChaperone_Version, &eError );
            }
            return m_pVRChaperone;
        }
 
        IVRChaperoneSetup *VRChaperoneSetup()
        {
            CheckClear();
            if ( m_pVRChaperoneSetup == nullptr )
            {
                EVRInitError eError;
                m_pVRChaperoneSetup = ( IVRChaperoneSetup * )VR_GetGenericInterface( IVRChaperoneSetup_Version, &eError );
            }
            return m_pVRChaperoneSetup;
        }
 
        IVRCompositor *VRCompositor()
        {
            CheckClear();
            if ( m_pVRCompositor == nullptr )
            {
                EVRInitError eError;
                m_pVRCompositor = ( IVRCompositor * )VR_GetGenericInterface( IVRCompositor_Version, &eError );
            }
            return m_pVRCompositor;
        }
 
        IVROverlay *VROverlay()
        {
            CheckClear();
            if ( m_pVROverlay == nullptr )
            {
                EVRInitError eError;
                m_pVROverlay = ( IVROverlay * )VR_GetGenericInterface( IVROverlay_Version, &eError );
            }
            return m_pVROverlay;
        }
 
        IVRResources *VRResources()
        {
            CheckClear();
            if ( m_pVRResources == nullptr )
            {
                EVRInitError eError;
                m_pVRResources = (IVRResources *)VR_GetGenericInterface( IVRResources_Version, &eError );
            }
            return m_pVRResources;
        }
 
        IVRScreenshots *VRScreenshots()
        {
            CheckClear();
            if ( m_pVRScreenshots == nullptr )
            {
                EVRInitError eError;
                m_pVRScreenshots = ( IVRScreenshots * )VR_GetGenericInterface( IVRScreenshots_Version, &eError );
            }
            return m_pVRScreenshots;
        }
 
        IVRRenderModels *VRRenderModels()
        {
            CheckClear();
            if ( m_pVRRenderModels == nullptr )
            {
                EVRInitError eError;
                m_pVRRenderModels = ( IVRRenderModels * )VR_GetGenericInterface( IVRRenderModels_Version, &eError );
            }
            return m_pVRRenderModels;
        }
 
        IVRExtendedDisplay *VRExtendedDisplay()
        {
            CheckClear();
            if ( m_pVRExtendedDisplay == nullptr )
            {
                EVRInitError eError;
                m_pVRExtendedDisplay = ( IVRExtendedDisplay * )VR_GetGenericInterface( IVRExtendedDisplay_Version, &eError );
            }
            return m_pVRExtendedDisplay;
        }
 
        IVRSettings *VRSettings()
        {
            CheckClear();
            if ( m_pVRSettings == nullptr )
            {
                EVRInitError eError;
                m_pVRSettings = ( IVRSettings * )VR_GetGenericInterface( IVRSettings_Version, &eError );
            }
            return m_pVRSettings;
        }
 
        IVRApplications *VRApplications()
        {
            CheckClear();
            if ( m_pVRApplications == nullptr )
            {
                EVRInitError eError;
                m_pVRApplications = ( IVRApplications * )VR_GetGenericInterface( IVRApplications_Version, &eError );
            }
            return m_pVRApplications;
        }
 
        IVRTrackedCamera *VRTrackedCamera()
        {
            CheckClear();
            if ( m_pVRTrackedCamera == nullptr )
            {
                EVRInitError eError;
                m_pVRTrackedCamera = ( IVRTrackedCamera * )VR_GetGenericInterface( IVRTrackedCamera_Version, &eError );
            }
            return m_pVRTrackedCamera;
        }
 
        IVRDriverManager *VRDriverManager()
        {
            CheckClear();
            if ( !m_pVRDriverManager )
            {
                EVRInitError eError;
                m_pVRDriverManager = ( IVRDriverManager * )VR_GetGenericInterface( IVRDriverManager_Version, &eError );
            }
            return m_pVRDriverManager;
        }
 
    private:
        IVRSystem           *m_pVRSystem;
        IVRChaperone        *m_pVRChaperone;
        IVRChaperoneSetup   *m_pVRChaperoneSetup;
        IVRCompositor       *m_pVRCompositor;
        IVROverlay          *m_pVROverlay;
        IVRResources        *m_pVRResources;
        IVRRenderModels     *m_pVRRenderModels;
        IVRExtendedDisplay  *m_pVRExtendedDisplay;
        IVRSettings         *m_pVRSettings;
        IVRApplications     *m_pVRApplications;
        IVRTrackedCamera    *m_pVRTrackedCamera;
        IVRScreenshots      *m_pVRScreenshots;
        IVRDriverManager    *m_pVRDriverManager;
    };
 
    inline COpenVRContext &OpenVRInternal_ModuleContext()
    {
        static void *ctx[ sizeof( COpenVRContext ) / sizeof( void * ) ];
        return *( COpenVRContext * )ctx; // bypass zero-init constructor
    }
 
    inline IVRSystem *VR_CALLTYPE VRSystem() { return OpenVRInternal_ModuleContext().VRSystem(); }
    inline IVRChaperone *VR_CALLTYPE VRChaperone() { return OpenVRInternal_ModuleContext().VRChaperone(); }
    inline IVRChaperoneSetup *VR_CALLTYPE VRChaperoneSetup() { return OpenVRInternal_ModuleContext().VRChaperoneSetup(); }
    inline IVRCompositor *VR_CALLTYPE VRCompositor() { return OpenVRInternal_ModuleContext().VRCompositor(); }
    inline IVROverlay *VR_CALLTYPE VROverlay() { return OpenVRInternal_ModuleContext().VROverlay(); }
    inline IVRScreenshots *VR_CALLTYPE VRScreenshots() { return OpenVRInternal_ModuleContext().VRScreenshots(); }
    inline IVRRenderModels *VR_CALLTYPE VRRenderModels() { return OpenVRInternal_ModuleContext().VRRenderModels(); }
    inline IVRApplications *VR_CALLTYPE VRApplications() { return OpenVRInternal_ModuleContext().VRApplications(); }
    inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleContext().VRSettings(); }
    inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleContext().VRResources(); }
    inline IVRExtendedDisplay *VR_CALLTYPE VRExtendedDisplay() { return OpenVRInternal_ModuleContext().VRExtendedDisplay(); }
    inline IVRTrackedCamera *VR_CALLTYPE VRTrackedCamera() { return OpenVRInternal_ModuleContext().VRTrackedCamera(); }
    inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleContext().VRDriverManager(); }
 
    inline void COpenVRContext::Clear()
    {
        m_pVRSystem = nullptr;
        m_pVRChaperone = nullptr;
        m_pVRChaperoneSetup = nullptr;
        m_pVRCompositor = nullptr;
        m_pVROverlay = nullptr;
        m_pVRRenderModels = nullptr;
        m_pVRExtendedDisplay = nullptr;
        m_pVRSettings = nullptr;
        m_pVRApplications = nullptr;
        m_pVRTrackedCamera = nullptr;
        m_pVRResources = nullptr;
        m_pVRScreenshots = nullptr;
        m_pVRDriverManager = nullptr;
    }
    
    VR_INTERFACE uint32_t VR_CALLTYPE VR_InitInternal2( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo );
    VR_INTERFACE void VR_CALLTYPE VR_ShutdownInternal();

    inline IVRSystem *VR_Init( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo )
    {
        IVRSystem *pVRSystem = nullptr;
 
        EVRInitError eError;
        VRToken() = VR_InitInternal2( &eError, eApplicationType, pStartupInfo );
        COpenVRContext &ctx = OpenVRInternal_ModuleContext();
        ctx.Clear();
 
        if ( eError == VRInitError_None )
        {
            if ( VR_IsInterfaceVersionValid( IVRSystem_Version ) )
            {
                pVRSystem = VRSystem();
            }
            else
            {
                VR_ShutdownInternal();
                eError = VRInitError_Init_InterfaceNotFound;
            }
        }
 
        if ( peError )
            *peError = eError;
        return pVRSystem;
    }

    inline void VR_Shutdown()
    {
        VR_ShutdownInternal();
    }
}