SteamFrame/OpenVR-AdvancedSettings-frame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update OpenVR to 1.6.10

Browse Source
This commit is contained in:
Vasily
2019-08-10 09:12:32 +02:00
committed by username223
parent c9c19c61b5
commit 03564f0802
17 changed files with 1302 additions and 187 deletions
Download Patch File Download Diff File Expand all files Collapse all files
third-party/openvr/headers/openvr_driver.h
Vendored
+154 -8
View File
@@ -15,8 +15,8 @@
namespace vr
{
static const uint32_t k_nSteamVRVersionMajor = 1;
static const uint32_t k_nSteamVRVersionMinor = 4;
static const uint32_t k_nSteamVRVersionBuild = 18;
static const uint32_t k_nSteamVRVersionMinor = 6;
static const uint32_t k_nSteamVRVersionBuild = 10;
} // namespace vr
// vrtypes.h
@@ -354,6 +354,7 @@ enum ETrackedDeviceProperty
Prop_BootloaderVersion_Uint64 = 1044,
Prop_AdditionalSystemReportData_String = 1045, // additional string to include in system reports about a tracked device
Prop_CompositeFirmwareVersion_String = 1046, // additional FW components from a device that gets propagated into reports
Prop_Firmware_RemindUpdate_Bool = 1047,
// Properties that are unique to TrackedDeviceClass_HMD
Prop_ReportsTimeSinceVSync_Bool = 2000,
@@ -408,7 +409,7 @@ enum ETrackedDeviceProperty
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_DoNotApplyPrediction_Bool = 2054, // currently no effect. was used to disable HMD pose prediction on MR, which is now done by MR driver setting velocity=0
Prop_CameraToHeadTransforms_Matrix34_Array = 2055,
Prop_DistortionMeshResolution_Int32 = 2056, // custom resolution of compositor calls to IVRSystem::ComputeDistortion
Prop_DriverIsDrawingControllers_Bool = 2057,
@@ -429,9 +430,14 @@ enum ETrackedDeviceProperty
Prop_CameraDistortionFunction_Int32_Array = 2072, // Prop_NumCameras_Int32-sized array of vr::EVRDistortionFunctionType values (max size is vr::k_unMaxCameras)
Prop_CameraDistortionCoefficients_Float_Array = 2073, // Prop_NumCameras_Int32-sized array of double[vr::k_unMaxDistortionFunctionParameters] (max size is vr::k_unMaxCameras)
Prop_ExpectedControllerType_String = 2074,
Prop_HmdTrackingStyle_Int32 = 2075, // one of EHmdTrackingStyle
Prop_DriverProvidedChaperoneVisibility_Bool = 2076,
Prop_DisplayAvailableFrameRates_Float_Array = 2080, // populated by compositor from actual EDID list when available from GPU driver
Prop_DisplaySupportsMultipleFramerates_Bool = 2081, // if this is true but Prop_DisplayAvailableFrameRates_Float_Array is empty, explain to user
Prop_DisplayColorMultLeft_Vector3 = 2082,
Prop_DisplayColorMultRight_Vector3 = 2083,
Prop_DashboardLayoutPathName_String = 2090,
@@ -527,6 +533,15 @@ enum ETrackedPropertyError
TrackedProp_IPCReadFailure = 13,
};
/** Used to drive certain text in the UI when talking about the tracking system for the HMD */
enum EHmdTrackingStyle
{
HmdTrackingStyle_Unknown = 0,
HmdTrackingStyle_Lighthouse = 1, // base stations and lasers
HmdTrackingStyle_OutsideInCameras = 2, // Cameras and LED, Rift 1 style
HmdTrackingStyle_InsideOutCameras = 3, // Cameras on HMD looking at the world
};
typedef uint64_t VRActionHandle_t;
typedef uint64_t VRActionSetHandle_t;
@@ -1110,6 +1125,7 @@ enum EShowUIType
// ShowUI_QuickStart = 2, // Deprecated
ShowUI_Pairing = 3,
ShowUI_Settings = 4,
ShowUI_DebugCommands = 5,
};
struct VREvent_ShowUI_t
@@ -1514,6 +1530,7 @@ enum EVRInitError
VRInitError_Init_TrackerManagerInitFailed = 142,
VRInitError_Init_AlreadyRunning = 143,
VRInitError_Init_FailedForVrMonitor = 144,
VRInitError_Init_PropertyManagerInitFailed = 145,
VRInitError_Driver_Failed = 200,
VRInitError_Driver_Unknown = 201,
@@ -1539,6 +1556,8 @@ enum EVRInitError
VRInitError_IPC_CompositorConnectFailed = 306,
VRInitError_IPC_CompositorInvalidConnectResponse = 307,
VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
VRInitError_IPC_ConnectFailedAfterTargetExited = 309,
VRInitError_IPC_NamespaceUnavailable = 310,
VRInitError_Compositor_Failed = 400,
VRInitError_Compositor_D3D11HardwareRequired = 401,
@@ -1625,6 +1644,8 @@ enum EVRInitError
VRInitError_Compositor_CreateTextIndexBuffer = 482,
VRInitError_Compositor_CreateMirrorTextures = 483,
VRInitError_Compositor_CreateLastFrameRenderTexture = 484,
VRInitError_Compositor_CreateMirrorOverlay = 485,
VRInitError_Compositor_FailedToCreateVirtualDisplayBackbuffer = 486,
VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
VRInitError_VendorSpecific_WindowsNotInDevMode = 1001,
@@ -1642,6 +1663,7 @@ enum EVRInitError
VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
VRInitError_VendorSpecific_OculusRuntimeBadInstall = 1114,
VRInitError_Steam_SteamInstallationNotFound = 2000,
@@ -1735,6 +1757,75 @@ typedef uint32_t ScreenshotHandle_t;
static const uint32_t k_unScreenshotHandleInvalid = 0;
/** Compositor frame timing reprojection flags. */
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.
const uint32_t VRCompositor_ReprojectionMotion = 0x08; // This flag indicates whether or not motion smoothing was triggered for this frame
const uint32_t VRCompositor_PredictionMask = 0x30; // The runtime may predict more than one frame (up to four) ahead if
// it detects the application is taking too long to render. These two
// bits will contain the count of additional frames (normally zero).
// Use the VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES macro to read from
// the latest frame timing entry.
const uint32_t VRCompositor_ThrottleMask = 0xC0; // Number of frames the compositor is throttling the application.
// Use the VR_COMPOSITOR_NUMBER_OF_THROTTLED_FRAMES macro to read from
// the latest frame timing entry.
#define VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_PredictionMask ) >> 4 )
#define VR_COMPOSITOR_NUMBER_OF_THROTTLED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_ThrottleMask ) >> 6 )
/** Provides a single frame's timing information to the app */
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;
/** Absolute time reference for comparing frames. This aligns with the vsync that running start is relative to. */
double m_flSystemTimeInSeconds;
/** These times may include work from other processes due to OS scheduling.
* The fewer packets of work these are broken up into, the less likely this will happen.
* GPU work can be broken up by calling Flush. This can sometimes be useful to get the GPU started
* processing that work earlier in the frame. */
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)
/** Miscellaneous measured intervals. */
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)
/** The following are all relative to this frame's SystemTimeInSeconds */
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
uint32_t m_nNumVSyncsReadyForUse;
uint32_t m_nNumVSyncsToFirstView;
};
/** Frame timing data provided by direct mode drivers. */
struct DriverDirectMode_FrameTiming
{
@@ -2089,7 +2180,7 @@ namespace vr
static const char * const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
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_BaseStationPowerManagement_Int32 = "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_MaxRecommendedResolution_Int32 = "maxRecommendedResolution";
@@ -2117,13 +2208,15 @@ namespace vr
static const char * const k_pch_SteamVR_DebugInput = "debugInput";
static const char * const k_pch_SteamVR_DebugInputBinding = "debugInputBinding";
static const char * const k_pch_SteamVR_DoNotFadeToGrid = "doNotFadeToGrid";
static const char * const k_pch_SteamVR_InputBindingUIBlock = "inputBindingUI";
static const char * const k_pch_SteamVR_RenderCameraMode = "renderCameraMode";
static const char * const k_pch_SteamVR_EnableSharedResourceJournaling = "enableSharedResourceJournaling";
static const char * const k_pch_SteamVR_EnableSafeMode = "enableSafeMode";
static const char * const k_pch_SteamVR_PreferredRefreshRate = "preferredRefreshRate";
static const char * const k_pch_SteamVR_LastVersionNotice = "lastVersionNotice";
static const char * const k_pch_SteamVR_LastVersionNoticeDate = "lastVersionNoticeDate";
static const char * const k_pch_SteamVR_HmdDisplayColorGainR_Float = "hmdDisplayColorGainR";
static const char * const k_pch_SteamVR_HmdDisplayColorGainG_Float = "hmdDisplayColorGainG";
static const char * const k_pch_SteamVR_HmdDisplayColorGainB_Float = "hmdDisplayColorGainB";
//-----------------------------------------------------------------------------
// direct mode keys
@@ -2261,6 +2354,7 @@ namespace vr
//-----------------------------------------------------------------------------
// driver keys - These could be checked in any driver_<name> section
static const char * const k_pch_Driver_Enable_Bool = "enable";
static const char * const k_pch_Driver_LoadPriority_Int32 = "loadPriority";
//-----------------------------------------------------------------------------
// web interface keys
@@ -2303,6 +2397,14 @@ namespace vr
// Dismissed warnings
static const char * const k_pch_DismissedWarnings_Section = "DismissedWarnings";
//-----------------------------------------------------------------------------
// Input Settings
static const char * const k_pch_Input_Section = "input";
static const char* const k_pch_Input_LeftThumbstickRotation_Float = "leftThumbstickRotation";
static const char* const k_pch_Input_RightThumbstickRotation_Float = "rightThumbstickRotation";
static const char* const k_pch_Input_ThumbstickDeadzone_Float = "thumbstickDeadzone";
} // namespace vr
// iservertrackeddevicedriver.h
@@ -2757,6 +2859,9 @@ public:
float GetFloatProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
int32_t GetInt32Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
uint64_t GetUint64Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
HmdVector2_t GetVec2Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
HmdVector3_t GetVec3Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
HmdVector4_t GetVec4Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L );
/** Returns a single typed property. If the device index is not valid or the property is not a string type this function will
* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
@@ -2782,6 +2887,9 @@ public:
ETrackedPropertyError SetFloatProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, float fNewValue );
ETrackedPropertyError SetInt32Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, int32_t nNewValue );
ETrackedPropertyError SetUint64Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, uint64_t ulNewValue );
ETrackedPropertyError SetVec2Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const HmdVector2_t & vNewValue );
ETrackedPropertyError SetVec3Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const HmdVector3_t & vNewValue );
ETrackedPropertyError SetVec4Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const HmdVector4_t & vNewValue );
/** Sets a string property. The new value will be returned on any subsequent call to get this property in any process. */
ETrackedPropertyError SetStringProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const char *pchNewValue );
@@ -2959,7 +3067,6 @@ inline bool CVRPropertyHelpers::GetBoolProperty( PropertyContainerHandle_t ulCon
return GetPropertyHelper<bool>( ulContainerHandle, prop, pError, false, k_unBoolPropertyTag );
}
inline float CVRPropertyHelpers::GetFloatProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
{
return GetPropertyHelper<float>( ulContainerHandle, prop, pError, 0.f, k_unFloatPropertyTag );
@@ -2975,6 +3082,24 @@ inline uint64_t CVRPropertyHelpers::GetUint64Property( PropertyContainerHandle_t
return GetPropertyHelper<uint64_t>( ulContainerHandle, prop, pError, 0, k_unUint64PropertyTag );
}
inline HmdVector2_t CVRPropertyHelpers::GetVec2Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
{
HmdVector2_t defaultval = { 0 };
return GetPropertyHelper<HmdVector2_t>( ulContainerHandle, prop, pError, defaultval, k_unHmdVector2PropertyTag );
}
inline HmdVector3_t CVRPropertyHelpers::GetVec3Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
{
HmdVector3_t defaultval = { 0 };
return GetPropertyHelper<HmdVector3_t>( ulContainerHandle, prop, pError, defaultval, k_unHmdVector3PropertyTag );
}
inline HmdVector4_t CVRPropertyHelpers::GetVec4Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError *pError )
{
HmdVector4_t defaultval = { 0 };
return GetPropertyHelper<HmdVector4_t>( ulContainerHandle, prop, pError, defaultval, k_unHmdVector4PropertyTag );
}
inline ETrackedPropertyError CVRPropertyHelpers::SetBoolProperty( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, bool bNewValue )
{
return SetProperty( ulContainerHandle, prop, &bNewValue, sizeof( bNewValue ), k_unBoolPropertyTag );
@@ -2995,6 +3120,21 @@ inline ETrackedPropertyError CVRPropertyHelpers::SetUint64Property( PropertyCont
return SetProperty( ulContainerHandle, prop, &ulNewValue, sizeof( ulNewValue ), k_unUint64PropertyTag );
}
inline ETrackedPropertyError CVRPropertyHelpers::SetVec2Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const HmdVector2_t & vNewValue )
{
return SetProperty( ulContainerHandle, prop, ( void * ) &vNewValue, sizeof( HmdVector2_t ), k_unHmdVector2PropertyTag );
}
inline ETrackedPropertyError CVRPropertyHelpers::SetVec3Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const HmdVector3_t & vNewValue )
{
return SetProperty( ulContainerHandle, prop, ( void * ) &vNewValue, sizeof( HmdVector3_t ), k_unHmdVector3PropertyTag );
}
inline ETrackedPropertyError CVRPropertyHelpers::SetVec4Property( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, const HmdVector4_t & vNewValue )
{
return SetProperty( ulContainerHandle, prop, ( void * ) &vNewValue, sizeof( HmdVector4_t ), k_unHmdVector4PropertyTag );
}
/** Sets the error return value for a property. This value will be returned on all subsequent requests to get the property */
inline ETrackedPropertyError CVRPropertyHelpers::SetPropertyError( PropertyContainerHandle_t ulContainerHandle, ETrackedDeviceProperty prop, ETrackedPropertyError eError )
{
@@ -3195,6 +3335,10 @@ public:
/** Requests that SteamVR be restarted. The provided reason will be displayed to the user and should be in the current locale. */
virtual void RequestRestart( const char *pchLocalizedReason, const char *pchExecutableToStart, const char *pchArguments, const char *pchWorkingDirectory ) = 0;
/** Interface for copying a range of timing data. Frames are returned in ascending order (oldest to newest) with the last being the most recent frame.
* Only the first entry's m_nSize needs to be set, as the rest will be inferred from that. Returns total number of entries filled out. */
virtual uint32_t GetFrameTimings( Compositor_FrameTiming *pTiming, uint32_t nFrames ) = 0;
};
static const char *IVRServerDriverHost_Version = "IVRServerDriverHost_005";
@@ -3282,10 +3426,10 @@ class IVRWatchdogHost
public:
/** Client drivers in watchdog mode should call this when they have received a signal from hardware that should
* cause SteamVR to start */
virtual void WatchdogWakeUp() = 0;
virtual void WatchdogWakeUp( vr::ETrackedDeviceClass eDeviceClass ) = 0;
};
static const char *IVRWatchdogHost_Version = "IVRWatchdogHost_001";
static const char *IVRWatchdogHost_Version = "IVRWatchdogHost_002";
};
@@ -3415,6 +3559,8 @@ public:
virtual uint32_t GetDriverName( vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
virtual DriverHandle_t GetDriverHandle( const char *pchDriverName ) = 0;
virtual bool IsEnabled( vr::DriverId_t nDriver ) const = 0;
};
static const char * const IVRDriverManager_Version = "IVRDriverManager_001";