1739 lines
74 KiB
C++
1739 lines
74 KiB
C++
|
|
// 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
|
|
|
|
namespace vr
|
|
{
|
|
|
|
#if defined(__linux__) || defined(__APPLE__)
|
|
// The 32-bit version of gcc has the alignment requirement for uint64 and double set to
|
|
// 4 meaning that even with #pragma pack(8) these types will only be four-byte aligned.
|
|
// The 64-bit version of gcc has the alignment requirement for these types set to
|
|
// 8 meaning that unless we use #pragma pack(4) our structures will get bigger.
|
|
// The 64-bit structure packing has to match the 32-bit structure packing for each platform.
|
|
#pragma pack( push, 4 )
|
|
#else
|
|
#pragma pack( push, 8 )
|
|
#endif
|
|
|
|
// right-handed system
|
|
// +y is up
|
|
// +x is to the right
|
|
// -z is going away from you
|
|
// Distance unit is meters
|
|
struct HmdMatrix34_t
|
|
{
|
|
float m[3][4];
|
|
};
|
|
|
|
struct HmdMatrix44_t
|
|
{
|
|
float m[4][4];
|
|
};
|
|
|
|
struct HmdVector3_t
|
|
{
|
|
float v[3];
|
|
};
|
|
|
|
struct HmdVector3d_t
|
|
{
|
|
double v[3];
|
|
};
|
|
|
|
struct HmdVector2_t
|
|
{
|
|
float v[2];
|
|
};
|
|
|
|
struct HmdQuaternion_t
|
|
{
|
|
double w, x, y, z;
|
|
};
|
|
|
|
struct HmdQuad_t
|
|
{
|
|
HmdVector3_t vCorners[ 4 ];
|
|
};
|
|
|
|
/** Used to return the post-distortion UVs for each color channel.
|
|
* UVs range from 0 to 1 with 0,0 in the upper left corner of the
|
|
* source render target. The 0,0 to 1,1 range covers a single eye. */
|
|
struct DistortionCoordinates_t
|
|
{
|
|
float rfRed[2];
|
|
float rfGreen[2];
|
|
float rfBlue[2];
|
|
};
|
|
|
|
enum Hmd_Eye
|
|
{
|
|
Eye_Left = 0,
|
|
Eye_Right = 1
|
|
};
|
|
|
|
enum GraphicsAPIConvention
|
|
{
|
|
API_DirectX = 0, // Normalized Z goes from 0 at the viewer to 1 at the far clip plane
|
|
API_OpenGL = 1, // Normalized Z goes from 1 at the viewer to -1 at the far clip plane
|
|
};
|
|
|
|
enum HmdTrackingResult
|
|
{
|
|
TrackingResult_Uninitialized = 1,
|
|
|
|
TrackingResult_Calibrating_InProgress = 100,
|
|
TrackingResult_Calibrating_OutOfRange = 101,
|
|
|
|
TrackingResult_Running_OK = 200,
|
|
TrackingResult_Running_OutOfRange = 201,
|
|
};
|
|
|
|
static const uint32_t k_unTrackingStringSize = 32;
|
|
static const uint32_t k_unMaxTrackedDeviceCount = 16;
|
|
static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
|
|
static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
|
|
|
|
/** Describes what kind of object is being tracked at a given ID */
|
|
enum TrackedDeviceClass
|
|
{
|
|
TrackedDeviceClass_Invalid = 0, // the ID was not valid.
|
|
TrackedDeviceClass_HMD = 1, // Head-Mounted Displays
|
|
TrackedDeviceClass_Controller = 2, // Tracked controllers
|
|
TrackedDeviceClass_TrackingReference = 4, // Camera and base stations that serve as tracking reference points
|
|
|
|
TrackedDeviceClass_Other = 1000,
|
|
};
|
|
|
|
|
|
/** describes a single pose for a tracked object */
|
|
struct TrackedDevicePose_t
|
|
{
|
|
HmdMatrix34_t mDeviceToAbsoluteTracking;
|
|
HmdVector3_t vVelocity; // velocity in tracker space in m/s
|
|
HmdVector3_t vAngularVelocity; // angular velocity in radians/s (?)
|
|
HmdTrackingResult eTrackingResult;
|
|
bool bPoseIsValid;
|
|
|
|
// This indicates that there is a device connected for this spot in the pose array.
|
|
// It could go from true to false if the user unplugs the device.
|
|
bool bDeviceIsConnected;
|
|
};
|
|
|
|
/** Identifies which style of tracking origin the application wants to use
|
|
* for the poses it is requesting */
|
|
enum TrackingUniverseOrigin
|
|
{
|
|
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. You probably don't want this one.
|
|
};
|
|
|
|
|
|
/** Each entry in this enum represents a property that can be retrieved about a
|
|
* tracked device. Many fields are only valid for one TrackedDeviceClass. */
|
|
enum TrackedDeviceProperty
|
|
{
|
|
// 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,
|
|
|
|
// 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_String = 2006,
|
|
Prop_IsOnDesktop_Bool = 2007,
|
|
|
|
// 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
|
|
|
|
// 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,
|
|
};
|
|
|
|
/** Used to pass device IDs to API calls */
|
|
typedef uint32_t TrackedDeviceIndex_t;
|
|
static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
|
|
|
|
/** No string property will ever be longer than this length */
|
|
static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
|
|
|
|
/** Used to return errors that occur when reading properties. */
|
|
enum TrackedPropertyError
|
|
{
|
|
TrackedProp_Success = 0,
|
|
TrackedProp_WrongDataType = 1,
|
|
TrackedProp_WrongDeviceClass = 2,
|
|
TrackedProp_BufferTooSmall = 3,
|
|
TrackedProp_UnknownProperty = 4,
|
|
TrackedProp_InvalidDevice = 5,
|
|
TrackedProp_CouldNotContactServer = 6,
|
|
TrackedProp_ValueNotProvidedByDevice = 7,
|
|
TrackedProp_StringExceedsMaximumLength = 8,
|
|
};
|
|
|
|
|
|
/** a single vertex in a render model */
|
|
struct RenderModel_Vertex_t
|
|
{
|
|
HmdVector3_t vPosition; // position in meters in device space
|
|
HmdVector3_t vNormal;
|
|
float rfTextureCoord[ 2 ];
|
|
};
|
|
|
|
/** A texture map for use on a render model */
|
|
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
|
|
};
|
|
|
|
/** Contains everything a game needs to render a single tracked or static object for the user. */
|
|
struct RenderModel_t
|
|
{
|
|
uint64_t ulInternalHandle; // Used internally by SteamVR
|
|
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
|
|
RenderModel_TextureMap_t diffuseTexture; // RGBA diffuse texture for the model
|
|
};
|
|
|
|
|
|
/** Allows the application to control what part of the provided texture will be used in the
|
|
* frame buffer. */
|
|
struct VRTextureBounds_t
|
|
{
|
|
float uMin, vMin;
|
|
float uMax, vMax;
|
|
};
|
|
|
|
/** Status of the overall system */
|
|
enum VRStatusState_t
|
|
{
|
|
State_OK = 0,
|
|
State_Error = 1,
|
|
State_Warning = 2,
|
|
State_Undefined = 3,
|
|
State_NotSet = 4,
|
|
};
|
|
|
|
|
|
/** The types of events that could be posted (and what the parameters mean for each event type) */
|
|
enum EVREventType
|
|
{
|
|
VREvent_None = 0,
|
|
|
|
VREvent_TrackedDeviceActivated = 100,
|
|
VREvent_TrackedDeviceDeactivated = 101,
|
|
VREvent_TrackedDeviceUpdated = 102,
|
|
|
|
VREvent_ButtonPress = 200, // data is controller
|
|
VREvent_ButtonUnpress = 201, // data is controller
|
|
VREvent_ButtonTouch = 202, // data is controller
|
|
VREvent_ButtonUntouch = 203, // data is controller
|
|
|
|
VREvent_MouseMove = 300, // data is mouse
|
|
VREvent_MouseButtonDown = 301, // data is mouse
|
|
VREvent_MouseButtonUp = 302, // data is mouse
|
|
|
|
VREvent_InputFocusCaptured = 400, // data is process
|
|
VREvent_InputFocusReleased = 401, // data is process
|
|
VREvent_SceneFocusLost = 402, // data is process
|
|
VREvent_SceneFocusGained = 403, // data is process
|
|
VREvent_SceneApplicationChanged = 404, // data is process
|
|
|
|
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_Notification_Show = 600,
|
|
VREvent_Notification_Dismissed = 601,
|
|
VREvent_Notification_BeginInteraction = 602,
|
|
|
|
VREvent_Quit = 700, // data is process
|
|
VREvent_ProcessQuit = 701, // data is process
|
|
|
|
VREvent_ChaperoneDataHasChanged = 800,
|
|
VREvent_ChaperoneUniverseHasChanged = 801,
|
|
|
|
VREvent_StatusUpdate = 900,
|
|
};
|
|
|
|
|
|
/** VR controller button and axis IDs */
|
|
enum EVRButtonId
|
|
{
|
|
k_EButton_System = 0,
|
|
k_EButton_ApplicationMenu = 1,
|
|
k_EButton_Grip = 2,
|
|
|
|
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_Max = 64
|
|
};
|
|
|
|
inline uint64_t ButtonMaskFromId( EVRButtonId id ) { return 1ull << id; }
|
|
|
|
/** used for controller button events */
|
|
struct VREvent_Controller_t
|
|
{
|
|
EVRButtonId button;
|
|
};
|
|
|
|
|
|
/** used for simulated mouse events in overlay space */
|
|
enum EVRMouseButton
|
|
{
|
|
VRMouseButton_Left = 0x0001,
|
|
VRMouseButton_Right = 0x0002,
|
|
VRMouseButton_Middle = 0x0004,
|
|
};
|
|
|
|
|
|
/** used for simulated mouse events in overlay space */
|
|
struct VREvent_Mouse_t
|
|
{
|
|
float x, y;
|
|
EVRMouseButton button;
|
|
};
|
|
|
|
/** notification related events. Details will still change at this point */
|
|
struct VREvent_Notification_t
|
|
{
|
|
uint64_t ulUserValue;
|
|
uint32_t notificationId;
|
|
};
|
|
|
|
|
|
/** Used for events about processes */
|
|
struct VREvent_Process_t
|
|
{
|
|
uint32_t pid;
|
|
uint32_t oldPid;
|
|
};
|
|
|
|
|
|
/** Used for a few events about overlays */
|
|
struct VREvent_Overlay_t
|
|
{
|
|
uint64_t overlayHandle;
|
|
};
|
|
|
|
|
|
/** Used for a few events about overlays */
|
|
struct VREvent_Status_t
|
|
{
|
|
VRStatusState_t statusState;
|
|
};
|
|
|
|
/** Not actually used for any events. It is just used to reserve
|
|
* space in the union for future event types */
|
|
struct VREvent_Reserved_t
|
|
{
|
|
uint64_t reserved0;
|
|
uint64_t reserved1;
|
|
};
|
|
|
|
/** If you change this you must manually update openvr_interop.cs.py */
|
|
typedef union
|
|
{
|
|
VREvent_Reserved_t reserved;
|
|
VREvent_Controller_t controller;
|
|
VREvent_Mouse_t mouse;
|
|
VREvent_Process_t process;
|
|
VREvent_Notification_t notification;
|
|
VREvent_Overlay_t overlay;
|
|
VREvent_Status_t status;
|
|
} VREvent_Data_t;
|
|
|
|
/** An event posted by the server to all running applications */
|
|
struct VREvent_t
|
|
{
|
|
EVREventType eventType;
|
|
TrackedDeviceIndex_t trackedDeviceIndex;
|
|
VREvent_Data_t data;
|
|
float eventAgeSeconds;
|
|
};
|
|
|
|
|
|
/** The mesh to draw into the stencil (or depth) buffer to perform
|
|
* early stencil (or depth) kills of pixels that will never appear on the HMD.
|
|
* This mesh draws on all the pixels that will be hidden after distortion.
|
|
*
|
|
* If the HMD does not provide a visible area mesh pVertexData will be
|
|
* NULL and unTriangleCount will be 0. */
|
|
struct HiddenAreaMesh_t
|
|
{
|
|
const HmdVector2_t *pVertexData;
|
|
uint32_t unTriangleCount;
|
|
};
|
|
|
|
|
|
/** Identifies what kind of axis is on the controller at index n. Read this type
|
|
* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
|
|
*/
|
|
enum EVRControllerAxisType
|
|
{
|
|
k_eControllerAxis_None = 0,
|
|
k_eControllerAxis_TrackPad = 1,
|
|
k_eControllerAxis_Joystick = 2,
|
|
k_eControllerAxis_Trigger = 3, // Analog trigger data is in the X axis
|
|
};
|
|
|
|
|
|
/** contains information about one axis on the controller */
|
|
struct VRControllerAxis_t
|
|
{
|
|
float x; // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
|
|
float y; // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
|
|
};
|
|
|
|
|
|
/** the number of axes in the controller state */
|
|
static const uint32_t k_unControllerStateAxisCount = 5;
|
|
|
|
|
|
/** Holds all the state of a controller at one moment in time. */
|
|
struct VRControllerState001_t
|
|
{
|
|
// If packet num matches that on your prior call, then the controller state hasn't been changed since
|
|
// your last call and there is no need to process it
|
|
uint32_t unPacketNum;
|
|
|
|
// bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
|
|
uint64_t ulButtonPressed;
|
|
uint64_t ulButtonTouched;
|
|
|
|
// Axis data for the controller's analog inputs
|
|
VRControllerAxis_t rAxis[ k_unControllerStateAxisCount ];
|
|
};
|
|
|
|
|
|
typedef VRControllerState001_t VRControllerState_t;
|
|
|
|
|
|
/** determines how to provide output to the application of various event processing functions. */
|
|
enum EVRControllerEventOutputType
|
|
{
|
|
ControllerEventOutput_OSEvents = 0,
|
|
ControllerEventOutput_VREvents = 1,
|
|
};
|
|
|
|
|
|
/** Allows the application to customize how the overlay appears in the compositor */
|
|
struct Compositor_OverlaySettings
|
|
{
|
|
uint32_t size; // sizeof(Compositor_OverlaySettings)
|
|
bool curved, antialias;
|
|
float scale, distance, alpha;
|
|
float uOffset, vOffset, uScale, vScale;
|
|
float gridDivs, gridWidth, gridScale;
|
|
HmdMatrix44_t transform;
|
|
};
|
|
|
|
/** used to refer to a single VR overlay */
|
|
typedef uint64_t VROverlayHandle_t;
|
|
|
|
static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
|
|
|
|
/** Errors that can occur around VR overlays */
|
|
enum VROverlayError
|
|
{
|
|
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,
|
|
};
|
|
|
|
/** enum values to pass in to VR_Init to identify whether the application will
|
|
* draw a 3D scene. */
|
|
enum EVRApplicationType
|
|
{
|
|
VRApplication_Other = 0, // Some other kind of application that isn't covered by the other entries
|
|
VRApplication_Scene = 1, // Application will submit 3D frames
|
|
VRApplication_Overlay = 2, // Application only interacts with overlays
|
|
};
|
|
|
|
/** error codes returned by Vr_Init */
|
|
|
|
// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
|
|
enum HmdError
|
|
{
|
|
HmdError_None = 0,
|
|
HmdError_Unknown = 1,
|
|
|
|
HmdError_Init_InstallationNotFound = 100,
|
|
HmdError_Init_InstallationCorrupt = 101,
|
|
HmdError_Init_VRClientDLLNotFound = 102,
|
|
HmdError_Init_FileNotFound = 103,
|
|
HmdError_Init_FactoryNotFound = 104,
|
|
HmdError_Init_InterfaceNotFound = 105,
|
|
HmdError_Init_InvalidInterface = 106,
|
|
HmdError_Init_UserConfigDirectoryInvalid = 107,
|
|
HmdError_Init_HmdNotFound = 108,
|
|
HmdError_Init_NotInitialized = 109,
|
|
HmdError_Init_PathRegistryNotFound = 110,
|
|
HmdError_Init_NoConfigPath = 111,
|
|
HmdError_Init_NoLogPath = 112,
|
|
HmdError_Init_PathRegistryNotWritable = 113,
|
|
HmdError_Init_AppInfoInitFailed = 114,
|
|
HmdError_Init_Retry = 115, // Used internally to cause retries to vrserver
|
|
HmdError_Init_InitCanceledByUser = 116, // The calling application should silently exit. The user canceled app startup
|
|
HmdError_Init_AnotherAppLaunching = 117,
|
|
|
|
HmdError_Driver_Failed = 200,
|
|
HmdError_Driver_Unknown = 201,
|
|
HmdError_Driver_HmdUnknown = 202,
|
|
HmdError_Driver_NotLoaded = 203,
|
|
HmdError_Driver_RuntimeOutOfDate = 204,
|
|
HmdError_Driver_HmdInUse = 205,
|
|
HmdError_Driver_NotCalibrated = 206,
|
|
HmdError_Driver_CalibrationInvalid = 207,
|
|
HmdError_Driver_HmdDisplayNotFound = 208,
|
|
|
|
HmdError_IPC_ServerInitFailed = 300,
|
|
HmdError_IPC_ConnectFailed = 301,
|
|
HmdError_IPC_SharedStateInitFailed = 302,
|
|
HmdError_IPC_CompositorInitFailed = 303,
|
|
HmdError_IPC_MutexInitFailed = 304,
|
|
|
|
HmdError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
|
|
|
|
HmdError_Steam_SteamInstallationNotFound = 2000,
|
|
|
|
};
|
|
|
|
#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
|
|
|
|
}
|
|
|
|
#endif // _INCLUDE_VRTYPES_H
|
|
|
|
// vrannotation.h
|
|
#ifdef __clang__
|
|
# 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
|
|
{
|
|
|
|
class IVRSystem
|
|
{
|
|
public:
|
|
|
|
|
|
// ------------------------------------
|
|
// Display Methods
|
|
// ------------------------------------
|
|
|
|
/** Size and position that the window needs to be on the VR display. */
|
|
virtual void GetWindowBounds( int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
|
|
|
|
/** Suggested size for the intermediate render target that the distortion pulls from. */
|
|
virtual void GetRecommendedRenderTargetSize( uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
|
|
|
|
/** Gets the viewport in the frame buffer to draw the output of the distortion into */
|
|
virtual void GetEyeOutputViewport( Hmd_Eye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
|
|
|
|
/** The projection matrix for the specified eye */
|
|
virtual HmdMatrix44_t GetProjectionMatrix( Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType ) = 0;
|
|
|
|
/** The components necessary to build your own projection matrix in case your
|
|
* application is doing something fancy like infinite Z */
|
|
virtual void GetProjectionRaw( Hmd_Eye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom ) = 0;
|
|
|
|
/** Returns the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in
|
|
* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport. */
|
|
virtual DistortionCoordinates_t ComputeDistortion( Hmd_Eye eEye, float fU, float fV ) = 0;
|
|
|
|
/** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head
|
|
* space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection.
|
|
* Normally View and Eye^-1 will be multiplied together and treated as View in your application.
|
|
*/
|
|
virtual HmdMatrix34_t GetEyeToHeadTransform( Hmd_Eye eEye ) = 0;
|
|
|
|
/** Returns the number of elapsed seconds since the last recorded vsync event. This
|
|
* will come from a vsync timer event in the timer if possible or from the application-reported
|
|
* time if that is not available. If no vsync times are available the function will
|
|
* return zero for vsync time and frame counter and return false from the method. */
|
|
virtual bool GetTimeSinceLastVsync( float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter ) = 0;
|
|
|
|
/** [D3D9 Only]
|
|
* Returns the adapter index that the user should pass into CreateDevice to set up D3D9 in such
|
|
* a way that it can go full screen exclusive on the HMD. Returns -1 if there was an error.
|
|
*/
|
|
virtual int32_t GetD3D9AdapterIndex() = 0;
|
|
|
|
/** [D3D10/11 Only]
|
|
* Returns the adapter index and output index that the user should pass into EnumAdapters and EnumOutputs
|
|
* to create the device and swap chain in DX10 and DX11. If an error occurs both indices will be set to -1.
|
|
*/
|
|
virtual void GetDXGIOutputInfo( int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex ) = 0;
|
|
|
|
/** [Windows Only]
|
|
* Notifies the system that the VR output will appear in a particular window.
|
|
*/
|
|
virtual bool AttachToWindow( void *hWnd ) = 0;
|
|
|
|
// ------------------------------------
|
|
// Tracking Methods
|
|
// ------------------------------------
|
|
|
|
/** The pose that the tracker thinks that the HMD will be in at the specified number of seconds into the
|
|
* future. Pass 0 to get the state at the instant the method is called. Most of the time the application should
|
|
* calculate the time until the photons will be emitted from the display and pass that time into the method.
|
|
*
|
|
* This is roughly analogous to the inverse of the view matrix in most applications, though
|
|
* many games will need to do some additional rotation or translation on top of the rotation
|
|
* and translation provided by the head pose.
|
|
*
|
|
* For devices where bPoseIsValid is true the application can use the pose to position the device
|
|
* in question. The provided array can be any size up to k_unMaxTrackedDeviceCount.
|
|
*
|
|
* Seated experiences should call this method with TrackingUniverseSeated and receive poses relative
|
|
* to the seated zero pose. Standing experiences should call this method with TrackingUniverseStanding
|
|
* and receive poses relative to the chaperone soft bounds. TrackingUniverseRawAndUncalibrated should
|
|
* probably not be used unless the application is the chaperone calibration tool itself, but will provide
|
|
* poses relative to the hardware-specific coordinate system in the driver.
|
|
*/
|
|
virtual void GetDeviceToAbsoluteTrackingPose( TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount) TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount ) = 0;
|
|
|
|
/** Sets the zero pose for the seated tracker coordinate system to the current position and yaw of the HMD. After
|
|
* ResetSeatedZeroPose all GetDeviceToAbsoluteTrackingPose calls that pass TrackingUniverseSeated as the origin
|
|
* will be relative to this new zero pose. The new zero coordinate system will not change the fact that the Y axis
|
|
* is up in the real world, so the next pose returned from GetDeviceToAbsoluteTrackingPose after a call to
|
|
* ResetSeatedZeroPose may not be exactly an identity matrix. */
|
|
virtual void ResetSeatedZeroPose() = 0;
|
|
|
|
/** Returns the transform from the seated zero pose to the standing absolute tracking system. This allows
|
|
* applications to represent the seated origin to used or transform object positions from one coordinate
|
|
* system to the other.
|
|
*
|
|
* The seated origin may or may not be inside the soft or hard bounds returned by IVRChaperone. Its position
|
|
* depends on what the user has set in the chaperone calibration tool and previous calls to ResetSeatedZeroPose. */
|
|
virtual HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() = 0;
|
|
|
|
/** Get a sorted array of device indices of a given class of tracked devices (e.g. controllers). Devices are sorted right to left
|
|
* relative to the specified tracked device (default: hmd -- pass in -1 for absolute tracking space). Returns the number of devices
|
|
* in the list, or the size of the array needed if not large enough. */
|
|
virtual uint32_t GetSortedTrackedDeviceIndicesOfClass( TrackedDeviceClass eTrackedDeviceClass, VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount) vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex = k_unTrackedDeviceIndex_Hmd ) = 0;
|
|
|
|
|
|
// ------------------------------------
|
|
// Property methods
|
|
// ------------------------------------
|
|
|
|
/** Returns the device class of a tracked device. If there has not been a device connected in this slot
|
|
* since the application started this function will return TrackedDevice_Invalid. For previous detected
|
|
* devices the function will return the previously observed device class.
|
|
*
|
|
* To determine which devices exist on the system, just loop from 0 to k_unMaxTrackedDeviceCount and check
|
|
* the device class. Every device with something other than TrackedDevice_Invalid is associated with an
|
|
* actual tracked device. */
|
|
virtual TrackedDeviceClass GetTrackedDeviceClass( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
|
|
|
|
/** Returns true if there is a device connected in this slot. */
|
|
virtual bool IsTrackedDeviceConnected( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
|
|
|
|
/** Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false. */
|
|
virtual bool GetBoolTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError *pError = 0L ) = 0;
|
|
|
|
/** Returns a float property. If the device index is not valid or the property is not a float type this function will return 0. */
|
|
virtual float GetFloatTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError *pError = 0L ) = 0;
|
|
|
|
/** Returns an int property. If the device index is not valid or the property is not a int type this function will return 0. */
|
|
virtual int32_t GetInt32TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError *pError = 0L ) = 0;
|
|
|
|
/** Returns a uint64 property. If the device index is not valid or the property is not a uint64 type this function will return 0. */
|
|
virtual uint64_t GetUint64TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError *pError = 0L ) = 0;
|
|
|
|
/** Returns a matrix property. If the device index is not valid or the property is not a matrix type, this function will return identity. */
|
|
virtual HmdMatrix34_t GetMatrix34TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError *pError = 0L ) = 0;
|
|
|
|
/** Returns a string property. If the device index is not valid or the property is not a float type this function will
|
|
* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
|
|
* null. Strings will generally fit in buffers of k_unTrackingStringSize characters. */
|
|
virtual uint32_t GetStringTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, TrackedPropertyError *pError = 0L ) = 0;
|
|
|
|
/** returns a string that corresponds with the specified property error. The string will be the name
|
|
* of the error enum value for all valid error codes */
|
|
virtual const char *GetPropErrorNameFromEnum( TrackedPropertyError error ) = 0;
|
|
|
|
// ------------------------------------
|
|
// Event methods
|
|
// ------------------------------------
|
|
|
|
/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
|
|
* this method returns false */
|
|
virtual bool PollNextEvent( VREvent_t *pEvent ) = 0;
|
|
|
|
/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
|
|
* this method returns false. Fills in the pose of the associated tracked device in the provided pose struct.
|
|
* This pose will always be older than the call to this function and should not be used to render the device. */
|
|
virtual bool PollNextEventWithPose( TrackingUniverseOrigin eOrigin, vr::VREvent_t *pEvent, vr::TrackedDevicePose_t *pTrackedDevicePose ) = 0;
|
|
|
|
/** returns the name of an EVREvent enum value */
|
|
virtual const char *GetEventTypeNameFromEnum( EVREventType eType ) = 0;
|
|
|
|
// ------------------------------------
|
|
// Rendering helper methods
|
|
// ------------------------------------
|
|
|
|
/** Returns the stencil mesh information for the current HMD. If this HMD does not have a stencil mesh the vertex data and count will be
|
|
* NULL and 0 respectively. This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering
|
|
* each eye's view. The pixels covered by this mesh will never be seen by the user after the lens distortion is applied and based on visibility to the panels.
|
|
* This will improve perf by letting the GPU early-reject pixels the user will never see before running the pixel shader.
|
|
* NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye.
|
|
*/
|
|
virtual HiddenAreaMesh_t GetHiddenAreaMesh( Hmd_Eye eEye ) = 0;
|
|
|
|
|
|
// ------------------------------------
|
|
// Controller methods
|
|
// ------------------------------------
|
|
|
|
/** Fills the supplied struct with the current state of the controller. Returns false if the controller index
|
|
* is invalid. */
|
|
virtual bool GetControllerState( vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState ) = 0;
|
|
|
|
/** fills the supplied struct with the current state of the controller and the provided pose with the pose of
|
|
* the controller when the controller state was updated most recently. Use this form if you need a precise controller
|
|
* pose as input to your application when the user presses or releases a button. */
|
|
virtual bool GetControllerStateWithPose( TrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, TrackedDevicePose_t *pTrackedDevicePose ) = 0;
|
|
|
|
/** Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
|
|
* and axis combination for 5ms. */
|
|
virtual void TriggerHapticPulse( vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec ) = 0;
|
|
|
|
/** returns the name of an EVRButtonId enum value */
|
|
virtual const char *GetButtonIdNameFromEnum( EVRButtonId eButtonId ) = 0;
|
|
|
|
/** returns the name of an EVRControllerAxisType enum value */
|
|
virtual const char *GetControllerAxisTypeNameFromEnum( EVRControllerAxisType eAxisType ) = 0;
|
|
|
|
/** Tells OpenVR that this process wants exclusive access to controller button states and button events. Other apps will be notified that
|
|
* they have lost input focus with a VREvent_InputFocusCaptured event. Returns false if input focus could not be captured for
|
|
* some reason. */
|
|
virtual bool CaptureInputFocus() = 0;
|
|
|
|
/** Tells OpenVR that this process no longer wants exclusive access to button states and button events. Other apps will be notified
|
|
* that input focus has been released with a VREvent_InputFocusReleased event. */
|
|
virtual void ReleaseInputFocus() = 0;
|
|
|
|
/** Returns true if input focus is captured by another process. */
|
|
virtual bool IsInputFocusCapturedByAnotherProcess() = 0;
|
|
|
|
// ------------------------------------
|
|
// Debug Methods
|
|
// ------------------------------------
|
|
|
|
/** Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
|
|
* but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated.
|
|
* The size of the response including its terminating null is returned. */
|
|
virtual uint32_t DriverDebugRequest( vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize ) = 0;
|
|
|
|
};
|
|
|
|
static const char * const IVRSystem_Version = "IVRSystem_005";
|
|
|
|
}
|
|
|
|
// ivrapplications.h
|
|
namespace vr
|
|
{
|
|
|
|
/** Used for all errors reported by the IVRApplications interface */
|
|
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_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,
|
|
};
|
|
|
|
/** The maximum length of an application key */
|
|
static const uint32_t k_unMaxApplicationKeyLength = 128;
|
|
|
|
/** these are the properties available on applications. */
|
|
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_IsDashboardOverlay_Bool = 60,
|
|
};
|
|
|
|
|
|
class IVRApplications
|
|
{
|
|
public:
|
|
|
|
// --------------- Application management --------------- //
|
|
|
|
/** Adds an application manifest to the list to load when building the list of installed applications.
|
|
* Temporary manifests are not automatically loaded */
|
|
virtual EVRApplicationError AddApplicationManifest( const char *pchApplicationManifestFullPath, bool bTemporary = false ) = 0;
|
|
|
|
/** Removes an application manifest from the list to load when building the list of installed applications. */
|
|
virtual EVRApplicationError RemoveApplicationManifest( const char *pchApplicationManifestFullPath ) = 0;
|
|
|
|
/** Returns true if an application is installed */
|
|
virtual bool IsApplicationInstalled( const char *pchAppKey ) = 0;
|
|
|
|
/** Returns the number of applications available in the list */
|
|
virtual uint32_t GetApplicationCount() = 0;
|
|
|
|
/** Returns the key of the specified application. The index is at least 0 and is less than the return
|
|
* value of GetApplicationCount(). The buffer should be at least k_unMaxApplicationKeyLength in order to
|
|
* fit the key. */
|
|
virtual EVRApplicationError GetApplicationKeyByIndex( uint32_t unApplicationIndex, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
|
|
|
|
/** Returns the key of the application for the specified Process Id. The buffer should be at least
|
|
* k_unMaxApplicationKeyLength in order to fit the key. */
|
|
virtual EVRApplicationError GetApplicationKeyByProcessId( uint32_t unProcessId, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
|
|
|
|
/** Launches the application. The existing scene application will exit and then the new application will start.
|
|
* This call is not valid for dashboard overlay applications. */
|
|
virtual EVRApplicationError LaunchApplication( const char *pchAppKey ) = 0;
|
|
|
|
/** Launches the dashboard overlay application if it is not already running. This call is only valid for
|
|
* dashboard overlay applications. */
|
|
virtual EVRApplicationError LaunchDashboardOverlay( const char *pchAppKey ) = 0;
|
|
|
|
/** Identifies a running application. OpenVR can't always tell which process started in response
|
|
* to a URL. This function allows a URL handler (or the process itself) to identify the app key
|
|
* for the now running application. Passing a process ID of 0 identifies the calling process.
|
|
* The application must be one that's known to the system via a call to AddApplicationManifest. */
|
|
virtual EVRApplicationError IdentifyApplication( uint32_t unProcessId, const char *pchAppKey ) = 0;
|
|
|
|
/** Returns the process ID for an application. Return 0 if the application was not found or is not running. */
|
|
virtual uint32_t GetApplicationProcessId( const char *pchAppKey ) = 0;
|
|
|
|
/** Returns a string for an applications error */
|
|
virtual const char *GetApplicationsErrorNameFromEnum( EVRApplicationError error ) = 0;
|
|
|
|
// --------------- Application properties --------------- //
|
|
|
|
/** Returns a value for an application property. The required buffer size to fit this value will be returned. */
|
|
virtual uint32_t GetApplicationPropertyString( const char *pchAppKey, EVRApplicationProperty eProperty, char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError = nullptr ) = 0;
|
|
|
|
/** Returns a value for an application property. The required buffer size to fit this value will be returned. */
|
|
virtual bool GetApplicationPropertyBool( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) = 0;
|
|
|
|
/** Returns the application key for the home application. The buffer should be at least k_unMaxApplicationKeyLength bytes long. */
|
|
virtual EVRApplicationError GetHomeApplication( char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
|
|
|
|
/** Sets the application key for the home application */
|
|
virtual EVRApplicationError SetHomeApplication( const char *pchAppKey ) = 0;
|
|
|
|
/** Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
|
|
virtual EVRApplicationError SetApplicationAutoLaunch( const char *pchAppKey, bool bAutoLaunch ) = 0;
|
|
|
|
/** Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
|
|
virtual bool GetApplicationAutoLaunch( const char *pchAppKey ) = 0;
|
|
|
|
};
|
|
|
|
static const char * const IVRApplications_Version = "IVRApplications_001";
|
|
|
|
/** Returns the current IVRApplications pointer or NULL the interface could not be found. */
|
|
VR_INTERFACE vr::IVRApplications *VR_CALLTYPE VRApplications();
|
|
|
|
} // namespace vr
|
|
// ivrchaperone.h
|
|
namespace vr
|
|
{
|
|
|
|
#if defined(__linux__) || defined(__APPLE__)
|
|
// The 32-bit version of gcc has the alignment requirement for uint64 and double set to
|
|
// 4 meaning that even with #pragma pack(8) these types will only be four-byte aligned.
|
|
// The 64-bit version of gcc has the alignment requirement for these types set to
|
|
// 8 meaning that unless we use #pragma pack(4) our structures will get bigger.
|
|
// The 64-bit structure packing has to match the 32-bit structure packing for each platform.
|
|
#pragma pack( push, 4 )
|
|
#else
|
|
#pragma pack( push, 8 )
|
|
#endif
|
|
|
|
enum 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,
|
|
ChaperoneCalibrationState_Error_BaseStationUninitalized = 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_SoftBoundsInvalid = 203, // Soft bounds haven't been calibrated for the current tracking center
|
|
ChaperoneCalibrationState_Error_HardBoundsInvalid = 204, // Hard bounds haven't been calibrated for the current tracking center
|
|
};
|
|
|
|
/** SOFT BOUNDS ASSUMPTIONS
|
|
* Corners are in clockwise order.
|
|
* Tracking space center (0,0,0) is contained within the Soft Bounds.
|
|
* Angles of corners are between 25 and 155 degrees.
|
|
* Quadrilateral formed is convex.
|
|
* One side will run parallel to the X axis.
|
|
* Height of every corner is 0Y (on the floor). */
|
|
struct ChaperoneSoftBoundsInfo_t
|
|
{
|
|
HmdQuad_t quadCorners;
|
|
};
|
|
|
|
struct ChaperoneSeatedBoundsInfo_t
|
|
{
|
|
HmdVector3_t vSeatedHeadPosition;
|
|
HmdVector3_t vDeskEdgePositions[ 2 ];
|
|
};
|
|
|
|
/** HIGH LEVEL TRACKING SPACE ASSUMPTIONS:
|
|
* 0,0,0 is the preferred standing area center.
|
|
* 0Y is the floor height.
|
|
* -Z is the preferred forward facing direction. */
|
|
class IVRChaperone
|
|
{
|
|
public:
|
|
|
|
/** Get the current state of Chaperone calibration. This state can change at any time during a session due to physical base station changes. */
|
|
virtual ChaperoneCalibrationState GetCalibrationState() = 0;
|
|
|
|
/** Returns the 4 corner positions of the Soft Bounds (also know as Safe Zone and Play Space). */
|
|
virtual bool GetSoftBoundsInfo( ChaperoneSoftBoundsInfo_t *pInfo ) = 0;
|
|
|
|
/** Returns the quads representing the Hard Bounds (static physical obstacles). */
|
|
virtual bool GetHardBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
|
|
|
|
/** Returns the preferred seated position and front edge of their desk. */
|
|
virtual bool GetSeatedBoundsInfo( ChaperoneSeatedBoundsInfo_t *pInfo ) = 0;
|
|
|
|
/** Reload Chaperone data from the .vrchap file on disk. */
|
|
virtual void ReloadInfo( void ) = 0;
|
|
|
|
};
|
|
|
|
static const char * const IVRChaperone_Version = "IVRChaperone_002";
|
|
|
|
#pragma pack( pop )
|
|
|
|
}
|
|
// ivrcompositor.h
|
|
namespace vr
|
|
{
|
|
|
|
#if defined(__linux__) || defined(__APPLE__)
|
|
// The 32-bit version of gcc has the alignment requirement for uint64 and double set to
|
|
// 4 meaning that even with #pragma pack(8) these types will only be four-byte aligned.
|
|
// The 64-bit version of gcc has the alignment requirement for these types set to
|
|
// 8 meaning that unless we use #pragma pack(4) our structures will get bigger.
|
|
// The 64-bit structure packing has to match the 32-bit structure packing for each platform.
|
|
#pragma pack( push, 4 )
|
|
#else
|
|
#pragma pack( push, 8 )
|
|
#endif
|
|
|
|
/** Errors that can occur with the VR compositor */
|
|
enum VRCompositorError
|
|
{
|
|
VRCompositorError_None = 0,
|
|
VRCompositorError_IncompatibleVersion = 100,
|
|
VRCompositorError_DoNotHaveFocus = 101,
|
|
VRCompositorError_InvalidTexture = 102,
|
|
VRCompositorError_IsNotSceneApplication = 103,
|
|
};
|
|
|
|
|
|
/** Provides a single frame's timing information to the app */
|
|
struct Compositor_FrameTiming
|
|
{
|
|
uint32_t size; // sizeof(Compositor_FrameTiming)
|
|
double frameStart;
|
|
float frameVSync; // seconds from frame start
|
|
uint32_t droppedFrames;
|
|
uint32_t frameIndex;
|
|
vr::TrackedDevicePose_t pose;
|
|
|
|
float prediction;
|
|
|
|
float m_flFrameIntervalMs;
|
|
float m_flSceneRenderCpuMs;
|
|
float m_flSceneRenderGpuMs;
|
|
float m_flCompositorRenderCpuMs;
|
|
float m_flCompositorRenderGpuMs;
|
|
float m_flPresentCallCpuMs;
|
|
float m_flRunningStartMs;
|
|
};
|
|
|
|
|
|
#pragma pack( pop )
|
|
|
|
|
|
/** Allows the application to interact with the compositor */
|
|
class IVRCompositor
|
|
{
|
|
public:
|
|
/** Returns the last error that occurred in the compositor */
|
|
virtual uint32_t GetLastError( VR_OUT_STRING() char* pchBuffer, uint32_t unBufferSize ) = 0;
|
|
|
|
/** Turns vsync on or off on the compositor window */
|
|
virtual void SetVSync( bool bVSync ) = 0;
|
|
|
|
/** Returns true if vsync is enabled in the compositor window */
|
|
virtual bool GetVSync() = 0;
|
|
|
|
/** Sets gamma for the compositor window */
|
|
virtual void SetGamma( float fGamma ) = 0;
|
|
|
|
/** Returns the gamma for the compositor window */
|
|
virtual float GetGamma() = 0;
|
|
|
|
/** Returns pose(s) to use to render scene (and optionally poses predicted two frames out for gameplay). */
|
|
virtual VRCompositorError WaitGetPoses( VR_ARRAY_COUNT(unRenderPoseArrayCount) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
|
|
VR_ARRAY_COUNT(unGamePoseArrayCount) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) = 0;
|
|
|
|
/** Updated scene texture to display. If pBounds is NULL the entire texture will be used.
|
|
*
|
|
* OpenGL dirty state:
|
|
* glBindTexture
|
|
*/
|
|
virtual VRCompositorError Submit( Hmd_Eye eEye, GraphicsAPIConvention eTextureType, void* pTexture, const VRTextureBounds_t* pBounds ) = 0;
|
|
|
|
/** Clears the frame that was sent with the last call to Submit. This will cause the
|
|
* compositor to show the grid until Submit is called again. */
|
|
virtual void ClearLastSubmittedFrame() = 0;
|
|
|
|
/** Returns true if timing data is filled it. Sets oldest timing info if nFramesAgo is larger than the stored history.
|
|
* Be sure to set timing.size = sizeof(Compositor_FrameTiming) on struct passed in before calling this function. */
|
|
virtual bool GetFrameTiming( Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0 ) = 0;
|
|
|
|
/** Fades the view on the HMD to the specified color. The fade will take fSeconds, and the color values are between
|
|
* 0.0 and 1.0. This color is faded on top of the scene based on the alpha parameter. Removing the fade color instantly
|
|
* would be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ). */
|
|
virtual void FadeToColor( float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false ) = 0;
|
|
|
|
/** Fading the Grid in or out in fSeconds */
|
|
virtual void FadeGrid( float fSeconds, bool bFadeIn ) = 0;
|
|
|
|
/** Brings the compositor window to the front. This is useful for covering any other window that may be on the HMD
|
|
* and is obscuring the compositor window. */
|
|
virtual void CompositorBringToFront() = 0;
|
|
|
|
/** Pushes the compositor window to the back. This is useful for allowing other applications to draw directly to the HMD. */
|
|
virtual void CompositorGoToBack() = 0;
|
|
|
|
/** Tells the compositor process to clean up and exit. You do not need to call this function at shutdown. Under normal
|
|
* circumstances the compositor will manage its own life cycle based on what applications are running. */
|
|
virtual void CompositorQuit() = 0;
|
|
|
|
/** Return whether the compositor is fullscreen */
|
|
virtual bool IsFullscreen() = 0;
|
|
|
|
/** Sets tracking space returned by WaitGetPoses */
|
|
virtual void SetTrackingSpace( TrackingUniverseOrigin eOrigin ) = 0;
|
|
|
|
/** Gets current tracking space returned by WaitGetPoses */
|
|
virtual TrackingUniverseOrigin GetTrackingSpace() = 0;
|
|
|
|
/** Returns the process ID of the process that is currently rendering the scene */
|
|
virtual uint32_t GetCurrentSceneFocusProcess() = 0;
|
|
|
|
/** Returns true if the current process has the scene focus */
|
|
virtual bool CanRenderScene() = 0;
|
|
};
|
|
|
|
static const char * const IVRCompositor_Version = "IVRCompositor_007";
|
|
|
|
} // namespace vr
|
|
|
|
|
|
// ivrnotifications.h
|
|
namespace vr
|
|
{
|
|
|
|
#if defined(__linux__) || defined(__APPLE__)
|
|
// The 32-bit version of gcc has the alignment requirement for uint64 and double set to
|
|
// 4 meaning that even with #pragma pack(8) these types will only be four-byte aligned.
|
|
// The 64-bit version of gcc has the alignment requirement for these types set to
|
|
// 8 meaning that unless we use #pragma pack(4) our structures will get bigger.
|
|
// The 64-bit structure packing has to match the 32-bit structure packing for each platform.
|
|
#pragma pack( push, 4 )
|
|
#else
|
|
#pragma pack( push, 8 )
|
|
#endif
|
|
|
|
const char * const NotificationTypeFriendUpdate = "FriendUpdate";
|
|
|
|
// Used for passing graphic data
|
|
struct NotificationBitmap
|
|
{
|
|
void *bytes;
|
|
int32_t width;
|
|
int32_t height;
|
|
int32_t depth;
|
|
};
|
|
|
|
enum NotificationError_t
|
|
{
|
|
k_ENotificationError_OK = 0,
|
|
k_ENotificationError_Fail = 1,
|
|
k_eNotificationError_InvalidParam = 2,
|
|
};
|
|
|
|
static const uint32_t k_unNotificationTypeMaxSize = 16;
|
|
static const uint32_t k_unNotificationTextMaxSize = 128;
|
|
static const uint32_t k_unNotificationCatagoryMaxSize = 32;
|
|
|
|
/** The types of events that could be posted (and what the parameters mean for each event type) */
|
|
/*enum NotificationEventType
|
|
{
|
|
Notification_None = 0,
|
|
|
|
Notification_Dismissed = 101, // param1 = Device index
|
|
Notification_BeginInteraction = 102, // param1 = Device index
|
|
Notification_Scroll = 103, // param1 = Device index
|
|
Notification_ClickOn = 104, // param1 = Device index
|
|
Notification_ClickOff = 105, // param1 = Device index
|
|
};*/
|
|
|
|
/** An event posted by the server to all running applications */
|
|
/*struct NotificationEvent_t
|
|
{
|
|
NotificationEventType eventType;
|
|
int32_t x; // X coordinate in the notifications bitmap when the click happened
|
|
int32_t y; // Y coordinate in the notifications bitmap when the click happened
|
|
int32_t scroll_x; // X scrolling amount in the notifications bitmap coords
|
|
int32_t scroll_y; // Y scrolling amount in the notifications bitmap coords
|
|
uint32_t buttons; // Buttons pressed
|
|
|
|
float eventAgeSeconds;
|
|
};*/
|
|
|
|
typedef uint32_t VRNotificationId;
|
|
|
|
// This struct will be used for the history list of notifications
|
|
struct NotificationItem
|
|
{
|
|
VRNotificationId notificationId;
|
|
};
|
|
|
|
|
|
|
|
#pragma pack( pop )
|
|
|
|
/** Allows notification sources to interact with the VR system
|
|
This current interface is not yet implemented. Do not use yet. */
|
|
class IVRNotifications
|
|
{
|
|
public:
|
|
/** Returns the last error that occurred */
|
|
virtual uint32_t GetErrorString( NotificationError_t error, VR_OUT_STRING() char* pchBuffer, uint32_t unBufferSize ) = 0;
|
|
|
|
VR_METHOD_DESC( Create a new notification. )
|
|
virtual NotificationError_t CreateNotification( VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, char *strType, char *strText, char *strCategory, NotificationBitmap *photo, /* out */ vr::VRNotificationId *notificationId ) = 0;
|
|
|
|
VR_METHOD_DESC(Dismiss the notification)
|
|
virtual NotificationError_t DismissNotification( vr::VRNotificationId notificationId ) = 0;
|
|
|
|
};
|
|
|
|
static const char * const IVRNotifications_Version = "IVRNotifications_001";
|
|
|
|
} // namespace vr
|
|
|
|
|
|
// ivroverlay.h
|
|
namespace vr
|
|
{
|
|
|
|
/** The maximum length of an overlay key in bytes, counting the terminating null character. */
|
|
static const uint32_t k_unVROverlayMaxKeyLength = 128;
|
|
|
|
/** The maximum length of an overlay name in bytes, counting the terminating null character. */
|
|
static const uint32_t k_unVROverlayMaxNameLength = 128;
|
|
|
|
/** The maximum number of overlays that can exist in the system at one time. */
|
|
static const uint32_t k_unMaxOverlayCount = 32;
|
|
|
|
/** Types of input supported by VR Overlays */
|
|
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
|
|
};
|
|
|
|
/** Allows the caller to figure out which overlay transform getter to call. */
|
|
enum VROverlayTransformType
|
|
{
|
|
VROverlayTransform_Absolute = 0,
|
|
VROverlayTransform_TrackedDeviceRelative = 1,
|
|
VROverlayTransform_SystemOverlay = 2,
|
|
};
|
|
|
|
/** Overlay control settings */
|
|
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,
|
|
|
|
};
|
|
|
|
struct VROverlayIntersectionParams_t
|
|
{
|
|
HmdVector3_t vSource;
|
|
HmdVector3_t vDirection;
|
|
TrackingUniverseOrigin eOrigin;
|
|
};
|
|
|
|
struct VROverlayIntersectionResults_t
|
|
{
|
|
HmdVector3_t vPoint;
|
|
HmdVector3_t vNormal;
|
|
HmdVector2_t vUVs;
|
|
float fDistance;
|
|
};
|
|
|
|
class IVROverlay
|
|
{
|
|
public:
|
|
|
|
// ---------------------------------------------
|
|
// Overlay management methods
|
|
// ---------------------------------------------
|
|
|
|
/** Finds an existing overlay with the specified key. */
|
|
virtual VROverlayError FindOverlay( const char *pchOverlayKey, VROverlayHandle_t * pOverlayHandle ) = 0;
|
|
|
|
/** Creates a new named overlay. All overlays start hidden and with default settings. */
|
|
virtual VROverlayError CreateOverlay( const char *pchOverlayKey, const char *pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle ) = 0;
|
|
|
|
/** Destroys the specified overlay. When an application calls VR_Shutdown all overlays created by that app are
|
|
* automatically destroyed. */
|
|
virtual VROverlayError DestroyOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
|
|
|
|
/** Specify which overlay to use the high quality render path. This overlay will be composited in during the distortion pass which
|
|
* results in it drawing on top of everything else, but also at a higher quality as it samples the source texture directly rather than
|
|
* rasterizing into each eye's render texture first. Because if this, only one of these is supported at any given time. It is most useful
|
|
* for overlays that are expected to take up most of the user's view (e.g. streaming video). */
|
|
virtual VROverlayError SetHighQualityOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
|
|
|
|
/** Returns the overlay handle of the current overlay being rendered using the single high quality overlay render path.
|
|
* Otherwise it will return k_ulOverlayHandleInvalid. */
|
|
virtual vr::VROverlayHandle_t GetHighQualityOverlay() = 0;
|
|
|
|
/** Fills the provided buffer with the string key of the overlay. Returns the size of buffer required to store the key, including
|
|
* the terminating null character. k_unVROverlayMaxKeyLength will be enough bytes to fit the string. */
|
|
virtual uint32_t GetOverlayKey( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, VROverlayError *pError = 0L ) = 0;
|
|
|
|
/** Fills the provided buffer with the friendly name of the overlay. Returns the size of buffer required to store the key, including
|
|
* the terminating null character. k_unVROverlayMaxNameLength will be enough bytes to fit the string. */
|
|
virtual uint32_t GetOverlayName( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, VROverlayError *pError = 0L ) = 0;
|
|
|
|
/** Gets the raw image data from an overlay. Overlay image data is always returned as RGBA data, 4 bytes per pixel. If the buffer is not large enough, width and height
|
|
* will be set and VROverlayError_ArrayTooSmall is returned. */
|
|
virtual VROverlayError GetOverlayImageData( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight ) = 0;
|
|
|
|
/** returns a string that corresponds with the specified overlay error. The string will be the name
|
|
* of the error enum value for all valid error codes */
|
|
virtual const char *GetOverlayErrorNameFromEnum( VROverlayError error ) = 0;
|
|
|
|
|
|
// ---------------------------------------------
|
|
// Overlay rendering methods
|
|
// ---------------------------------------------
|
|
|
|
/** Specify flag setting for a given overlay */
|
|
virtual VROverlayError SetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled ) = 0;
|
|
|
|
/** Sets flag setting for a given overlay */
|
|
virtual VROverlayError GetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled ) = 0;
|
|
|
|
/** Sets the color tint of the overlay quad. Use 0.0 to 1.0 per channel. */
|
|
virtual VROverlayError SetOverlayColor( VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue ) = 0;
|
|
|
|
/** Gets the color tint of the overlay quad. */
|
|
virtual VROverlayError GetOverlayColor( VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue ) = 0;
|
|
|
|
/** Sets the alpha of the overlay quad. Use 1.0 for 100 percent opacity to 0.0 for 0 percent opacity. */
|
|
virtual VROverlayError SetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float fAlpha ) = 0;
|
|
|
|
/** Gets the alpha of the overlay quad. By default overlays are rendering at 100 percent alpha (1.0). */
|
|
virtual VROverlayError GetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float *pfAlpha ) = 0;
|
|
|
|
/** Sets the gamma of the overlay quad. Use 2.2 when providing a texture in linear color space. */
|
|
virtual VROverlayError SetOverlayGamma( VROverlayHandle_t ulOverlayHandle, float fGamma ) = 0;
|
|
|
|
/** Gets the gamma of the overlay quad. Be default overlays are rendered with 1.0 gamma. */
|
|
virtual VROverlayError GetOverlayGamma( VROverlayHandle_t ulOverlayHandle, float *pfGamma ) = 0;
|
|
|
|
/** Sets the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
|
|
virtual VROverlayError SetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float fWidthInMeters ) = 0;
|
|
|
|
/** Returns the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
|
|
virtual VROverlayError GetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters ) = 0;
|
|
|
|
/** For high-quality curved overlays only, sets the distance range in meters from the overlay used to automatically curve
|
|
* the surface around the viewer. Min is distance is when the surface will be most curved. Max is when least curved. */
|
|
virtual VROverlayError SetOverlayAutoCurveDistanceRangeInMeters( VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters ) = 0;
|
|
|
|
/** For high-quality curved overlays only, gets the distance range in meters from the overlay used to automatically curve
|
|
* the surface around the viewer. Min is distance is when the surface will be most curved. Max is when least curved. */
|
|
virtual VROverlayError GetOverlayAutoCurveDistanceRangeInMeters( VROverlayHandle_t ulOverlayHandle, float *pfMinDistanceInMeters, float *pfMaxDistanceInMeters ) = 0;
|
|
/** Sets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
|
|
virtual VROverlayError SetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, const VRTextureBounds_t *pOverlayTextureBounds ) = 0;
|
|
|
|
/** Gets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
|
|
virtual VROverlayError GetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t *pOverlayTextureBounds ) = 0;
|
|
|
|
/** Returns the transform type of this overlay. */
|
|
virtual VROverlayError GetOverlayTransformType( VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType ) = 0;
|
|
|
|
/** Sets the transform to absolute tracking origin. */
|
|
virtual VROverlayError SetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) = 0;
|
|
|
|
/** Gets the transform if it is absolute. Returns an error if the transform is some other type. */
|
|
virtual VROverlayError GetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin *peTrackingOrigin, HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) = 0;
|
|
|
|
/** Sets the transform to relative to the transform of the specified tracked device. */
|
|
virtual VROverlayError SetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, const HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) = 0;
|
|
|
|
/** Gets the transform if it is relative to a tracked device. Returns an error if the transform is some other type. */
|
|
virtual VROverlayError GetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) = 0;
|
|
|
|
/** Shows the VR overlay. For dashboard overlays, only the Dashboard Manager is allowed to call this. */
|
|
virtual VROverlayError ShowOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
|
|
|
|
/** Hides the VR overlay. For dashboard overlays, only the Dashboard Manager is allowed to call this. */
|
|
virtual VROverlayError HideOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
|
|
|
|
/** Returns true if the overlay is visible. */
|
|
virtual bool IsOverlayVisible( VROverlayHandle_t ulOverlayHandle ) = 0;
|
|
|
|
|
|
// ---------------------------------------------
|
|
// Overlay input methods
|
|
// ---------------------------------------------
|
|
|
|
/** Returns true and fills the event with the next event on the overlay's event queue, if there is one.
|
|
* If there are no events this method returns false */
|
|
virtual bool PollNextOverlayEvent( VROverlayHandle_t ulOverlayHandle, VREvent_t *pEvent ) = 0;
|
|
|
|
/** Returns the current input settings for the specified overlay. */
|
|
virtual VROverlayError GetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod ) = 0;
|
|
|
|
/** Sets the input settings for the specified overlay. */
|
|
virtual VROverlayError SetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod ) = 0;
|
|
|
|
/** Gets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
|
|
* typically the size of the underlying UI in pixels. */
|
|
virtual VROverlayError GetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvecMouseScale ) = 0;
|
|
|
|
/** Sets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
|
|
* typically the size of the underlying UI in pixels. */
|
|
virtual VROverlayError SetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvecMouseScale ) = 0;
|
|
|
|
/** Computes the overlay-space pixel coordinates of where the ray intersects the overlay with the
|
|
* specified settings. Returns false if there is no intersection. */
|
|
virtual bool ComputeOverlayIntersection( VROverlayHandle_t ulOverlayHandle, const VROverlayIntersectionParams_t *pParams, VROverlayIntersectionResults_t *pResults ) = 0;
|
|
|
|
/** Processes mouse input from the specified controller as though it were a mouse pointed at a compositor overlay with the
|
|
* specified settings. The controller is treated like a laser pointer on the -z axis. The point where the laser pointer would
|
|
* intersect with the overlay is the mouse position, the trigger is left mouse, and the track pad is right mouse.
|
|
*
|
|
* Return true if the controller is pointed at the overlay and an event was generated. */
|
|
virtual bool HandleControllerOverlayInteractionAsMouse( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex ) = 0;
|
|
|
|
// ---------------------------------------------
|
|
// Overlay texture methods
|
|
// ---------------------------------------------
|
|
|
|
/** Texture to draw for the overlay. IVRCompositor::SetGraphicsDevice must be called before
|
|
* this function. This function can only be called by the overlay's renderer process.
|
|
*
|
|
* If pBounds is NULL the entire texture will be used.
|
|
*
|
|
* OpenGL dirty state:
|
|
* glBindTexture
|
|
*/
|
|
virtual VROverlayError SetOverlayTexture( VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void* pTexture ) = 0;
|
|
|
|
/** Use this to tell the overlay system to release the texture set for this overlay. */
|
|
virtual VROverlayError ClearOverlayTexture( VROverlayHandle_t ulOverlayHandle ) = 0;
|
|
|
|
/** Separate interface for providing the data as a stream of bytes, but there is an upper bound on data
|
|
* that can be sent. This function can only be called by the overlay's renderer process. */
|
|
virtual VROverlayError SetOverlayRaw( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth ) = 0;
|
|
|
|
/** Separate interface for providing the image through a filename: can be png or jpg, and should not be bigger than 1920x1080.
|
|
* This function can only be called by the overlay's renderer process */
|
|
virtual VROverlayError SetOverlayFromFile( VROverlayHandle_t ulOverlayHandle, const char *pchFilePath ) = 0;
|
|
|
|
// ----------------------------------------------
|
|
// Dashboard Overlay Methods
|
|
// ----------------------------------------------
|
|
|
|
/** Creates a dashboard overlay and returns its handle */
|
|
virtual VROverlayError CreateDashboardOverlay( const char *pchOverlayKey, const char *pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t *pThumbnailHandle ) = 0;
|
|
|
|
/** Returns true if the dashboard is visible */
|
|
virtual bool IsDashboardVisible() = 0;
|
|
|
|
/** returns true if the dashboard is visible and the specified overlay is the active system Overlay */
|
|
virtual bool IsActiveDashboardOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
|
|
|
|
/** Sets the dashboard overlay to only appear when the specified process ID has scene focus */
|
|
virtual VROverlayError SetDashboardOverlaySceneProcess( VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId ) = 0;
|
|
|
|
/** Gets the process ID that this dashboard overlay requires to have scene focus */
|
|
virtual VROverlayError GetDashboardOverlaySceneProcess( VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId ) = 0;
|
|
|
|
/** Shows the dashboard. */
|
|
virtual void ShowDashboard( const char *pchOverlayToShow ) = 0;
|
|
|
|
};
|
|
|
|
static const char * const IVROverlay_Version = "IVROverlay_004";
|
|
|
|
} // namespace vr
|
|
// ivrrendermodels.h
|
|
namespace vr
|
|
{
|
|
|
|
class IVRRenderModels
|
|
{
|
|
public:
|
|
|
|
|
|
/** Loads and returns a render model for use in the application. pchRenderModelName should be a render model name
|
|
* from the Prop_RenderModelName_String property or an absolute path name to a render model on disk.
|
|
*
|
|
* The resulting render model is valid until VR_Shutdown() is called or until FreeRenderModel() is called. When the
|
|
* application is finished with the render model it should call FreeRenderModel() to free the memory associated
|
|
* with the model.
|
|
*
|
|
* The method returns false if the model could not be loaded.
|
|
*
|
|
* The API expects that this function will be called at startup or when tracked devices are connected and disconnected.
|
|
* If it is called every frame it will hurt performance.
|
|
*/
|
|
virtual bool LoadRenderModel( const char *pchRenderModelName, RenderModel_t *pRenderModel ) = 0;
|
|
|
|
/** Frees a previously returned render model */
|
|
virtual void FreeRenderModel( RenderModel_t *pRenderModel ) = 0;
|
|
|
|
/** Use this to get the names of available render models. Index does not correlate to a tracked device index, but
|
|
* is only used for iterating over all available render models. If the index is out of range, this function will return 0.
|
|
* Otherwise, it will return the size of the buffer required for the name. */
|
|
virtual uint32_t GetRenderModelName( uint32_t unRenderModelIndex, VR_OUT_STRING() char *pchRenderModelName, uint32_t unRenderModelNameLen ) = 0;
|
|
|
|
/** Returns the number of available render models. */
|
|
virtual uint32_t GetRenderModelCount() = 0;
|
|
|
|
|
|
};
|
|
|
|
static const char * const IVRRenderModels_Version = "IVRRenderModels_001";
|
|
|
|
}
|
|
|
|
// ivrcontrolpanel.h
|
|
namespace vr
|
|
{
|
|
|
|
class IVRControlPanel;
|
|
#if 0
|
|
class IVRControlPanel
|
|
{
|
|
public:
|
|
|
|
// ------------------------------------
|
|
// Driver enumeration methods
|
|
// ------------------------------------
|
|
|
|
/** the number of active drivers */
|
|
virtual uint32_t GetDriverCount() = 0;
|
|
|
|
/** The ID of the specified driver as a UTF-8 string. Returns the length of the ID in bytes. If
|
|
* the buffer is not large enough to fit the ID an empty string will be returned. In general, 128 bytes
|
|
* will be enough to fit any ID. */
|
|
virtual uint32_t GetDriverId( uint32_t unDriverIndex, char *pchBuffer, uint32_t unBufferLen ) = 0;
|
|
|
|
// ------------------------------------
|
|
// Display Enumeration Methods
|
|
// ------------------------------------
|
|
|
|
/** the number of active displays on the specified driver */
|
|
virtual uint32_t GetDriverDisplayCount( const char *pchDriverId ) = 0;
|
|
|
|
/** The ID of the specified display in the specified driver as a UTF-8 string. Returns the
|
|
* length of the ID in bytes. If the buffer is not large enough to fit the ID an empty
|
|
* string will be returned. In general, 128 bytes will be enough to fit any ID. */
|
|
virtual uint32_t GetDriverDisplayId( const char *pchDriverId, uint32_t unDisplayIndex, char *pchBuffer, uint32_t unBufferLen ) = 0;
|
|
|
|
// ------------------------------------
|
|
// Display Detail Methods
|
|
// ------------------------------------
|
|
|
|
/** The model name of the specified driver in the specified driver as a UTF-8 string. Returns the
|
|
* length of the model name in bytes. If the buffer is not large enough to fit the model name an empty
|
|
* string will be returned. In general, 128 bytes will be enough to fit any model name. Returns 0 if
|
|
* the display or driver was not found. */
|
|
virtual uint32_t GetDriverDisplayModelNumber( const char *pchDriverId, const char *pchDisplayId, char *pchBuffer, uint32_t unBufferLen ) = 0;
|
|
|
|
/** The serial number of the specified driver in the specified driver as a UTF-8 string. Returns the
|
|
* length of the serial number in bytes. If the buffer is not large enough to fit the serial number an empty
|
|
* string will be returned. In general, 128 bytes will be enough to fit any model name. Returns 0 if
|
|
* the display or driver was not found. */
|
|
virtual uint32_t GetDriverDisplaySerialNumber( const char *pchDriverId, const char *pchDisplayId, char *pchBuffer, uint32_t unBufferLen ) = 0;
|
|
|
|
/** Returns the IVRSystem interface for the current display that matches the specified version number.
|
|
* This is usually unnecessary and the return value of VR_Init can be used without calling this method. */
|
|
VR_IGNOREATTR()
|
|
virtual class IVRSystem *GetCurrentDisplayInterface( const char *pchHmdInterfaceVersion ) = 0;
|
|
|
|
// ------------------------------------
|
|
// Shared Resource Methods
|
|
// ------------------------------------
|
|
|
|
/** Loads the specified resource into the provided buffer if large enough.
|
|
* Returns the size in bytes of the buffer required to hold the specified resource. */
|
|
virtual uint32_t LoadSharedResource( const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen ) = 0;
|
|
|
|
// ------------------------------------
|
|
// IPD Methods
|
|
// ------------------------------------
|
|
|
|
/** Gets the current IPD (Interpupillary Distance) in meters. */
|
|
virtual float GetIPD() = 0;
|
|
|
|
/** Sets the current IPD (Interpupillary Distance) in meters. */
|
|
virtual void SetIPD( float fIPD ) = 0;
|
|
|
|
// ------------------------------------
|
|
// Compositor Methods
|
|
// ------------------------------------
|
|
|
|
/** Returns the IVRCompositor interface that matches the specified interface version. This will only
|
|
* return the compositor interface if it has already been initialized by the current process. */
|
|
virtual class vr::IVRCompositor *GetCurrentCompositorInterface( const char *pchInterfaceVersion ) = 0;
|
|
|
|
// ------------------------------------
|
|
// Process control Methods
|
|
// ------------------------------------
|
|
|
|
/** Tells the specified OpenVR process to quit. If the process ID is 0, all processes will be told to quit,
|
|
* ending with the process submitting the request. Returns false if the request could not be sent. */
|
|
virtual bool QuitProcess( uint32_t pidProcessToQuit ) = 0;
|
|
|
|
/** Starts a process and returns the PID or 0 if the process failed to start. */
|
|
virtual uint32_t StartVRProcess( const char *pchExecutable, const char **pchArguments, uint32_t unArgumentCount, const char *pchWorkingDirectory) = 0;
|
|
|
|
/** Sets the master process for OpenVR. When the master process exits VRServer will send quit messages to every other process
|
|
* to start the shutdown process */
|
|
virtual void SetMasterProcessToThis() = 0;
|
|
|
|
|
|
};
|
|
|
|
static const char * const IVRControlPanel_Version = "IVRControlPanel_001";
|
|
#endif
|
|
|
|
}// End
|
|
|
|
#endif // _OPENVR_API
|
|
|
|
|
|
namespace vr
|
|
{
|
|
|
|
/** Finds the active installation of the VR API and initializes it. The provided path must be absolute
|
|
* or relative to the current working directory. These are the local install versions of the equivalent
|
|
* functions in steamvr.h and will work without a local Steam install.
|
|
*
|
|
* This path is to the "root" of the VR API install. That's the directory with
|
|
* the "drivers" directory and a platform (i.e. "win32") directory in it, not the directory with the DLL itself.
|
|
*/
|
|
VR_INTERFACE vr::IVRSystem *VR_CALLTYPE VR_Init( vr::HmdError *peError, vr::EVRApplicationType eApplicationType = vr::VRApplication_Scene );
|
|
|
|
/** unloads vrclient.dll. Any interface pointers from the interface are
|
|
* invalid after this point */
|
|
VR_INTERFACE void VR_CALLTYPE VR_Shutdown();
|
|
|
|
/** Returns true if there is an HMD attached. This check is as lightweight as possible and
|
|
* can be called outside of VR_Init/VR_Shutdown. It should be used when an application wants
|
|
* to know if initializing VR is a possibility but isn't ready to take that step yet.
|
|
*/
|
|
VR_INTERFACE bool VR_CALLTYPE VR_IsHmdPresent();
|
|
|
|
/** Returns true if the OpenVR runtime is installed. */
|
|
VR_INTERFACE bool VR_CALLTYPE VR_IsRuntimeInstalled();
|
|
|
|
/** Returns the string version of an HMD error. This function may be called outside of VR_Init()/VR_Shutdown(). */
|
|
VR_INTERFACE const char *VR_CALLTYPE VR_GetStringForHmdError( vr::HmdError error );
|
|
|
|
/** Returns the interface of the specified version. This method must be called after VR_Init. The
|
|
* pointer returned is valid until VR_Shutdown is called.
|
|
*/
|
|
VR_INTERFACE void *VR_CALLTYPE VR_GetGenericInterface( const char *pchInterfaceVersion, vr::HmdError *peError );
|
|
|
|
/** Returns the current IVRSystem pointer or NULL if VR_Init has not been called successfully */
|
|
VR_INTERFACE vr::IVRSystem *VR_CALLTYPE VRSystem();
|
|
|
|
/** Returns the current IVRChaperone pointer or NULL the interface could not be found. */
|
|
VR_INTERFACE vr::IVRChaperone *VR_CALLTYPE VRChaperone();
|
|
|
|
/** Returns the current IVRCompositor pointer or NULL the interface could not be found. */
|
|
VR_INTERFACE vr::IVRCompositor *VR_CALLTYPE VRCompositor();
|
|
|
|
/** Returns the current IVROverlay pointer or NULL the interface could not be found. */
|
|
VR_INTERFACE vr::IVROverlay *VR_CALLTYPE VROverlay();
|
|
|
|
/** Returns the current IVRRenderModels pointer or NULL the interface could not be found. */
|
|
VR_INTERFACE vr::IVRRenderModels *VR_CALLTYPE VRRenderModels();
|
|
|
|
/** Returns the current IVRControlPanel pointer or NULL the interface could not be found. */
|
|
VR_INTERFACE vr::IVRControlPanel *VR_CALLTYPE VRControlPanel();
|
|
|
|
|
|
}
|