//========= Copyright 2017-2018, HTC Corporation. All rights reserved. =========== // // Purpose: This file contains C#/managed code bindings for the OpenVR interfaces // //================================================================================ using System; using System.Runtime.InteropServices; using HVR; namespace HVR { [StructLayout(LayoutKind.Sequential)] public struct IHVRSystem { [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _GetRecommendedRenderTargetSize(ref uint pnWidth, ref uint pnHeight); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetRecommendedRenderTargetSize GetRecommendedRenderTargetSize; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate HVRMatrix44_t _GetProjectionMatrix(EHVREye eEye, float fNearZ, float fFarZ, EHVRTextureType eProjType); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetProjectionMatrix GetProjectionMatrix; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _GetProjectionRaw(EHVREye eEye, ref float pfLeft, ref float pfRight, ref float pfTop, ref float pfBottom); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetProjectionRaw GetProjectionRaw; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate HVRMatrix34_t _GetEyeToHeadTransform(EHVREye eEye); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetEyeToHeadTransform GetEyeToHeadTransform; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetTimeSinceLastVsync(ref float pfSecondsSinceLastVsync, ref ulong pulFrameCounter); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetTimeSinceLastVsync GetTimeSinceLastVsync; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _GetDeviceToAbsoluteTrackingPose(EHVRTrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, [In, Out] HVRTrackedDevicePose_t[] pTrackedDevicePoseArray, uint unTrackedDevicePoseArrayCount); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetDeviceToAbsoluteTrackingPose GetDeviceToAbsoluteTrackingPose; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate HVRMatrix34_t _GetRawZeroPoseToStandingAbsoluteTrackingPose(); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetRawZeroPoseToStandingAbsoluteTrackingPose GetRawZeroPoseToStandingAbsoluteTrackingPose; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate uint _GetTrackedDeviceIndexForControllerRole(EHVRTrackedControllerRole unDeviceType); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetTrackedDeviceIndexForControllerRole GetTrackedDeviceIndexForControllerRole; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackedControllerRole _GetControllerRoleForTrackedDeviceIndex(uint unDeviceIndex); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetControllerRoleForTrackedDeviceIndex GetControllerRoleForTrackedDeviceIndex; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackedDeviceClass _GetTrackedDeviceClass(uint unDeviceIndex); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetTrackedDeviceClass GetTrackedDeviceClass; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _IsTrackedDeviceConnected(uint unDeviceIndex); [MarshalAs(UnmanagedType.FunctionPtr)] internal _IsTrackedDeviceConnected IsTrackedDeviceConnected; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetBoolTrackedDeviceProperty(uint unDeviceIndex, EHVRTrackedDeviceProperty prop, ref EHVRTrackedPropertyError pError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetBoolTrackedDeviceProperty GetBoolTrackedDeviceProperty; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate float _GetFloatTrackedDeviceProperty(uint unDeviceIndex, EHVRTrackedDeviceProperty prop, ref EHVRTrackedPropertyError pError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetFloatTrackedDeviceProperty GetFloatTrackedDeviceProperty; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate int _GetInt32TrackedDeviceProperty(uint unDeviceIndex, EHVRTrackedDeviceProperty prop, ref EHVRTrackedPropertyError pError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetInt32TrackedDeviceProperty GetInt32TrackedDeviceProperty; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate ulong _GetUint64TrackedDeviceProperty(uint unDeviceIndex, EHVRTrackedDeviceProperty prop, ref EHVRTrackedPropertyError pError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetUint64TrackedDeviceProperty GetUint64TrackedDeviceProperty; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate uint _GetStringTrackedDeviceProperty(uint unDeviceIndex, EHVRTrackedDeviceProperty prop, System.Text.StringBuilder pchValue, uint unBufferSize, ref EHVRTrackedPropertyError pError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetStringTrackedDeviceProperty GetStringTrackedDeviceProperty; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate HVRMatrix34_t _GetMatrix34TrackedDeviceProperty(uint unDeviceIndex, EHVRTrackedDeviceProperty prop, ref EHVRTrackedPropertyError pError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetMatrix34TrackedDeviceProperty GetMatrix34TrackedDeviceProperty; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _PollNextEvent(ref HVREvent_t pEvent, uint uncbVREvent); [MarshalAs(UnmanagedType.FunctionPtr)] internal _PollNextEvent PollNextEvent; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate HVRHiddenAreaMesh_t _GetHiddenAreaMesh(EHVREye eEye, EHVRHiddenAreaMeshType type); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetHiddenAreaMesh GetHiddenAreaMesh; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetControllerState(uint unControllerDeviceIndex, ref HVRControllerState_t pControllerState); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetControllerState GetControllerState; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetControllerStateWithPose(EHVRTrackingUniverseOrigin eOrigin, uint unControllerDeviceIndex, ref HVRControllerState_t pControllerState, uint unControllerStateSize, ref HVRTrackedDevicePose_t pTrackedDevicePose); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetControllerStateWithPose GetControllerStateWithPose; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _TriggerHapticPulse(uint unControllerDeviceIndex, uint unAxisId, char usDurationMicroSec); [MarshalAs(UnmanagedType.FunctionPtr)] internal _TriggerHapticPulse TriggerHapticPulse; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _IsInputFocusCapturedByAnotherProcess(); [MarshalAs(UnmanagedType.FunctionPtr)] internal _IsInputFocusCapturedByAnotherProcess IsInputFocusCapturedByAnotherProcess; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate HVRChaperoneCalibrationState _GetCalibrationState(); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetCalibrationState GetCalibrationState; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetPlayAreaSize(ref float pSizeX, ref float pSizeZ); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetPlayAreaSize GetPlayAreaSize; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetPlayAreaRect(ref HVRQuad_t rect); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetPlayAreaRect GetPlayAreaRect; } [StructLayout(LayoutKind.Sequential)] public struct IHVRCompositor { [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _SetTrackingSpace(EHVRTrackingUniverseOrigin eTrackingOrigin); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetTrackingSpace SetTrackingSpace; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackingUniverseOrigin _GetTrackingSpace(); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetTrackingSpace GetTrackingSpace; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRCompositorError _WaitGetPoses([In, Out] HVRTrackedDevicePose_t[] pRenderPoseArray, uint unRenderPoseArrayCount, [In, Out] HVRTrackedDevicePose_t[] pGamePoseArray, uint unGamePoseArrayCount); [MarshalAs(UnmanagedType.FunctionPtr)] internal _WaitGetPoses WaitGetPoses; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRCompositorError _GetLastPoses([In, Out] HVRTrackedDevicePose_t[] pRenderPoseArray, uint unRenderPoseArrayCount, [In, Out] HVRTrackedDevicePose_t[] pGamePoseArray, uint unGamePoseArrayCount); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetLastPoses GetLastPoses; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRCompositorError _Submit(EHVREye eEye, ref HVRTexture_t pTexture, ref HVRTextureBounds_t pBounds, EHVRSubmitFlags nSubmitFlags); [MarshalAs(UnmanagedType.FunctionPtr)] internal _Submit Submit; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _PostPresentHandoff(); [MarshalAs(UnmanagedType.FunctionPtr)] internal _PostPresentHandoff PostPresentHandoff; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _FadeToColor(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground); [MarshalAs(UnmanagedType.FunctionPtr)] internal _FadeToColor FadeToColor; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _CanRenderScene(); [MarshalAs(UnmanagedType.FunctionPtr)] internal _CanRenderScene CanRenderScene; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _SuspendRendering(bool bSuspend); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SuspendRendering SuspendRendering; } [StructLayout(LayoutKind.Sequential)] public struct IHVROverlay { [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _FindOverlay(string pchOverlayKey, ref ulong pOverlayHandle); [MarshalAs(UnmanagedType.FunctionPtr)] internal _FindOverlay FindOverlay; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _CreateOverlay(string pchOverlayKey, string pchOverlayFriendlyName, ref ulong pOverlayHandle); [MarshalAs(UnmanagedType.FunctionPtr)] internal _CreateOverlay CreateOverlay; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _DestroyOverlay(ulong ulOverlayHandle); [MarshalAs(UnmanagedType.FunctionPtr)] internal _DestroyOverlay DestroyOverlay; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetHighQualityOverlay(ulong ulOverlayHandle); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetHighQualityOverlay SetHighQualityOverlay; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate ulong _GetHighQualityOverlay(); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetHighQualityOverlay GetHighQualityOverlay; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate uint _GetOverlayKey(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EHVROverlayError pError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayKey GetOverlayKey; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate uint _GetOverlayName(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EHVROverlayError pError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayName GetOverlayName; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlayImageData(ulong ulOverlayHandle, IntPtr pvBuffer, uint unBufferSize, ref uint punWidth, ref uint punHeight); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayImageData GetOverlayImageData; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate IntPtr _GetOverlayErrorNameFromEnum(EHVROverlayError error); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayErrorNameFromEnum GetOverlayErrorNameFromEnum; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayRenderingPid(ulong ulOverlayHandle, uint unPID); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayRenderingPid SetOverlayRenderingPid; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate uint _GetOverlayRenderingPid(ulong ulOverlayHandle); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayRenderingPid GetOverlayRenderingPid; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayFlag(ulong ulOverlayHandle, HVROverlayFlags eOverlayFlag, bool bEnabled); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayFlag SetOverlayFlag; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlayFlag(ulong ulOverlayHandle, HVROverlayFlags eOverlayFlag, ref bool bEnabled); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayFlag GetOverlayFlag; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayColor(ulong ulOverlayHandle, float fRed, float fGreen, float fBlue); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayColor SetOverlayColor; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlayColor(ulong ulOverlayHandle, ref float pfRed, ref float pfGreen, ref float pfBlue); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayColor GetOverlayColor; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayAlpha(ulong ulOverlayHandle, float fAlpha); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayAlpha SetOverlayAlpha; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlayAlpha(ulong ulOverlayHandle, ref float pfAlpha); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayAlpha GetOverlayAlpha; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayTexelAspect(ulong ulOverlayHandle, float fTexelAspect); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayTexelAspect SetOverlayTexelAspect; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlayTexelAspect(ulong ulOverlayHandle, ref float pfTexelAspect); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayTexelAspect GetOverlayTexelAspect; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlaySortOrder(ulong ulOverlayHandle, uint unSortOrder); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlaySortOrder SetOverlaySortOrder; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlaySortOrder(ulong ulOverlayHandle, ref uint punSortOrder); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlaySortOrder GetOverlaySortOrder; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayWidthInMeters(ulong ulOverlayHandle, float fWidthInMeters); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayWidthInMeters SetOverlayWidthInMeters; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlayWidthInMeters(ulong ulOverlayHandle, ref float pfWidthInMeters); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayWidthInMeters GetOverlayWidthInMeters; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayAutoCurveDistanceRangeInMeters SetOverlayAutoCurveDistanceRangeInMeters; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle, ref float fMinDistanceInMeters, ref float fMaxDistanceInMeters); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayAutoCurveDistanceRangeInMeters GetOverlayAutoCurveDistanceRangeInMeters; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayTextureBounds(ulong ulOverlayHandle, ref HVRTextureBounds_t pOverlayTextureBounds); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayTextureBounds SetOverlayTextureBounds; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlayTextureBounds(ulong ulOverlayHandle, ref HVRTextureBounds_t pOverlayTextureBounds); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayTextureBounds GetOverlayTextureBounds; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlayTransformType(ulong ulOverlayHandle, ref HVROverlayTransformType peTransformType); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayTransformType GetOverlayTransformType; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayTransformAbsolute(ulong ulOverlayHandle, EHVRTrackingUniverseOrigin eTrackingOrigin, ref HVRMatrix34_t pmatTrackingOriginToOverlayTransform); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayTransformAbsolute SetOverlayTransformAbsolute; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlayTransformAbsolute(ulong ulOverlayHandle, ref EHVRTrackingUniverseOrigin peTrackingOrigin, ref HVRMatrix34_t pmatTrackingOriginToOverlayTransform); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayTransformAbsolute GetOverlayTransformAbsolute; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, uint unTrackedDevice, ref HVRMatrix34_t pmatTrackedDeviceToOverlayTransform); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayTransformTrackedDeviceRelative SetOverlayTransformTrackedDeviceRelative; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, ref uint punTrackedDevice, ref HVRMatrix34_t pmatTrackedDeviceToOverlayTransform); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayTransformTrackedDeviceRelative GetOverlayTransformTrackedDeviceRelative; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, uint unDeviceIndex, string pchComponentName); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayTransformTrackedDeviceComponent SetOverlayTransformTrackedDeviceComponent; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, ref uint punDeviceIndex, string pchComponentName, uint unComponentNameSize); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayTransformTrackedDeviceComponent GetOverlayTransformTrackedDeviceComponent; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _ShowOverlay(ulong ulOverlayHandle); [MarshalAs(UnmanagedType.FunctionPtr)] internal _ShowOverlay ShowOverlay; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _HideOverlay(ulong ulOverlayHandle); [MarshalAs(UnmanagedType.FunctionPtr)] internal _HideOverlay HideOverlay; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _IsOverlayVisible(ulong ulOverlayHandle); [MarshalAs(UnmanagedType.FunctionPtr)] internal _IsOverlayVisible IsOverlayVisible; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayTexture(ulong ulOverlayHandle, ref HVRTexture_t pTexture); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayTexture SetOverlayTexture; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _ClearOverlayTexture(ulong ulOverlayHandle); [MarshalAs(UnmanagedType.FunctionPtr)] internal _ClearOverlayTexture ClearOverlayTexture; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayRaw(ulong ulOverlayHandle, IntPtr pvBuffer, uint unWidth, uint unHeight, uint unDepth); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayRaw SetOverlayRaw; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayFromFile(ulong ulOverlayHandle, string pchFilePath); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayFromFile SetOverlayFromFile; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlayTexture(ulong ulOverlayHandle, ref IntPtr pNativeTextureHandle, IntPtr pNativeTextureRef, ref uint pWidth, ref uint pHeight, ref uint pNativeFormat, ref EHVRTextureType pAPI, ref EHVRColorSpace pColorSpace); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayTexture GetOverlayTexture; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _GetOverlayTextureSize(ulong ulOverlayHandle, ref uint pWidth, ref uint pHeight); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayTextureSize GetOverlayTextureSize; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayStereoTexture(ulong ulOverlayHandle, ref HVRTexture_t pTexture, EHVREye eye); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayStereoTexture SetOverlayStereoTexture; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayStereoMode(ulong ulOverlayHandle, bool bEnabled); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayStereoMode SetOverlayStereoMode; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayStereoTextureBounds(ulong ulOverlayHandle, ref HVRTextureBounds_t pOverlayTextureBounds, EHVREye eye); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayStereoTextureBounds SetOverlayStereoTextureBounds; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetOverlayTextureUpsideDownFlag(ulong ulOverlayHandle, bool flag); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetOverlayTextureUpsideDownFlag SetOverlayTextureUpsideDownFlag; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _CreateDesktopCaptureOverlay(uint targetHandle); [MarshalAs(UnmanagedType.FunctionPtr)] internal _CreateDesktopCaptureOverlay CreateDesktopCaptureOverlay; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _DestroyDesktopCaptureOverlay(uint targetHandle); [MarshalAs(UnmanagedType.FunctionPtr)] internal _DestroyDesktopCaptureOverlay DestroyDesktopCaptureOverlay; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetDesktopCaptureOverlayWidth(uint targetHandle, float width); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetDesktopCaptureOverlayWidth SetDesktopCaptureOverlayWidth; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetDesktopCaptureOverlayAbsolutePose(uint targetHandle, ref HVRMatrix34_t pmatTrackedDeviceToOverlayTransform); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetDesktopCaptureOverlayAbsolutePose SetDesktopCaptureOverlayAbsolutePose; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVROverlayError _SetDesktopCaptureOverlayCurveDistance(uint targetHandle, float minDist, float maxDist); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetDesktopCaptureOverlayCurveDistance SetDesktopCaptureOverlayCurveDistance; } [StructLayout(LayoutKind.Sequential)] public struct IHVRRenderModels { [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRRenderModelError _LoadRenderModel_Async(string pchRenderModelName, ref IntPtr ppRenderModel); [MarshalAs(UnmanagedType.FunctionPtr)] internal _LoadRenderModel_Async LoadRenderModel_Async; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _FreeRenderModel(IntPtr pRenderModel); [MarshalAs(UnmanagedType.FunctionPtr)] internal _FreeRenderModel FreeRenderModel; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRRenderModelError _LoadTexture_Async(int textureId, ref IntPtr ppTexture); [MarshalAs(UnmanagedType.FunctionPtr)] internal _LoadTexture_Async LoadTexture_Async; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _FreeTexture(IntPtr pTexture); [MarshalAs(UnmanagedType.FunctionPtr)] internal _FreeTexture FreeTexture; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRRenderModelError _LoadTextureD3D11_Async(int textureId, IntPtr pD3D11Device, ref IntPtr ppD3D11Texture2D); [MarshalAs(UnmanagedType.FunctionPtr)] internal _LoadTextureD3D11_Async LoadTextureD3D11_Async; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRRenderModelError _LoadIntoTextureD3D11_Async(int textureId, IntPtr pDstTexture); [MarshalAs(UnmanagedType.FunctionPtr)] internal _LoadIntoTextureD3D11_Async LoadIntoTextureD3D11_Async; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _FreeTextureD3D11(IntPtr pD3D11Texture2D); [MarshalAs(UnmanagedType.FunctionPtr)] internal _FreeTextureD3D11 FreeTextureD3D11; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate uint _GetRenderModelName(uint unRenderModelIndex, System.Text.StringBuilder pchRenderModelName, uint unRenderModelNameLen); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetRenderModelName GetRenderModelName; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate uint _GetRenderModelCount(); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetRenderModelCount GetRenderModelCount; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate uint _GetComponentCount(string pchRenderModelName); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetComponentCount GetComponentCount; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate uint _GetComponentName(string pchRenderModelName, uint unComponentIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameLen); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetComponentName GetComponentName; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate ulong _GetComponentButtonMask(string pchRenderModelName, string pchComponentName); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetComponentButtonMask GetComponentButtonMask; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate uint _GetComponentRenderModelName(string pchRenderModelName, string pchComponentName, System.Text.StringBuilder pchComponentRenderModelName, uint unComponentRenderModelNameLen); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetComponentRenderModelName GetComponentRenderModelName; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetComponentStateForDevicePath(string pchRenderModelName, string pchComponentName, ulong devicePath, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetComponentStateForDevicePath GetComponentStateForDevicePath; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetComponentState(string pchRenderModelName, string pchComponentName, ref HVRControllerState_t pControllerState, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetComponentState GetComponentState; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _RenderModelHasComponent(string pchRenderModelName, string pchComponentName); [MarshalAs(UnmanagedType.FunctionPtr)] internal _RenderModelHasComponent RenderModelHasComponent; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate uint _GetRenderModelThumbnailURL(string pchRenderModelName, System.Text.StringBuilder pchThumbnailURL, uint unThumbnailURLLen, ref EHVRRenderModelError peError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetRenderModelThumbnailURL GetRenderModelThumbnailURL; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate uint _GetRenderModelOriginalPath(string pchRenderModelName, System.Text.StringBuilder pchOriginalPath, uint unOriginalPathLen, ref EHVRRenderModelError peError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetRenderModelOriginalPath GetRenderModelOriginalPath; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate IntPtr _GetRenderModelErrorNameFromEnum(EHVRRenderModelError error); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetRenderModelErrorNameFromEnum GetRenderModelErrorNameFromEnum; } [StructLayout(LayoutKind.Sequential)] public struct IHVRTrackedCamera { [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate IntPtr _GetCameraErrorNameFromEnum(EHVRTrackedCameraError eCameraError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetCameraErrorNameFromEnum GetCameraErrorNameFromEnum; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackedCameraError _HasCamera(uint nDeviceIndex, ref bool pHasCamera); [MarshalAs(UnmanagedType.FunctionPtr)] internal _HasCamera HasCamera; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackedCameraError _GetCameraFrameSize(uint nDeviceIndex, EHVRTrackedCameraFrameType eFrameType, ref uint pnWidth, ref uint pnHeight, ref uint pnFrameBufferSize); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetCameraFrameSize GetCameraFrameSize; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackedCameraError _GetCameraIntrinsics(uint nDeviceIndex, uint nCameraIndex, EHVRTrackedCameraFrameType eFrameType, ref HVRVector2_t pFocalLength, ref HVRVector2_t pCenter); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetCameraIntrinsics GetCameraIntrinsics; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackedCameraError _GetCameraProjection(uint nDeviceIndex, uint nCameraIndex, EHVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, ref HVRMatrix44_t pProjection); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetCameraProjection GetCameraProjection; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackedCameraError _AcquireVideoStreamingService(uint nDeviceIndex, ref ulong pHandle); [MarshalAs(UnmanagedType.FunctionPtr)] internal _AcquireVideoStreamingService AcquireVideoStreamingService; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackedCameraError _ReleaseVideoStreamingService(ulong hTrackedCamera); [MarshalAs(UnmanagedType.FunctionPtr)] internal _ReleaseVideoStreamingService ReleaseVideoStreamingService; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackedCameraError _GetVideoStreamFrameBuffer(ulong hTrackedCamera, EHVRTrackedCameraFrameType eFrameType, IntPtr pFrameBuffer, uint nFrameBufferSize, ref HVRCameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetVideoStreamFrameBuffer GetVideoStreamFrameBuffer; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackedCameraError _GetVideoStreamTextureSize(uint nDeviceIndex, EHVRTrackedCameraFrameType eFrameType, ref HVRTextureBounds_t pTextureBounds, ref uint pnWidth, ref uint pnHeight); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetVideoStreamTextureSize GetVideoStreamTextureSize; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackedCameraError _GetVideoStreamTextureD3D11(ulong hTrackedCamera, EHVRTrackedCameraFrameType eFrameType, IntPtr pD3D11DeviceOrResource, ref IntPtr ppD3D11ShaderResourceView, ref HVRCameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetVideoStreamTextureD3D11 GetVideoStreamTextureD3D11; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackedCameraError _GetVideoStreamSeperateTextureD3D11(ulong hTrackedCamera, EHVRTrackedCameraFrameType eFrameType, IntPtr pD3D11DeviceOrResource, ref IntPtr ppD3D11ShaderResourceViewLeft, ref IntPtr ppD3D11ShaderResourceViewRight, ref HVRCameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetVideoStreamSeperateTextureD3D11 GetVideoStreamSeperateTextureD3D11; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackedCameraError _GetVideoStreamTextureGL(ulong hTrackedCamera, EHVRTrackedCameraFrameType eFrameType, ref uint pglTextureId, ref HVRCameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetVideoStreamTextureGL GetVideoStreamTextureGL; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EHVRTrackedCameraError _ReleaseVideoStreamTextureGL(ulong hTrackedCamera, uint glTextureId); [MarshalAs(UnmanagedType.FunctionPtr)] internal _ReleaseVideoStreamTextureGL ReleaseVideoStreamTextureGL; } [StructLayout(LayoutKind.Sequential)] public struct IHVRSettings { [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate IntPtr _GetSettingsErrorNameFromEnum(EHVRSettingsError eError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetSettingsErrorNameFromEnum GetSettingsErrorNameFromEnum; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _Sync(bool bForce, ref EHVRSettingsError peError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _Sync Sync; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _SetBool(string pchSection, string pchSettingsKey, bool bValue, ref EHVRSettingsError peError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetBool SetBool; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _SetInt32(string pchSection, string pchSettingsKey, int nValue, ref EHVRSettingsError peError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetInt32 SetInt32; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _SetFloat(string pchSection, string pchSettingsKey, float flValue, ref EHVRSettingsError peError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetFloat SetFloat; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _SetString(string pchSection, string pchSettingsKey, string pchValue, ref EHVRSettingsError peError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetString SetString; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetBool(string pchSection, string pchSettingsKey, ref EHVRSettingsError peError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetBool GetBool; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate int _GetInt32(string pchSection, string pchSettingsKey, ref EHVRSettingsError peError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetInt32 GetInt32; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate float _GetFloat(string pchSection, string pchSettingsKey, ref EHVRSettingsError peError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetFloat GetFloat; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _GetString(string pchSection, string pchSettingsKey, System.Text.StringBuilder pchValue, uint unValueLen, ref EHVRSettingsError peError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetString GetString; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _RemoveSection(string pchSection, ref EHVRSettingsError peError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _RemoveSection RemoveSection; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _RemoveKeyInSection(string pchSection, string pchSettingsKey, ref EHVRSettingsError peError); [MarshalAs(UnmanagedType.FunctionPtr)] internal _RemoveKeyInSection RemoveKeyInSection; } [StructLayout(LayoutKind.Sequential)] public struct IHVRChaperoneSetup { [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _CommitWorkingCopy(EHVRChaperoneConfigFile configFile); [MarshalAs(UnmanagedType.FunctionPtr)] internal _CommitWorkingCopy CommitWorkingCopy; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _RevertWorkingCopy(); [MarshalAs(UnmanagedType.FunctionPtr)] internal _RevertWorkingCopy RevertWorkingCopy; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetWorkingPlayAreaSize(ref float pSizeX, ref float pSizeZ); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetWorkingPlayAreaSize GetWorkingPlayAreaSize; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetWorkingPlayAreaRect(ref HVRQuad_t rect); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetWorkingPlayAreaRect GetWorkingPlayAreaRect; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetWorkingCollisionBoundsInfo([In, Out] HVRQuad_t[] pQuadsBuffer, ref uint punQuadsCount); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetWorkingCollisionBoundsInfo GetWorkingCollisionBoundsInfo; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetLiveCollisionBoundsInfo([In, Out] HVRQuad_t[] pQuadsBuffer, ref uint punQuadsCount); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetLiveCollisionBoundsInfo GetLiveCollisionBoundsInfo; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetWorkingSeatedZeroPoseToRawTrackingPose(ref HVRMatrix34_t pmatSeatedZeroPoseToRawTrackingPose); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetWorkingSeatedZeroPoseToRawTrackingPose GetWorkingSeatedZeroPoseToRawTrackingPose; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetWorkingStandingZeroPoseToRawTrackingPose(ref HVRMatrix34_t pmatStandingZeroPoseToRawTrackingPose); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetWorkingStandingZeroPoseToRawTrackingPose GetWorkingStandingZeroPoseToRawTrackingPose; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _SetWorkingPlayAreaSize(float sizeX, float sizeZ); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetWorkingPlayAreaSize SetWorkingPlayAreaSize; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _SetWorkingCollisionBoundsInfo([In, Out] HVRQuad_t[] pQuadsBuffer, uint unQuadsCount); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetWorkingCollisionBoundsInfo SetWorkingCollisionBoundsInfo; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _SetWorkingSeatedZeroPoseToRawTrackingPose(ref HVRMatrix34_t pMatSeatedZeroPoseToRawTrackingPose); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetWorkingSeatedZeroPoseToRawTrackingPose SetWorkingSeatedZeroPoseToRawTrackingPose; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _SetWorkingStandingZeroPoseToRawTrackingPose(ref HVRMatrix34_t pMatStandingZeroPoseToRawTrackingPose); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetWorkingStandingZeroPoseToRawTrackingPose SetWorkingStandingZeroPoseToRawTrackingPose; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _ReloadFromDisk(EHVRChaperoneConfigFile configFile); [MarshalAs(UnmanagedType.FunctionPtr)] internal _ReloadFromDisk ReloadFromDisk; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetLiveSeatedZeroPoseToRawTrackingPose(ref HVRMatrix34_t pmatSeatedZeroPoseToRawTrackingPose); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetLiveSeatedZeroPoseToRawTrackingPose GetLiveSeatedZeroPoseToRawTrackingPose; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _SetWorkingCollisionBoundsTagsInfo([In, Out] byte[] pTagsBuffer, uint unTagCount); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetWorkingCollisionBoundsTagsInfo SetWorkingCollisionBoundsTagsInfo; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetLiveCollisionBoundsTagsInfo([In, Out] byte[] pTagsBuffer, ref uint punTagCount); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetLiveCollisionBoundsTagsInfo GetLiveCollisionBoundsTagsInfo; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _SetWorkingPhysicalBoundsInfo([In, Out] HVRQuad_t[] pQuadsBuffer, uint unQuadsCount); [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetWorkingPhysicalBoundsInfo SetWorkingPhysicalBoundsInfo; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetLivePhysicalBoundsInfo([In, Out] HVRQuad_t[] pQuadsBuffer, ref uint punQuadsCount); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetLivePhysicalBoundsInfo GetLivePhysicalBoundsInfo; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _ExportLiveToBuffer(System.Text.StringBuilder pBuffer, ref uint pnBufferLength); [MarshalAs(UnmanagedType.FunctionPtr)] internal _ExportLiveToBuffer ExportLiveToBuffer; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _ImportFromBufferToWorking(string pBuffer, uint nImportFlags); [MarshalAs(UnmanagedType.FunctionPtr)] internal _ImportFromBufferToWorking ImportFromBufferToWorking; } public class CHVRSystem { IHVRSystem FnTable; internal CHVRSystem(IntPtr pInterface) { FnTable = (IHVRSystem)Marshal.PtrToStructure(pInterface, typeof(IHVRSystem)); } public void GetRecommendedRenderTargetSize(ref uint pnWidth,ref uint pnHeight) { pnWidth = 0; pnHeight = 0; FnTable.GetRecommendedRenderTargetSize(ref pnWidth,ref pnHeight); } public HVRMatrix44_t GetProjectionMatrix(EHVREye eEye,float fNearZ,float fFarZ, EHVRTextureType eProjType) { HVRMatrix44_t result = FnTable.GetProjectionMatrix(eEye,fNearZ,fFarZ,eProjType); return result; } public void GetProjectionRaw(EHVREye eEye,ref float pfLeft,ref float pfRight,ref float pfTop,ref float pfBottom) { pfLeft = 0; pfRight = 0; pfTop = 0; pfBottom = 0; FnTable.GetProjectionRaw(eEye,ref pfLeft,ref pfRight,ref pfTop,ref pfBottom); } public HVRMatrix34_t GetEyeToHeadTransform(EHVREye eEye) { HVRMatrix34_t result = FnTable.GetEyeToHeadTransform(eEye); return result; } public bool GetTimeSinceLastVsync(ref float pfSecondsSinceLastVsync,ref ulong pulFrameCounter) { pfSecondsSinceLastVsync = 0; pulFrameCounter = 0; bool result = FnTable.GetTimeSinceLastVsync(ref pfSecondsSinceLastVsync,ref pulFrameCounter); return result; } public void GetDeviceToAbsoluteTrackingPose(EHVRTrackingUniverseOrigin eOrigin,float fPredictedSecondsToPhotonsFromNow,HVRTrackedDevicePose_t [] pTrackedDevicePoseArray) { FnTable.GetDeviceToAbsoluteTrackingPose(eOrigin,fPredictedSecondsToPhotonsFromNow,pTrackedDevicePoseArray,(uint) pTrackedDevicePoseArray.Length); } public HVRMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() { HVRMatrix34_t result = FnTable.GetRawZeroPoseToStandingAbsoluteTrackingPose(); return result; } public uint GetTrackedDeviceIndexForControllerRole(EHVRTrackedControllerRole unDeviceType) { uint result = FnTable.GetTrackedDeviceIndexForControllerRole(unDeviceType); return result; } public EHVRTrackedControllerRole GetControllerRoleForTrackedDeviceIndex(uint unDeviceIndex) { EHVRTrackedControllerRole result = FnTable.GetControllerRoleForTrackedDeviceIndex(unDeviceIndex); return result; } public EHVRTrackedDeviceClass GetTrackedDeviceClass(uint unDeviceIndex) { EHVRTrackedDeviceClass result = FnTable.GetTrackedDeviceClass(unDeviceIndex); return result; } public bool IsTrackedDeviceConnected(uint unDeviceIndex) { bool result = FnTable.IsTrackedDeviceConnected(unDeviceIndex); return result; } public bool GetBoolTrackedDeviceProperty(uint unDeviceIndex,EHVRTrackedDeviceProperty prop,ref EHVRTrackedPropertyError pError) { bool result = FnTable.GetBoolTrackedDeviceProperty(unDeviceIndex,prop,ref pError); return result; } public float GetFloatTrackedDeviceProperty(uint unDeviceIndex,EHVRTrackedDeviceProperty prop,ref EHVRTrackedPropertyError pError) { float result = FnTable.GetFloatTrackedDeviceProperty(unDeviceIndex,prop,ref pError); return result; } public int GetInt32TrackedDeviceProperty(uint unDeviceIndex,EHVRTrackedDeviceProperty prop,ref EHVRTrackedPropertyError pError) { int result = FnTable.GetInt32TrackedDeviceProperty(unDeviceIndex,prop,ref pError); return result; } public ulong GetUint64TrackedDeviceProperty(uint unDeviceIndex,EHVRTrackedDeviceProperty prop,ref EHVRTrackedPropertyError pError) { ulong result = FnTable.GetUint64TrackedDeviceProperty(unDeviceIndex,prop,ref pError); return result; } public uint GetStringTrackedDeviceProperty(uint unDeviceIndex,EHVRTrackedDeviceProperty prop,System.Text.StringBuilder pchValue,uint unBufferSize,ref EHVRTrackedPropertyError pError) { uint result = FnTable.GetStringTrackedDeviceProperty(unDeviceIndex,prop,pchValue,unBufferSize,ref pError); return result; } public HVRMatrix34_t GetMatrix34TrackedDeviceProperty(uint unDeviceIndex,EHVRTrackedDeviceProperty prop,ref EHVRTrackedPropertyError pError) { HVRMatrix34_t result = FnTable.GetMatrix34TrackedDeviceProperty(unDeviceIndex,prop,ref pError); return result; } public bool PollNextEvent(ref HVREvent_t pEvent,uint uncbVREvent) { bool result = FnTable.PollNextEvent(ref pEvent,uncbVREvent); return result; } public HVRHiddenAreaMesh_t GetHiddenAreaMesh(EHVREye eEye, EHVRHiddenAreaMeshType type) { HVRHiddenAreaMesh_t result = FnTable.GetHiddenAreaMesh(eEye, type); return result; } public bool GetControllerState(uint unControllerDeviceIndex,ref HVRControllerState_t pControllerState, uint unControllerStateSize) { bool result = FnTable.GetControllerState(unControllerDeviceIndex,ref pControllerState); return result; } public bool GetControllerStateWithPose(EHVRTrackingUniverseOrigin eOrigin,uint unControllerDeviceIndex,ref HVRControllerState_t pControllerState, uint unControllerStateSize, ref HVRTrackedDevicePose_t pTrackedDevicePose) { bool result = FnTable.GetControllerStateWithPose(eOrigin,unControllerDeviceIndex,ref pControllerState, (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(HVRControllerState_t)),ref pTrackedDevicePose); return result; } public void TriggerHapticPulse(uint unControllerDeviceIndex,uint unAxisId,char usDurationMicroSec) { FnTable.TriggerHapticPulse(unControllerDeviceIndex,unAxisId,usDurationMicroSec); } public bool IsInputFocusCapturedByAnotherProcess() { return FnTable.IsInputFocusCapturedByAnotherProcess(); } public bool GetPlayAreaSize(ref float pSizeX,ref float pSizeZ) { pSizeX = 0; pSizeZ = 0; bool result = FnTable.GetPlayAreaSize(ref pSizeX,ref pSizeZ); return result; } public bool GetPlayAreaRect(ref HVRQuad_t rect) { bool result = FnTable.GetPlayAreaRect(ref rect); return result; } public HVRChaperoneCalibrationState GetCalibrationState() { HVRChaperoneCalibrationState result = FnTable.GetCalibrationState(); return result; } } public class CHVRCompositor { IHVRCompositor FnTable; internal CHVRCompositor(IntPtr pInterface) { FnTable = (IHVRCompositor)Marshal.PtrToStructure(pInterface, typeof(IHVRCompositor)); } public void SetTrackingSpace(EHVRTrackingUniverseOrigin eTrackingOrigin) { FnTable.SetTrackingSpace(eTrackingOrigin); } public EHVRTrackingUniverseOrigin GetTrackingSpace() { return FnTable.GetTrackingSpace(); } public EHVRCompositorError WaitGetPoses(HVRTrackedDevicePose_t [] pRenderPoseArray,HVRTrackedDevicePose_t [] pGamePoseArray) { EHVRCompositorError result = FnTable.WaitGetPoses(pRenderPoseArray,(uint) pRenderPoseArray.Length,pGamePoseArray,(uint) pGamePoseArray.Length); return result; } public EHVRCompositorError GetLastPoses(HVRTrackedDevicePose_t [] pRenderPoseArray,HVRTrackedDevicePose_t [] pGamePoseArray) { EHVRCompositorError result = FnTable.GetLastPoses(pRenderPoseArray,(uint) pRenderPoseArray.Length,pGamePoseArray,(uint) pGamePoseArray.Length); return result; } public EHVRCompositorError Submit(EHVREye eEye,ref HVRTexture_t pTexture,ref HVRTextureBounds_t pBounds,EHVRSubmitFlags nSubmitFlags) { EHVRCompositorError result = FnTable.Submit(eEye,ref pTexture,ref pBounds,nSubmitFlags); return result; } public void PostPresentHandoff() { FnTable.PostPresentHandoff(); } public void FadeToColor(float fSeconds,float fRed,float fGreen,float fBlue,float fAlpha,bool bBackground) { FnTable.FadeToColor(fSeconds,fRed,fGreen,fBlue,fAlpha,bBackground); } public void SuspendRendering(bool bSuspend) { FnTable.SuspendRendering(bSuspend); } public bool CanRenderScene() { bool ret = FnTable.CanRenderScene(); return ret; } } public class CHVROverlay { IHVROverlay FnTable; internal CHVROverlay(IntPtr pInterface) { FnTable = (IHVROverlay)Marshal.PtrToStructure(pInterface, typeof(IHVROverlay)); } public EHVROverlayError FindOverlay(string pchOverlayKey,ref ulong pOverlayHandle) { pOverlayHandle = 0; EHVROverlayError result = FnTable.FindOverlay(pchOverlayKey,ref pOverlayHandle); return result; } public EHVROverlayError CreateOverlay(string pchOverlayKey,string pchOverlayFriendlyName,ref ulong pOverlayHandle) { pOverlayHandle = 0; EHVROverlayError result = FnTable.CreateOverlay(pchOverlayKey,pchOverlayFriendlyName,ref pOverlayHandle); return result; } public EHVROverlayError DestroyOverlay(ulong ulOverlayHandle) { EHVROverlayError result = FnTable.DestroyOverlay(ulOverlayHandle); return result; } public EHVROverlayError SetHighQualityOverlay(ulong ulOverlayHandle) { EHVROverlayError result = FnTable.SetHighQualityOverlay(ulOverlayHandle); return result; } public ulong GetHighQualityOverlay() { ulong result = FnTable.GetHighQualityOverlay(); return result; } public uint GetOverlayKey(ulong ulOverlayHandle,System.Text.StringBuilder pchValue,uint unBufferSize,ref EHVROverlayError pError) { uint result = FnTable.GetOverlayKey(ulOverlayHandle,pchValue,unBufferSize,ref pError); return result; } public uint GetOverlayName(ulong ulOverlayHandle,System.Text.StringBuilder pchValue,uint unBufferSize,ref EHVROverlayError pError) { uint result = FnTable.GetOverlayName(ulOverlayHandle,pchValue,unBufferSize,ref pError); return result; } public EHVROverlayError GetOverlayImageData(ulong ulOverlayHandle,IntPtr pvBuffer,uint unBufferSize,ref uint punWidth,ref uint punHeight) { punWidth = 0; punHeight = 0; EHVROverlayError result = FnTable.GetOverlayImageData(ulOverlayHandle,pvBuffer,unBufferSize,ref punWidth,ref punHeight); return result; } public string GetOverlayErrorNameFromEnum(EHVROverlayError error) { IntPtr result = FnTable.GetOverlayErrorNameFromEnum(error); return Marshal.PtrToStringAnsi(result); } public EHVROverlayError SetOverlayRenderingPid(ulong ulOverlayHandle,uint unPID) { EHVROverlayError result = FnTable.SetOverlayRenderingPid(ulOverlayHandle,unPID); return result; } public uint GetOverlayRenderingPid(ulong ulOverlayHandle) { uint result = FnTable.GetOverlayRenderingPid(ulOverlayHandle); return result; } public EHVROverlayError SetOverlayFlag(ulong ulOverlayHandle, HVROverlayFlags eOverlayFlag, bool bEnabled) { EHVROverlayError result = FnTable.SetOverlayFlag(ulOverlayHandle, eOverlayFlag, bEnabled); return result; } public EHVROverlayError GetOverlayFlag(ulong ulOverlayHandle, HVROverlayFlags eOverlayFlag, ref bool bEnabled) { EHVROverlayError result = FnTable.GetOverlayFlag(ulOverlayHandle, eOverlayFlag, ref bEnabled); return result; } public EHVROverlayError SetOverlayColor(ulong ulOverlayHandle,float fRed,float fGreen,float fBlue) { EHVROverlayError result = FnTable.SetOverlayColor(ulOverlayHandle,fRed,fGreen,fBlue); return result; } public EHVROverlayError GetOverlayColor(ulong ulOverlayHandle,ref float pfRed,ref float pfGreen,ref float pfBlue) { pfRed = 0; pfGreen = 0; pfBlue = 0; EHVROverlayError result = FnTable.GetOverlayColor(ulOverlayHandle,ref pfRed,ref pfGreen,ref pfBlue); return result; } public EHVROverlayError SetOverlayAlpha(ulong ulOverlayHandle,float fAlpha) { EHVROverlayError result = FnTable.SetOverlayAlpha(ulOverlayHandle,fAlpha); return result; } public EHVROverlayError GetOverlayAlpha(ulong ulOverlayHandle,ref float pfAlpha) { pfAlpha = 0; EHVROverlayError result = FnTable.GetOverlayAlpha(ulOverlayHandle,ref pfAlpha); return result; } public EHVROverlayError SetOverlayTexelAspect(ulong ulOverlayHandle,float fTexelAspect) { EHVROverlayError result = FnTable.SetOverlayTexelAspect(ulOverlayHandle,fTexelAspect); return result; } public EHVROverlayError GetOverlayTexelAspect(ulong ulOverlayHandle,ref float pfTexelAspect) { pfTexelAspect = 0; EHVROverlayError result = FnTable.GetOverlayTexelAspect(ulOverlayHandle,ref pfTexelAspect); return result; } public EHVROverlayError SetOverlaySortOrder(ulong ulOverlayHandle,uint unSortOrder) { EHVROverlayError result = FnTable.SetOverlaySortOrder(ulOverlayHandle,unSortOrder); return result; } public EHVROverlayError GetOverlaySortOrder(ulong ulOverlayHandle,ref uint punSortOrder) { punSortOrder = 0; EHVROverlayError result = FnTable.GetOverlaySortOrder(ulOverlayHandle,ref punSortOrder); return result; } public EHVROverlayError SetOverlayWidthInMeters(ulong ulOverlayHandle,float fWidthInMeters) { EHVROverlayError result = FnTable.SetOverlayWidthInMeters(ulOverlayHandle,fWidthInMeters); return result; } public EHVROverlayError GetOverlayWidthInMeters(ulong ulOverlayHandle,ref float pfWidthInMeters) { pfWidthInMeters = 0; EHVROverlayError result = FnTable.GetOverlayWidthInMeters(ulOverlayHandle,ref pfWidthInMeters); return result; } public EHVROverlayError SetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) { EHVROverlayError result = FnTable.SetOverlayAutoCurveDistanceRangeInMeters(ulOverlayHandle, fMinDistanceInMeters, fMaxDistanceInMeters); return result; } public EHVROverlayError GetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle, ref float fMinDistanceInMeters, ref float fMaxDistanceInMeters) { EHVROverlayError result = FnTable.GetOverlayAutoCurveDistanceRangeInMeters(ulOverlayHandle, ref fMinDistanceInMeters, ref fMaxDistanceInMeters); return result; } public EHVROverlayError SetOverlayTextureBounds(ulong ulOverlayHandle, ref HVRTextureBounds_t pOverlayTextureBounds) { EHVROverlayError result = FnTable.SetOverlayTextureBounds(ulOverlayHandle, ref pOverlayTextureBounds); return result; } public EHVROverlayError GetOverlayTextureBounds(ulong ulOverlayHandle, ref HVRTextureBounds_t pOverlayTextureBounds) { EHVROverlayError result = FnTable.GetOverlayTextureBounds(ulOverlayHandle, ref pOverlayTextureBounds); return result; } public EHVROverlayError GetOverlayTransformType(ulong ulOverlayHandle,ref HVROverlayTransformType peTransformType) { EHVROverlayError result = FnTable.GetOverlayTransformType(ulOverlayHandle,ref peTransformType); return result; } public EHVROverlayError SetOverlayTransformAbsolute(ulong ulOverlayHandle,EHVRTrackingUniverseOrigin eTrackingOrigin,ref HVRMatrix34_t pmatTrackingOriginToOverlayTransform) { EHVROverlayError result = FnTable.SetOverlayTransformAbsolute(ulOverlayHandle,eTrackingOrigin,ref pmatTrackingOriginToOverlayTransform); return result; } public EHVROverlayError GetOverlayTransformAbsolute(ulong ulOverlayHandle,ref EHVRTrackingUniverseOrigin peTrackingOrigin,ref HVRMatrix34_t pmatTrackingOriginToOverlayTransform) { EHVROverlayError result = FnTable.GetOverlayTransformAbsolute(ulOverlayHandle,ref peTrackingOrigin,ref pmatTrackingOriginToOverlayTransform); return result; } public EHVROverlayError SetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle,uint unTrackedDevice,ref HVRMatrix34_t pmatTrackedDeviceToOverlayTransform) { EHVROverlayError result = FnTable.SetOverlayTransformTrackedDeviceRelative(ulOverlayHandle,unTrackedDevice,ref pmatTrackedDeviceToOverlayTransform); return result; } public EHVROverlayError GetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle,ref uint punTrackedDevice,ref HVRMatrix34_t pmatTrackedDeviceToOverlayTransform) { punTrackedDevice = 0; EHVROverlayError result = FnTable.GetOverlayTransformTrackedDeviceRelative(ulOverlayHandle,ref punTrackedDevice,ref pmatTrackedDeviceToOverlayTransform); return result; } public EHVROverlayError SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle,uint unDeviceIndex,string pchComponentName) { EHVROverlayError result = FnTable.SetOverlayTransformTrackedDeviceComponent(ulOverlayHandle,unDeviceIndex,pchComponentName); return result; } public EHVROverlayError GetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle,ref uint punDeviceIndex,string pchComponentName,uint unComponentNameSize) { punDeviceIndex = 0; EHVROverlayError result = FnTable.GetOverlayTransformTrackedDeviceComponent(ulOverlayHandle,ref punDeviceIndex,pchComponentName,unComponentNameSize); return result; } public EHVROverlayError ShowOverlay(ulong ulOverlayHandle) { EHVROverlayError result = FnTable.ShowOverlay(ulOverlayHandle); return result; } public EHVROverlayError HideOverlay(ulong ulOverlayHandle) { EHVROverlayError result = FnTable.HideOverlay(ulOverlayHandle); return result; } public bool IsOverlayVisible(ulong ulOverlayHandle) { bool result = FnTable.IsOverlayVisible(ulOverlayHandle); return result; } public EHVROverlayError SetOverlayTexture(ulong ulOverlayHandle,ref HVRTexture_t pTexture) { EHVROverlayError result = FnTable.SetOverlayTexture(ulOverlayHandle,ref pTexture); return result; } public EHVROverlayError ClearOverlayTexture(ulong ulOverlayHandle) { EHVROverlayError result = FnTable.ClearOverlayTexture(ulOverlayHandle); return result; } public EHVROverlayError SetOverlayRaw(ulong ulOverlayHandle,IntPtr pvBuffer,uint unWidth,uint unHeight,uint unDepth) { EHVROverlayError result = FnTable.SetOverlayRaw(ulOverlayHandle,pvBuffer,unWidth,unHeight,unDepth); return result; } public EHVROverlayError SetOverlayFromFile(ulong ulOverlayHandle,string pchFilePath) { EHVROverlayError result = FnTable.SetOverlayFromFile(ulOverlayHandle,pchFilePath); return result; } public EHVROverlayError GetOverlayTexture(ulong ulOverlayHandle,ref IntPtr pNativeTextureHandle,IntPtr pNativeTextureRef,ref uint pWidth,ref uint pHeight,ref uint pNativeFormat,ref EHVRTextureType pAPI,ref EHVRColorSpace pColorSpace) { pWidth = 0; pHeight = 0; pNativeFormat = 0; EHVROverlayError result = FnTable.GetOverlayTexture(ulOverlayHandle,ref pNativeTextureHandle,pNativeTextureRef,ref pWidth,ref pHeight,ref pNativeFormat,ref pAPI,ref pColorSpace); return result; } public EHVROverlayError GetOverlayTextureSize(ulong ulOverlayHandle,ref uint pWidth,ref uint pHeight) { pWidth = 0; pHeight = 0; EHVROverlayError result = FnTable.GetOverlayTextureSize(ulOverlayHandle,ref pWidth,ref pHeight); return result; } public EHVROverlayError SetOverlayStereoTexture(ulong ulOverlayHandle, ref HVRTexture_t pTexture, EHVREye eye) { EHVROverlayError result = FnTable.SetOverlayStereoTexture(ulOverlayHandle, ref pTexture, eye); return result; } public EHVROverlayError SetOverlayStereoMode(ulong ulOverlayHandle, bool bEnabled) { EHVROverlayError result = FnTable.SetOverlayStereoMode(ulOverlayHandle, bEnabled); return result; } public EHVROverlayError SetOverlayStereoTextureBounds(ulong ulOverlayHandle, ref HVRTextureBounds_t pOverlayTextureBounds, EHVREye eye) { EHVROverlayError result = FnTable.SetOverlayStereoTextureBounds(ulOverlayHandle, ref pOverlayTextureBounds, eye); return result; } public EHVROverlayError SetOverlayTextureUpsideDownFlag(ulong ulOverlayHandle, bool flag) { EHVROverlayError result = FnTable.SetOverlayTextureUpsideDownFlag(ulOverlayHandle, flag); return result; } public EHVROverlayError CreateDesktopCaptureOverlay(uint targetHandle) { EHVROverlayError result = FnTable.CreateDesktopCaptureOverlay(targetHandle); return result; } public EHVROverlayError DestroyDesktopCaptureOverlay(uint targetHandle) { EHVROverlayError result = FnTable.DestroyDesktopCaptureOverlay(targetHandle); return result; } public EHVROverlayError SetDesktopCaptureOverlayWidth(uint targetHandle, float width) { EHVROverlayError result = FnTable.SetDesktopCaptureOverlayWidth(targetHandle, width); return result; } public EHVROverlayError SetDesktopCaptureOverlayAbsolutePose( uint targetHandle, ref HVRMatrix34_t pmatTrackedDeviceToOverlayTransform) { EHVROverlayError result = FnTable.SetDesktopCaptureOverlayAbsolutePose(targetHandle, ref pmatTrackedDeviceToOverlayTransform); return result; } public EHVROverlayError SetDesktopCaptureOverlayCurveDistance(uint targetHandle, float minDist, float maxDist) { EHVROverlayError result = FnTable.SetDesktopCaptureOverlayCurveDistance(targetHandle, minDist, maxDist); return result; } } public class CHVRRenderModels { IHVRRenderModels FnTable; internal CHVRRenderModels(IntPtr pInterface) { FnTable = (IHVRRenderModels)Marshal.PtrToStructure(pInterface, typeof(IHVRRenderModels)); } public EHVRRenderModelError LoadRenderModel_Async(string pchRenderModelName, ref IntPtr ppRenderModel) { EHVRRenderModelError result = FnTable.LoadRenderModel_Async(pchRenderModelName, ref ppRenderModel); return result; } public void FreeRenderModel(IntPtr pRenderModel) { FnTable.FreeRenderModel(pRenderModel); } public EHVRRenderModelError LoadTexture_Async(int textureId, ref IntPtr ppTexture) { EHVRRenderModelError result = FnTable.LoadTexture_Async(textureId, ref ppTexture); return result; } public void FreeTexture(IntPtr pTexture) { FnTable.FreeTexture(pTexture); } public EHVRRenderModelError LoadTextureD3D11_Async(int textureId, IntPtr pD3D11Device, ref IntPtr ppD3D11Texture2D) { EHVRRenderModelError result = FnTable.LoadTextureD3D11_Async(textureId, pD3D11Device, ref ppD3D11Texture2D); return result; } public EHVRRenderModelError LoadIntoTextureD3D11_Async(int textureId, IntPtr pDstTexture) { EHVRRenderModelError result = FnTable.LoadIntoTextureD3D11_Async(textureId, pDstTexture); return result; } public void FreeTextureD3D11(IntPtr pD3D11Texture2D) { FnTable.FreeTextureD3D11(pD3D11Texture2D); } public uint GetRenderModelName(uint unRenderModelIndex, System.Text.StringBuilder pchRenderModelName, uint unRenderModelNameLen) { uint result = FnTable.GetRenderModelName(unRenderModelIndex, pchRenderModelName, unRenderModelNameLen); return result; } public uint GetRenderModelCount() { uint result = FnTable.GetRenderModelCount(); return result; } public uint GetComponentCount(string pchRenderModelName) { uint result = FnTable.GetComponentCount(pchRenderModelName); return result; } public uint GetComponentName(string pchRenderModelName, uint unComponentIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameLen) { uint result = FnTable.GetComponentName(pchRenderModelName, unComponentIndex, pchComponentName, unComponentNameLen); return result; } public ulong GetComponentButtonMask(string pchRenderModelName, string pchComponentName) { ulong result = FnTable.GetComponentButtonMask(pchRenderModelName, pchComponentName); return result; } public uint GetComponentRenderModelName(string pchRenderModelName, string pchComponentName, System.Text.StringBuilder pchComponentRenderModelName, uint unComponentRenderModelNameLen) { uint result = FnTable.GetComponentRenderModelName(pchRenderModelName, pchComponentName, pchComponentRenderModelName, unComponentRenderModelNameLen); return result; } public bool GetComponentStateForDevicePath(string pchRenderModelName, string pchComponentName, ulong devicePath, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState) { bool result = FnTable.GetComponentStateForDevicePath(pchRenderModelName, pchComponentName, devicePath, ref pState, ref pComponentState); return result; } // This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were // originally mis-compiled with the wrong packing for Linux and OSX. [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate bool _GetComponentStatePacked(string pchRenderModelName, string pchComponentName, ref VRControllerState_t_Packed pControllerState, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState); [StructLayout(LayoutKind.Explicit)] struct GetComponentStateUnion { [FieldOffset(0)] public IHVRRenderModels._GetComponentState pGetComponentState; [FieldOffset(0)] public _GetComponentStatePacked pGetComponentStatePacked; } public bool GetComponentState(string pchRenderModelName, string pchComponentName, ref HVRControllerState_t pControllerState, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState) { #if !UNITY_METRO if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) { GetComponentStateUnion u; VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState); u.pGetComponentStatePacked = null; u.pGetComponentState = FnTable.GetComponentState; bool packed_result = u.pGetComponentStatePacked(pchRenderModelName, pchComponentName, ref state_packed, ref pState, ref pComponentState); state_packed.Unpack(ref pControllerState); return packed_result; } #endif bool result = FnTable.GetComponentState(pchRenderModelName, pchComponentName, ref pControllerState, ref pState, ref pComponentState); return result; } public bool RenderModelHasComponent(string pchRenderModelName, string pchComponentName) { bool result = FnTable.RenderModelHasComponent(pchRenderModelName, pchComponentName); return result; } public uint GetRenderModelThumbnailURL(string pchRenderModelName, System.Text.StringBuilder pchThumbnailURL, uint unThumbnailURLLen, ref EHVRRenderModelError peError) { uint result = FnTable.GetRenderModelThumbnailURL(pchRenderModelName, pchThumbnailURL, unThumbnailURLLen, ref peError); return result; } public uint GetRenderModelOriginalPath(string pchRenderModelName, System.Text.StringBuilder pchOriginalPath, uint unOriginalPathLen, ref EHVRRenderModelError peError) { uint result = FnTable.GetRenderModelOriginalPath(pchRenderModelName, pchOriginalPath, unOriginalPathLen, ref peError); return result; } public string GetRenderModelErrorNameFromEnum(EHVRRenderModelError error) { IntPtr result = FnTable.GetRenderModelErrorNameFromEnum(error); return Marshal.PtrToStringAnsi(result); } } public class CHVRTrackedCamera { IHVRTrackedCamera FnTable; internal CHVRTrackedCamera(IntPtr pInterface) { FnTable = (IHVRTrackedCamera)Marshal.PtrToStructure(pInterface, typeof(IHVRTrackedCamera)); } public string GetCameraErrorNameFromEnum(EHVRTrackedCameraError eCameraError) { IntPtr result = FnTable.GetCameraErrorNameFromEnum(eCameraError); return Marshal.PtrToStringAnsi(result); } public EHVRTrackedCameraError HasCamera(uint nDeviceIndex,ref bool pHasCamera) { pHasCamera = false; EHVRTrackedCameraError result = FnTable.HasCamera(nDeviceIndex,ref pHasCamera); return result; } public EHVRTrackedCameraError GetCameraFrameSize(uint nDeviceIndex,EHVRTrackedCameraFrameType eFrameType,ref uint pnWidth,ref uint pnHeight,ref uint pnFrameBufferSize) { pnWidth = 0; pnHeight = 0; pnFrameBufferSize = 0; EHVRTrackedCameraError result = FnTable.GetCameraFrameSize(nDeviceIndex,eFrameType,ref pnWidth,ref pnHeight,ref pnFrameBufferSize); return result; } public EHVRTrackedCameraError GetCameraIntrinsics(uint nDeviceIndex, uint nCameraIndex, EHVRTrackedCameraFrameType eFrameType,ref HVRVector2_t pFocalLength,ref HVRVector2_t pCenter) { EHVRTrackedCameraError result = FnTable.GetCameraIntrinsics(nDeviceIndex, nCameraIndex, eFrameType, ref pFocalLength,ref pCenter); return result; } public EHVRTrackedCameraError GetCameraProjection(uint nDeviceIndex,uint nCameraIndex, EHVRTrackedCameraFrameType eFrameType,float flZNear,float flZFar,ref HVRMatrix44_t pProjection) { EHVRTrackedCameraError result = FnTable.GetCameraProjection(nDeviceIndex,nCameraIndex, eFrameType,flZNear,flZFar,ref pProjection); return result; } public EHVRTrackedCameraError AcquireVideoStreamingService(uint nDeviceIndex,ref ulong pHandle) { pHandle = 0; EHVRTrackedCameraError result = FnTable.AcquireVideoStreamingService(nDeviceIndex,ref pHandle); return result; } public EHVRTrackedCameraError ReleaseVideoStreamingService(ulong hTrackedCamera) { EHVRTrackedCameraError result = FnTable.ReleaseVideoStreamingService(hTrackedCamera); return result; } public EHVRTrackedCameraError GetVideoStreamFrameBuffer(ulong hTrackedCamera,EHVRTrackedCameraFrameType eFrameType,IntPtr pFrameBuffer,uint nFrameBufferSize,ref HVRCameraVideoStreamFrameHeader_t pFrameHeader,uint nFrameHeaderSize) { EHVRTrackedCameraError result = FnTable.GetVideoStreamFrameBuffer(hTrackedCamera,eFrameType,pFrameBuffer,nFrameBufferSize,ref pFrameHeader,nFrameHeaderSize); return result; } public EHVRTrackedCameraError GetVideoStreamTextureSize(uint nDeviceIndex,EHVRTrackedCameraFrameType eFrameType,ref HVRTextureBounds_t pTextureBounds,ref uint pnWidth,ref uint pnHeight) { pnWidth = 0; pnHeight = 0; EHVRTrackedCameraError result = FnTable.GetVideoStreamTextureSize(nDeviceIndex,eFrameType,ref pTextureBounds,ref pnWidth,ref pnHeight); return result; } public EHVRTrackedCameraError GetVideoStreamTextureD3D11(ulong hTrackedCamera,EHVRTrackedCameraFrameType eFrameType,IntPtr pD3D11DeviceOrResource,ref IntPtr ppD3D11ShaderResourceView,ref HVRCameraVideoStreamFrameHeader_t pFrameHeader,uint nFrameHeaderSize) { EHVRTrackedCameraError result = FnTable.GetVideoStreamTextureD3D11(hTrackedCamera,eFrameType,pD3D11DeviceOrResource,ref ppD3D11ShaderResourceView,ref pFrameHeader,nFrameHeaderSize); return result; } public EHVRTrackedCameraError GetVideoStreamTextureGL(ulong hTrackedCamera,EHVRTrackedCameraFrameType eFrameType,ref uint pglTextureId,ref HVRCameraVideoStreamFrameHeader_t pFrameHeader,uint nFrameHeaderSize) { pglTextureId = 0; EHVRTrackedCameraError result = FnTable.GetVideoStreamTextureGL(hTrackedCamera,eFrameType,ref pglTextureId,ref pFrameHeader,nFrameHeaderSize); return result; } public EHVRTrackedCameraError ReleaseVideoStreamTextureGL(ulong hTrackedCamera,uint glTextureId) { EHVRTrackedCameraError result = FnTable.ReleaseVideoStreamTextureGL(hTrackedCamera,glTextureId); return result; } } public class CHVRSettings { IHVRSettings FnTable; internal CHVRSettings(IntPtr pInterface) { FnTable = (IHVRSettings)Marshal.PtrToStructure(pInterface, typeof(IHVRSettings)); } public string GetSettingsErrorNameFromEnum(EHVRSettingsError eError) { IntPtr result = FnTable.GetSettingsErrorNameFromEnum(eError); return Marshal.PtrToStringAnsi(result); } public bool Sync(bool bForce,ref EHVRSettingsError peError) { bool result = FnTable.Sync(bForce,ref peError); return result; } public void SetBool(string pchSection,string pchSettingsKey,bool bValue,ref EHVRSettingsError peError) { FnTable.SetBool(pchSection,pchSettingsKey,bValue,ref peError); } public void SetInt32(string pchSection,string pchSettingsKey,int nValue,ref EHVRSettingsError peError) { FnTable.SetInt32(pchSection,pchSettingsKey,nValue,ref peError); } public void SetFloat(string pchSection,string pchSettingsKey,float flValue,ref EHVRSettingsError peError) { FnTable.SetFloat(pchSection,pchSettingsKey,flValue,ref peError); } public void SetString(string pchSection,string pchSettingsKey,string pchValue,ref EHVRSettingsError peError) { FnTable.SetString(pchSection,pchSettingsKey,pchValue,ref peError); } public bool GetBool(string pchSection,string pchSettingsKey,ref EHVRSettingsError peError) { bool result = FnTable.GetBool(pchSection,pchSettingsKey,ref peError); return result; } public int GetInt32(string pchSection,string pchSettingsKey,ref EHVRSettingsError peError) { int result = FnTable.GetInt32(pchSection,pchSettingsKey,ref peError); return result; } public float GetFloat(string pchSection,string pchSettingsKey,ref EHVRSettingsError peError) { float result = FnTable.GetFloat(pchSection,pchSettingsKey,ref peError); return result; } public void GetString(string pchSection,string pchSettingsKey,System.Text.StringBuilder pchValue,uint unValueLen,ref EHVRSettingsError peError) { FnTable.GetString(pchSection,pchSettingsKey,pchValue,unValueLen,ref peError); } public void RemoveSection(string pchSection,ref EHVRSettingsError peError) { FnTable.RemoveSection(pchSection,ref peError); } public void RemoveKeyInSection(string pchSection,string pchSettingsKey,ref EHVRSettingsError peError) { FnTable.RemoveKeyInSection(pchSection,pchSettingsKey,ref peError); } } public class CHVRChaperoneSetup { IHVRChaperoneSetup FnTable; internal CHVRChaperoneSetup(IntPtr pInterface) { FnTable = (IHVRChaperoneSetup)Marshal.PtrToStructure(pInterface, typeof(IHVRChaperoneSetup)); } public bool CommitWorkingCopy(EHVRChaperoneConfigFile configFile) { bool result = FnTable.CommitWorkingCopy(configFile); return result; } public void RevertWorkingCopy() { FnTable.RevertWorkingCopy(); } public bool GetWorkingPlayAreaSize(ref float pSizeX,ref float pSizeZ) { pSizeX = 0; pSizeZ = 0; bool result = FnTable.GetWorkingPlayAreaSize(ref pSizeX,ref pSizeZ); return result; } public bool GetWorkingPlayAreaRect(ref HVRQuad_t rect) { bool result = FnTable.GetWorkingPlayAreaRect(ref rect); return result; } public bool GetWorkingCollisionBoundsInfo(out HVRQuad_t [] pQuadsBuffer) { uint punQuadsCount = 0; bool result = FnTable.GetWorkingCollisionBoundsInfo(null,ref punQuadsCount); pQuadsBuffer= new HVRQuad_t[punQuadsCount]; result = FnTable.GetWorkingCollisionBoundsInfo(pQuadsBuffer,ref punQuadsCount); return result; } public bool GetLiveCollisionBoundsInfo(out HVRQuad_t [] pQuadsBuffer) { uint punQuadsCount = 0; bool result = FnTable.GetLiveCollisionBoundsInfo(null,ref punQuadsCount); pQuadsBuffer= new HVRQuad_t[punQuadsCount]; result = FnTable.GetLiveCollisionBoundsInfo(pQuadsBuffer,ref punQuadsCount); return result; } public bool GetWorkingSeatedZeroPoseToRawTrackingPose(ref HVRMatrix34_t pmatSeatedZeroPoseToRawTrackingPose) { bool result = FnTable.GetWorkingSeatedZeroPoseToRawTrackingPose(ref pmatSeatedZeroPoseToRawTrackingPose); return result; } public bool GetWorkingStandingZeroPoseToRawTrackingPose(ref HVRMatrix34_t pmatStandingZeroPoseToRawTrackingPose) { bool result = FnTable.GetWorkingStandingZeroPoseToRawTrackingPose(ref pmatStandingZeroPoseToRawTrackingPose); return result; } public void SetWorkingPlayAreaSize(float sizeX,float sizeZ) { FnTable.SetWorkingPlayAreaSize(sizeX,sizeZ); } public void SetWorkingCollisionBoundsInfo(HVRQuad_t [] pQuadsBuffer) { FnTable.SetWorkingCollisionBoundsInfo(pQuadsBuffer,(uint) pQuadsBuffer.Length); } public void SetWorkingSeatedZeroPoseToRawTrackingPose(ref HVRMatrix34_t pMatSeatedZeroPoseToRawTrackingPose) { FnTable.SetWorkingSeatedZeroPoseToRawTrackingPose(ref pMatSeatedZeroPoseToRawTrackingPose); } public void SetWorkingStandingZeroPoseToRawTrackingPose(ref HVRMatrix34_t pMatStandingZeroPoseToRawTrackingPose) { FnTable.SetWorkingStandingZeroPoseToRawTrackingPose(ref pMatStandingZeroPoseToRawTrackingPose); } public void ReloadFromDisk(EHVRChaperoneConfigFile configFile) { FnTable.ReloadFromDisk(configFile); } public bool GetLiveSeatedZeroPoseToRawTrackingPose(ref HVRMatrix34_t pmatSeatedZeroPoseToRawTrackingPose) { bool result = FnTable.GetLiveSeatedZeroPoseToRawTrackingPose(ref pmatSeatedZeroPoseToRawTrackingPose); return result; } public void SetWorkingCollisionBoundsTagsInfo(byte [] pTagsBuffer) { FnTable.SetWorkingCollisionBoundsTagsInfo(pTagsBuffer,(uint) pTagsBuffer.Length); } public bool GetLiveCollisionBoundsTagsInfo(out byte [] pTagsBuffer) { uint punTagCount = 0; bool result = FnTable.GetLiveCollisionBoundsTagsInfo(null,ref punTagCount); pTagsBuffer= new byte[punTagCount]; result = FnTable.GetLiveCollisionBoundsTagsInfo(pTagsBuffer,ref punTagCount); return result; } public bool SetWorkingPhysicalBoundsInfo(HVRQuad_t [] pQuadsBuffer) { bool result = FnTable.SetWorkingPhysicalBoundsInfo(pQuadsBuffer,(uint) pQuadsBuffer.Length); return result; } public bool GetLivePhysicalBoundsInfo(out HVRQuad_t [] pQuadsBuffer) { uint punQuadsCount = 0; bool result = FnTable.GetLivePhysicalBoundsInfo(null,ref punQuadsCount); pQuadsBuffer= new HVRQuad_t[punQuadsCount]; result = FnTable.GetLivePhysicalBoundsInfo(pQuadsBuffer,ref punQuadsCount); return result; } public bool ExportLiveToBuffer(System.Text.StringBuilder pBuffer,ref uint pnBufferLength) { pnBufferLength = 0; bool result = FnTable.ExportLiveToBuffer(pBuffer,ref pnBufferLength); return result; } public bool ImportFromBufferToWorking(string pBuffer,uint nImportFlags) { bool result = FnTable.ImportFromBufferToWorking(pBuffer,nImportFlags); return result; } } public class HVRInterop { [DllImportAttribute("ViveVR_api", EntryPoint = "HVR_Init")] internal static extern EHVRErrorCode HVR_InitInternal(EHVRApplicationType eApplicationType); [DllImportAttribute("ViveVR_api", EntryPoint = "HVR_ShutDown")] internal static extern EHVRErrorCode HVR_ShutdownInternal(); [DllImportAttribute("ViveVR_api", EntryPoint = "HVR_GetGenericInterface")] internal static extern IntPtr HVR_GetGenericInterface([In, MarshalAs(UnmanagedType.LPStr)] string pchInterfaceVersion, ref EHVRErrorCode peError); } public enum EHVREye { EHVREye_Left = 0, EHVREye_Right = 1, } public enum EHVRTextureType { EHVRTextureType_DirectX = 0, EHVRTextureType_OpenGL = 1, EHVRTextureType_Vulkan = 2, EHVRTextureType_IOSurface = 3, EHVRTextureType_DirectX12 = 4, } public enum EHVRColorSpace { EHVRColorSpace_Auto = 0, EHVRColorSpace_Gamma = 1, EHVRColorSpace_Linear = 2, } public enum EHVRSubmitFlags { EHVRSubmitFlags_Default = 0, EHVRSubmitFlags_LensDistortionAlreadyApplied = 1, EHVRSubmitFlags_GlRenderBuffer = 2, EHVRSubmitFlags_Reserved = 4, EHVRSubmitFlags_TextureWithPose = 8, } public enum EHVRTrackingUniverseOrigin { EHVRTrackingUniverseOrigin_Seated = 0, EHVRTrackingUniverseOrigin_Standing = 1, EHVRTrackingUniverseOrigin_RawAndUncalibrated = 2, } public enum EHVRTrackingResult { EHVRTrackingResult_Uninitialized = 1, EHVRTrackingResult_Calibrating_InProgress = 100, EHVRTrackingResult_Calibrating_OutOfRange = 101, EHVRTrackingResult_Running_OK = 200, EHVRTrackingResult_Running_OutOfRange = 201, } public enum EHVRTrackedControllerRole { EHVRTrackedControllerRole_Invalid = 0, EHVRTrackedControllerRole_LeftHand = 1, EHVRTrackedControllerRole_RightHand = 2, } public enum EHVRTrackedDeviceClass { EHVRTrackedDeviceClass_Invalid = 0, EHVRTrackedDeviceClass_HMD = 1, EHVRTrackedDeviceClass_Controller = 2, EHVRTrackedDeviceClass_GenericTracker = 3, EHVRTrackedDeviceClass_TrackingReference = 4, } public enum EHVRApplicationType { EHVRApplication_Other = 0, EHVRApplication_Scene = 1, EHVRApplication_Overlay = 2, EHVRApplication_Background = 3, EHVRApplication_Utility = 4, EHVRApplication_VRMonitor = 5, EHVRApplication_Max = 6, } public enum EHVRTrackedDeviceProperty { EHVRTrackedDeviceProperty_Invalid = 0, EHVRTrackedDeviceProperty_TrackingSystemName_String = 1000, EHVRTrackedDeviceProperty_ModelNumber_String = 1001, EHVRTrackedDeviceProperty_SerialNumber_String = 1002, EHVRTrackedDeviceProperty_RenderModelName_String = 1003, EHVRTrackedDeviceProperty_WillDriftInYaw_Bool = 1004, EHVRTrackedDeviceProperty_ManufacturerName_String = 1005, EHVRTrackedDeviceProperty_TrackingFirmwareVersion_String = 1006, EHVRTrackedDeviceProperty_HardwareRevision_String = 1007, EHVRTrackedDeviceProperty_AllWirelessDongleDescriptions_String = 1008, EHVRTrackedDeviceProperty_ConnectedWirelessDongle_String = 1009, EHVRTrackedDeviceProperty_DeviceIsWireless_Bool = 1010, EHVRTrackedDeviceProperty_DeviceIsCharging_Bool = 1011, EHVRTrackedDeviceProperty_DeviceBatteryPercentage_Float = 1012, EHVRTrackedDeviceProperty_StatusDisplayTransform_Matrix34 = 1013, EHVRTrackedDeviceProperty_Firmware_UpdateAvailable_Bool = 1014, EHVRTrackedDeviceProperty_Firmware_ManualUpdate_Bool = 1015, EHVRTrackedDeviceProperty_Firmware_ManualUpdateURL_String = 1016, EHVRTrackedDeviceProperty_HardwareRevision_Uint64 = 1017, EHVRTrackedDeviceProperty_FirmwareVersion_Uint64 = 1018, EHVRTrackedDeviceProperty_FPGAVersion_Uint64 = 1019, EHVRTrackedDeviceProperty_VRCVersion_Uint64 = 1020, EHVRTrackedDeviceProperty_RadioVersion_Uint64 = 1021, EHVRTrackedDeviceProperty_DongleVersion_Uint64 = 1022, EHVRTrackedDeviceProperty_BlockServerShutdown_Bool = 1023, EHVRTrackedDeviceProperty_CanUnifyCoordinateSystemWithHmd_Bool = 1024, EHVRTrackedDeviceProperty_ContainsProximitySensor_Bool = 1025, EHVRTrackedDeviceProperty_DeviceProvidesBatteryStatus_Bool = 1026, EHVRTrackedDeviceProperty_DeviceCanPowerOff_Bool = 1027, EHVRTrackedDeviceProperty_Firmware_ProgrammingTarget_String = 1028, EHVRTrackedDeviceProperty_DeviceClass_Int32 = 1029, EHVRTrackedDeviceProperty_HasCamera_Bool = 1030, EHVRTrackedDeviceProperty_DriverVersion_String = 1031, EHVRTrackedDeviceProperty_Firmware_ForceUpdateRequired_Bool = 1032, EHVRTrackedDeviceProperty_ViveSystemButtonFixRequired_Bool = 1033, EHVRTrackedDeviceProperty_ParentDriver_Uint64 = 1034, EHVRTrackedDeviceProperty_ResourceRoot_String = 1035, EHVRTrackedDeviceProperty_ReportsTimeSinceVSync_Bool = 2000, EHVRTrackedDeviceProperty_SecondsFromVsyncToPhotons_Float = 2001, EHVRTrackedDeviceProperty_DisplayFrequency_Float = 2002, EHVRTrackedDeviceProperty_UserIpdMeters_Float = 2003, EHVRTrackedDeviceProperty_CurrentUniverseId_Uint64 = 2004, EHVRTrackedDeviceProperty_PreviousUniverseId_Uint64 = 2005, EHVRTrackedDeviceProperty_DisplayFirmwareVersion_Uint64 = 2006, EHVRTrackedDeviceProperty_IsOnDesktop_Bool = 2007, EHVRTrackedDeviceProperty_DisplayMCType_Int32 = 2008, EHVRTrackedDeviceProperty_DisplayMCOffset_Float = 2009, EHVRTrackedDeviceProperty_DisplayMCScale_Float = 2010, EHVRTrackedDeviceProperty_EdidVendorID_Int32 = 2011, EHVRTrackedDeviceProperty_DisplayMCImageLeft_String = 2012, EHVRTrackedDeviceProperty_DisplayMCImageRight_String = 2013, EHVRTrackedDeviceProperty_DisplayGCBlackClamp_Float = 2014, EHVRTrackedDeviceProperty_EdidProductID_Int32 = 2015, EHVRTrackedDeviceProperty_CameraToHeadTransform_Matrix34 = 2016, EHVRTrackedDeviceProperty_DisplayGCType_Int32 = 2017, EHVRTrackedDeviceProperty_DisplayGCOffset_Float = 2018, EHVRTrackedDeviceProperty_DisplayGCScale_Float = 2019, EHVRTrackedDeviceProperty_DisplayGCPrescale_Float = 2020, EHVRTrackedDeviceProperty_DisplayGCImage_String = 2021, EHVRTrackedDeviceProperty_LensCenterLeftU_Float = 2022, EHVRTrackedDeviceProperty_LensCenterLeftV_Float = 2023, EHVRTrackedDeviceProperty_LensCenterRightU_Float = 2024, EHVRTrackedDeviceProperty_LensCenterRightV_Float = 2025, EHVRTrackedDeviceProperty_UserHeadToEyeDepthMeters_Float = 2026, EHVRTrackedDeviceProperty_CameraFirmwareVersion_Uint64 = 2027, EHVRTrackedDeviceProperty_CameraFirmwareDescription_String = 2028, EHVRTrackedDeviceProperty_DisplayFPGAVersion_Uint64 = 2029, EHVRTrackedDeviceProperty_DisplayBootloaderVersion_Uint64 = 2030, EHVRTrackedDeviceProperty_DisplayHardwareVersion_Uint64 = 2031, EHVRTrackedDeviceProperty_AudioFirmwareVersion_Uint64 = 2032, EHVRTrackedDeviceProperty_CameraCompatibilityMode_Int32 = 2033, EHVRTrackedDeviceProperty_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034, EHVRTrackedDeviceProperty_ScreenshotVerticalFieldOfViewDegrees_Float = 2035, EHVRTrackedDeviceProperty_DisplaySuppressed_Bool = 2036, EHVRTrackedDeviceProperty_DisplayAllowNightMode_Bool = 2037, EHVRTrackedDeviceProperty_DisplayMCImageWidth_Int32 = 2038, EHVRTrackedDeviceProperty_DisplayMCImageHeight_Int32 = 2039, EHVRTrackedDeviceProperty_DisplayMCImageNumChannels_Int32 = 2040, EHVRTrackedDeviceProperty_DisplayMCImageData_Binary = 2041, EHVRTrackedDeviceProperty_SecondsFromPhotonsToVblank_Float = 2042, EHVRTrackedDeviceProperty_DriverDirectModeSendsVsyncEvents_Bool = 2043, EHVRTrackedDeviceProperty_DisplayDebugMode_Bool = 2044, EHVRTrackedDeviceProperty_GraphicsAdapterLuid_Uint64 = 2045, EHVRTrackedDeviceProperty_AttachedDeviceId_String = 3000, EHVRTrackedDeviceProperty_SupportedButtons_Uint64 = 3001, EHVRTrackedDeviceProperty_Axis0Type_Int32 = 3002, EHVRTrackedDeviceProperty_Axis1Type_Int32 = 3003, EHVRTrackedDeviceProperty_Axis2Type_Int32 = 3004, EHVRTrackedDeviceProperty_Axis3Type_Int32 = 3005, EHVRTrackedDeviceProperty_Axis4Type_Int32 = 3006, EHVRTrackedDeviceProperty_ControllerRoleHint_Int32 = 3007, EHVRTrackedDeviceProperty_FieldOfViewLeftDegrees_Float = 4000, EHVRTrackedDeviceProperty_FieldOfViewRightDegrees_Float = 4001, EHVRTrackedDeviceProperty_FieldOfViewTopDegrees_Float = 4002, EHVRTrackedDeviceProperty_FieldOfViewBottomDegrees_Float = 4003, EHVRTrackedDeviceProperty_TrackingRangeMinimumMeters_Float = 4004, EHVRTrackedDeviceProperty_TrackingRangeMaximumMeters_Float = 4005, EHVRTrackedDeviceProperty_ModeLabel_String = 4006, EHVRTrackedDeviceProperty_IconPathName_String = 5000, EHVRTrackedDeviceProperty_NamedIconPathDeviceOff_String = 5001, EHVRTrackedDeviceProperty_NamedIconPathDeviceSearching_String = 5002, EHVRTrackedDeviceProperty_NamedIconPathDeviceSearchingAlert_String = 5003, EHVRTrackedDeviceProperty_NamedIconPathDeviceReady_String = 5004, EHVRTrackedDeviceProperty_NamedIconPathDeviceReadyAlert_String = 5005, EHVRTrackedDeviceProperty_NamedIconPathDeviceNotReady_String = 5006, EHVRTrackedDeviceProperty_NamedIconPathDeviceStandby_String = 5007, EHVRTrackedDeviceProperty_NamedIconPathDeviceAlertLow_String = 5008, EHVRTrackedDeviceProperty_DisplayHiddenArea_Binary_Start = 5100, EHVRTrackedDeviceProperty_DisplayHiddenArea_Binary_End = 5150, EHVRTrackedDeviceProperty_UserConfigPath_String = 6000, EHVRTrackedDeviceProperty_InstallPath_String = 6001, EHVRTrackedDeviceProperty_HasDisplayComponent_Bool = 6002, EHVRTrackedDeviceProperty_HasControllerComponent_Bool = 6003, EHVRTrackedDeviceProperty_HasCameraComponent_Bool = 6004, EHVRTrackedDeviceProperty_HasDriverDirectModeComponent_Bool = 6005, EHVRTrackedDeviceProperty_HasVirtualDisplayComponent_Bool = 6006, EHVRTrackedDeviceProperty_VendorSpecific_Reserved_Start = 10000, EHVRTrackedDeviceProperty_VendorSpecific_Reserved_End = 10999, } public enum EHVRTrackedPropertyError { EHVRTrackedPropertyError_Success = 0, EHVRTrackedPropertyError_WrongDataType = 1, EHVRTrackedPropertyError_WrongDeviceClass = 2, EHVRTrackedPropertyError_BufferTooSmall = 3, EHVRTrackedPropertyError_UnknownProperty = 4, EHVRTrackedPropertyError_InvalidDevice = 5, EHVRTrackedPropertyError_CouldNotContactServer = 6, EHVRTrackedPropertyError_ValueNotProvidedByDevice = 7, EHVRTrackedPropertyError_StringExceedsMaximumLength = 8, EHVRTrackedPropertyError_NotYetAvailable = 9, EHVRTrackedPropertyError_PermissionDenied = 10, EHVRTrackedPropertyError_InvalidOperation = 11, } public enum EHVRHiddenAreaMeshType { EHVRHiddenAreaMeshType_Standard = 0, EHVRHiddenAreaMeshType_Inverse = 1, EHVRHiddenAreaMeshType_LineLoop = 2, EHVRHiddenAreaMeshType_Max = 3, } public enum EHVRButtonId { EHVRButtonId_System = 0, EHVRButtonId_ApplicationMenu = 1, EHVRButtonId_Grip = 2, EHVRButtonId_DPad_Left = 3, EHVRButtonId_DPad_Up = 4, EHVRButtonId_DPad_Right = 5, EHVRButtonId_DPad_Down = 6, EHVRButtonId_A = 7, EHVRButtonId_ProximitySensor = 31, EHVRButtonId_Axis0 = 32, EHVRButtonId_Axis1 = 33, EHVRButtonId_Axis2 = 34, EHVRButtonId_Axis3 = 35, EHVRButtonId_Axis4 = 36, EVRButton_Touchpad = 32, EVRButton_Trigger = 33, EVRButton_Dashboard_Back = 2, EHVRButtonId_Max = 64, } public enum EHVRControllerAxisType { EHVRControllerAxisType_None = 0, EHVRControllerAxisType_TrackPad = 1, EHVRControllerAxisType_Joystick = 2, EHVRControllerAxisType_Trigger = 3, } public enum HVROverlayTransformType { HVROverlayTransformType_Absolute = 0, HVROverlayTransformType_TrackedDeviceRelative = 1, HVROverlayTransformType_SystemOverlay = 2, HVROverlayTransformType_TrackedComponent = 3, } public enum EHVREventType { EHVREventType_None = 0, EHVREventType_TrackedDeviceActivated = 100, EHVREventType_TrackedDeviceDeactivated = 101, EHVREventType_TrackedDeviceUpdated = 102, EHVREventType_TrackedDeviceUserInteractionStarted = 103, EHVREventType_TrackedDeviceUserInteractionEnded = 104, EHVREventType_IpdChanged = 105, EHVREventType_EnterStandbyMode = 106, EHVREventType_LeaveStandbyMode = 107, EHVREventType_TrackedDeviceRoleChanged = 108, EHVREventType_WatchdogWakeUpRequested = 109, EHVREventType_LensDistortionChanged = 110, EHVREventType_PropertyChanged = 111, EHVREventType_ButtonPress = 200, EHVREventType_ButtonUnpress = 201, EHVREventType_ButtonTouch = 202, EHVREventType_ButtonUntouch = 203, EHVREventType_MouseMove = 300, EHVREventType_MouseButtonDown = 301, EHVREventType_MouseButtonUp = 302, EHVREventType_FocusEnter = 303, EHVREventType_FocusLeave = 304, EHVREventType_Scroll = 305, EHVREventType_TouchPadMove = 306, EHVREventType_OverlayFocusChanged = 307, EHVREventType_InputFocusCaptured = 400, EHVREventType_InputFocusReleased = 401, EHVREventType_SceneFocusLost = 402, EHVREventType_SceneFocusGained = 403, EHVREventType_SceneApplicationChanged = 404, EHVREventType_SceneFocusChanged = 405, EHVREventType_InputFocusChanged = 406, EHVREventType_SceneApplicationSecondaryRenderingStarted = 407, EHVREventType_HideRenderModels = 410, EHVREventType_ShowRenderModels = 411, EHVREventType_OverlayShown = 500, EHVREventType_OverlayHidden = 501, EHVREventType_DashboardActivated = 502, EHVREventType_DashboardDeactivated = 503, EHVREventType_DashboardThumbSelected = 504, EHVREventType_DashboardRequested = 505, EHVREventType_ResetDashboard = 506, EHVREventType_RenderToast = 507, EHVREventType_ImageLoaded = 508, EHVREventType_ShowKeyboard = 509, EHVREventType_HideKeyboard = 510, EHVREventType_OverlayGamepadFocusGained = 511, EHVREventType_OverlayGamepadFocusLost = 512, EHVREventType_OverlaySharedTextureChanged = 513, EHVREventType_DashboardGuideButtonDown = 514, EHVREventType_DashboardGuideButtonUp = 515, EHVREventType_ScreenshotTriggered = 516, EHVREventType_ImageFailed = 517, EHVREventType_DashboardOverlayCreated = 518, EHVREventType_RequestScreenshot = 520, EHVREventType_ScreenshotTaken = 521, EHVREventType_ScreenshotFailed = 522, EHVREventType_SubmitScreenshotToDashboard = 523, EHVREventType_ScreenshotProgressToDashboard = 524, EHVREventType_PrimaryDashboardDeviceChanged = 525, EHVREventType_Notification_Shown = 600, EHVREventType_Notification_Hidden = 601, EHVREventType_Notification_BeginInteraction = 602, EHVREventType_Notification_Destroyed = 603, EHVREventType_Quit = 700, EHVREventType_ProcessQuit = 701, EHVREventType_QuitAborted_UserPrompt = 702, EHVREventType_QuitAcknowledged = 703, EHVREventType_DriverRequestedQuit = 704, EHVREventType_ChaperoneDataHasChanged = 800, EHVREventType_ChaperoneUniverseHasChanged = 801, EHVREventType_ChaperoneTempDataHasChanged = 802, EHVREventType_ChaperoneSettingsHaveChanged = 803, EHVREventType_SeatedZeroPoseReset = 804, EHVREventType_AudioSettingsHaveChanged = 820, EHVREventType_BackgroundSettingHasChanged = 850, EHVREventType_CameraSettingsHaveChanged = 851, EHVREventType_ReprojectionSettingHasChanged = 852, EHVREventType_ModelSkinSettingsHaveChanged = 853, EHVREventType_EnvironmentSettingsHaveChanged = 854, EHVREventType_PowerSettingsHaveChanged = 855, EHVREventType_EnableHomeAppSettingsHaveChanged = 856, EHVREventType_StatusUpdate = 900, EHVREventType_MCImageUpdated = 1000, EHVREventType_FirmwareUpdateStarted = 1100, EHVREventType_FirmwareUpdateFinished = 1101, EHVREventType_KeyboardClosed = 1200, EHVREventType_KeyboardCharInput = 1201, EHVREventType_KeyboardDone = 1202, EHVREventType_ApplicationTransitionStarted = 1300, EHVREventType_ApplicationTransitionAborted = 1301, EHVREventType_ApplicationTransitionNewAppStarted = 1302, EHVREventType_ApplicationListUpdated = 1303, EHVREventType_ApplicationMimeTypeLoad = 1304, EHVREventType_ApplicationTransitionNewAppLaunchComplete = 1305, EHVREventType_ProcessConnected = 1306, EHVREventType_ProcessDisconnected = 1307, EHVREventType_Compositor_MirrorWindowShown = 1400, EHVREventType_Compositor_MirrorWindowHidden = 1401, EHVREventType_Compositor_ChaperoneBoundsShown = 1410, EHVREventType_Compositor_ChaperoneBoundsHidden = 1411, EHVREventType_TrackedCamera_StartVideoStream = 1500, EHVREventType_TrackedCamera_StopVideoStream = 1501, EHVREventType_TrackedCamera_PauseVideoStream = 1502, EHVREventType_TrackedCamera_ResumeVideoStream = 1503, EHVREventType_TrackedCamera_EditingSurface = 1550, EHVREventType_PerformanceTest_EnableCapture = 1600, EHVREventType_PerformanceTest_DisableCapture = 1601, EHVREventType_PerformanceTest_FidelityLevel = 1602, EHVREventType_MessageOverlay_Closed = 1650, EHVREventType_VendorSpecific_Reserved_Start = 10000, EHVREventType_VendorSpecific_Reserved_End = 19999, } public enum EHVRCompositorError { EHVRCompositorError_None = 0, EHVRCompositorError_RequestFailed = 1, EHVRCompositorError_IncompatibleVersion = 100, EHVRCompositorError_DoNotHaveFocus = 101, EHVRCompositorError_InvalidTexture = 102, EHVRCompositorError_IsNotSceneApplication = 103, EHVRCompositorError_TextureIsOnWrongDevice = 104, EHVRCompositorError_TextureUsesUnsupportedFormat = 105, EHVRCompositorError_SharedTexturesNotSupported = 106, EHVRCompositorError_IndexOutOfRange = 107, EHVRCompositorError_AlreadySubmitted = 108, EHVRCompositorError_InvalidBounds = 109, } public enum EHVROverlayError { EHVROverlayError_None = 0, EHVROverlayError_UnknownOverlay = 10, EHVROverlayError_InvalidHandle = 11, EHVROverlayError_PermissionDenied = 12, EHVROverlayError_OverlayLimitExceeded = 13, EHVROverlayError_WrongVisibilityType = 14, EHVROverlayError_KeyTooLong = 15, EHVROverlayError_NameTooLong = 16, EHVROverlayError_KeyInUse = 17, EHVROverlayError_WrongTransformType = 18, EHVROverlayError_InvalidTrackedDevice = 19, EHVROverlayError_InvalidParameter = 20, EHVROverlayError_ThumbnailCantBeDestroyed = 21, EHVROverlayError_ArrayTooSmall = 22, EHVROverlayError_RequestFailed = 23, EHVROverlayError_InvalidTexture = 24, EHVROverlayError_UnableToLoadFile = 25, EHVROverlayError_KeyboardAlreadyInUse = 26, EHVROverlayError_NoNeighbor = 27, EHVROverlayError_TooManyMaskPrimitives = 29, EHVROverlayError_BadMaskPrimitive = 30, } public enum EHVRTrackedCameraError { EHVRTrackedCameraError_None = 0, EHVRTrackedCameraError_OperationFailed = 100, EHVRTrackedCameraError_InvalidHandle = 101, EHVRTrackedCameraError_InvalidFrameHeaderVersion = 102, EHVRTrackedCameraError_OutOfHandles = 103, EHVRTrackedCameraError_IPCFailure = 104, EHVRTrackedCameraError_NotSupportedForThisDevice = 105, EHVRTrackedCameraError_SharedMemoryFailure = 106, EHVRTrackedCameraError_FrameBufferingFailure = 107, EHVRTrackedCameraError_StreamSetupFailure = 108, EHVRTrackedCameraError_InvalidGLTextureId = 109, EHVRTrackedCameraError_InvalidSharedTextureHandle = 110, EHVRTrackedCameraError_FailedToGetGLTextureId = 111, EHVRTrackedCameraError_SharedTextureFailure = 112, EHVRTrackedCameraError_NoFrameAvailable = 113, EHVRTrackedCameraError_InvalidArgument = 114, EHVRTrackedCameraError_InvalidFrameBufferSize = 115, } public enum EHVRTrackedCameraFrameType { EHVRTrackedCameraFrameType_Distorted = 0, EHVRTrackedCameraFrameType_Undistorted = 1, EHVRTrackedCameraFrameType_MaximumUndistorted = 2, EHVRTrackedCameraFrameType_MAX_CAMERA_FRAME_TYPES = 3, } public enum EHVRRenderModelError { None = 0, Loading = 100, NotSupported = 200, InvalidArg = 300, InvalidModel = 301, NoShapes = 302, MultipleShapes = 303, TooManyVertices = 304, MultipleTextures = 305, BufferTooSmall = 306, NotEnoughNormals = 307, NotEnoughTexCoords = 308, InvalidTexture = 400, } public enum EHVRComponentProperty { HVRComponentProperty_IsStatic = (1 << 0), HVRComponentProperty_IsVisible = (1 << 1), HVRComponentProperty_IsTouched = (1 << 2), HVRComponentProperty_IsPressed = (1 << 3), HVRComponentProperty_IsScrolled = (1 << 4), } public enum EHVRSettingsError { EVRSettingsError_None = 0, EVRSettingsError_IPCFailed = 1, EVRSettingsError_WriteFailed = 2, EVRSettingsError_ReadFailed = 3, EVRSettingsError_JsonParseFailed = 4, EVRSettingsError_UnsetSettingHasNoDefault = 5, } public enum EHVRChaperoneConfigFile { EHVRChaperoneConfigFile_Live = 1, EHVRChaperoneConfigFile_Temp = 2, } public enum EHVRErrorCode { HVR_ERR_None = 0, HVR_ERR_Unknown = 1, HVR_ERR_Init_ServerInstallationNotFound = 100, HVR_ERR_Init_CompositorInstallationNotFound = 101, HVR_ERR_Init_MonitorInstallationNotFound = 102, HVR_ERR_Init_ServerProcessCannotBeLaunched = 103, HVR_ERR_Init_CompositorProcessCannotBeLaunched = 104, HVR_ERR_Init_MonitorProcessCannotBeLaunched = 105, HVR_ERR_Init_DriverDLLNotFound = 106, HVR_ERR_Init_FactoryNotFound = 107, HVR_ERR_Init_InterfaceNotFound = 108, HVR_ERR_Init_UserConfigDirectoryInvalid = 109, HVR_ERR_Init_HmdNotFound = 110, HVR_ERR_Init_NotInitialized = 111, HVR_ERR_Init_NoConfigPath = 112, HVR_ERR_Init_NoLogPath = 113, HVR_ERR_Init_ServerRegistryNotFound = 114, HVR_ERR_Init_CompositorRegistryNotFound = 115, HVR_ERR_Init_MonitorRegistryNotFound = 116, HVR_ERR_Init_SettingsInitFailed = 117, HVR_ERR_Init_ShuttingDown = 118, HVR_ERR_Init_VRMonitorNotFound = 119, HVR_ERR_Init_VRMonitorInitFailed = 120, HVR_ERR_Init_InvalidApplicationType = 121, HVR_ERR_Init_ServerInstanceInitFailed = 122, HVR_ERR_Init_CompositorInstanceInitFailed = 123, HVR_ERR_Init_MonitorInstanceInitFailed = 124, HVR_ERR_Init_RenderModelInstanceInitFailed = 125, HVR_ERR_Driver_Failed = 200, HVR_ERR_Driver_LoadFailed = 201, HVR_ERR_Driver_InitFailed = 202, HVR_ERR_Driver_InterfaceNotFound = 203, HVR_ERR_Driver_HmdUnknown = 204, HVR_ERR_Driver_RuntimeOutOfDate = 205, HVR_ERR_IPC_ServerDisconnect = 300, HVR_ERR_IPC_ServerInitFailed = 301, HVR_ERR_IPC_ServerConnectFailed = 302, HVR_ERR_IPC_CompositorInitFailed = 303, HVR_ERR_IPC_CompositorConnectFailed = 304, HVR_ERR_IPC_ConnectFailedAFterManyAttemps = 305, HVR_ERR_Compositor_Failed = 400, HVR_ERR_Compositor_GLFWInitFailed = 401, HVR_ERR_Compositor_GLEWInitFailed = 402, HVR_ERR_Compositor_DXInitFailed = 403, HVR_ERR_Compositor_InitFailed = 404, HVR_ERR_Compositor_D3D11HardwareRequired = 405, HVR_ERR_Compositor_DirectModeFailed = 406, HVR_ERR_Compositor_NVAPIFailed = 407, HVR_ERR_Compositor_AMDAPIFailed = 408, HVR_ERR_Interface_LoadCoreFailed = 501, HVR_ERR_SDK_RegistryNotFound = 901, HVR_ERR_SDK_LibsNotFound = 902, HVR_ERR_SDK_LibsError = 903 } public enum HVRChaperoneCalibrationState { HVRChaperoneCalibrationState_OK = 1, HVRChaperoneCalibrationState_Warning = 100, HVRChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101, HVRChaperoneCalibrationState_Warning_BaseStationRemoved = 102, HVRChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103, HVRChaperoneCalibrationState_Error = 200, HVRChaperoneCalibrationState_Error_BaseStationUninitialized = 201, HVRChaperoneCalibrationState_Error_BaseStationConflict = 202, HVRChaperoneCalibrationState_Error_PlayAreaInvalid = 203, HVRChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204, } public enum HVROverlayFlags { HVROverlayFlags_None = 0, HVROverlayFlags_Curved = 1, HVROverlayFlags_RGSS4X = 2, HVROverlayFlags_NoDashboardTab = 3, HVROverlayFlags_AcceptsGamepadEvents = 4, HVROverlayFlags_ShowGamepadFocus = 5, HVROverlayFlags_SendVRScrollEvents = 6, HVROverlayFlags_SendVRTouchpadEvents = 7, HVROverlayFlags_ShowTouchPadScrollWheel = 8, HVROverlayFlags_TransferOwnershipToInternalProcess = 9, HVROverlayFlags_SideBySide_Parallel = 10, HVROverlayFlags_SideBySide_Crossed = 11, HVROverlayFlags_Panorama = 12, HVROverlayFlags_StereoPanorama = 13, HVROverlayFlags_SortWithNonSceneOverlays = 14, HVROverlayFlags_VisibleInDashboard = 15, } [StructLayout(LayoutKind.Explicit)] public struct HVREvent_Data_t { [FieldOffset(0)] public HVREvent_Reserved_t reserved; [FieldOffset(0)] public HVREvent_Controller_t controller; [FieldOffset(0)] public HVREvent_Process_t process; [FieldOffset(0)] public HVREvent_Overlay_t overlay; [FieldOffset(0)] public HVREvent_Status_t status; [FieldOffset(0)] public HVREvent_Ipd_t ipd; [FieldOffset(0)] public HVREvent_Chaperone_t chaperone; [FieldOffset(0)] public HVREvent_TouchPadMove_t touchPadMove; } [StructLayout(LayoutKind.Sequential)] public struct HVRMatrix34_t { public float m0; //float[3][4] public float m1; public float m2; public float m3; public float m4; public float m5; public float m6; public float m7; public float m8; public float m9; public float m10; public float m11; } [StructLayout(LayoutKind.Sequential)] public struct HVRMatrix44_t { public float m0; //float[4][4] public float m1; public float m2; public float m3; public float m4; public float m5; public float m6; public float m7; public float m8; public float m9; public float m10; public float m11; public float m12; public float m13; public float m14; public float m15; } [StructLayout(LayoutKind.Sequential)] public struct HVRVector3_t { public float v0; //float[3] public float v1; public float v2; } [StructLayout(LayoutKind.Sequential)] public struct HVRVector4_t { public float v0; //float[4] public float v1; public float v2; public float v3; } [StructLayout(LayoutKind.Sequential)] public struct HVRVector3d_t { public double v0; //double[3] public double v1; public double v2; } [StructLayout(LayoutKind.Sequential)] public struct HVRVector2_t { public float v0; //float[2] public float v1; } [StructLayout(LayoutKind.Sequential)] public struct HVRQuaternion_t { public double w; public double x; public double y; public double z; } [StructLayout(LayoutKind.Sequential)] public struct HVRColor_t { public float r; public float g; public float b; public float a; } [StructLayout(LayoutKind.Sequential)] public struct HVRQuad_t { public HVRVector3_t vCorners0; public HVRVector3_t vCorners1; public HVRVector3_t vCorners2; public HVRVector3_t vCorners3; } [StructLayout(LayoutKind.Sequential)] public struct HVRRect2_t { public HVRVector2_t vTopLeft; public HVRVector2_t vBottomRight; } [StructLayout(LayoutKind.Sequential)] public struct HVRTexture_t { public ulong handle; // uint64 public EHVRTextureType eType; public EHVRColorSpace eColorSpace; } [StructLayout(LayoutKind.Sequential)] public struct HVRTrackedDevicePose_t { public HVRMatrix34_t mDeviceToAbsoluteTracking; public HVRVector3_t vVelocity; public HVRVector3_t vAngularVelocity; public EHVRTrackingResult eTrackingResult; [MarshalAs(UnmanagedType.I1)] public bool bPoseIsValid; [MarshalAs(UnmanagedType.I1)] public bool bDeviceIsConnected; } [StructLayout(LayoutKind.Sequential)] public struct HVRTextureBounds_t { public float uMin; public float vMin; public float uMax; public float vMax; } [StructLayout(LayoutKind.Sequential)] public struct HVREvent_Controller_t { public uint button; } [StructLayout(LayoutKind.Sequential)] public struct HVREvent_TouchPadMove_t { [MarshalAs(UnmanagedType.I1)] public bool bFingerDown; public float flSecondsFingerDown; public float fValueXFirst; public float fValueYFirst; public float fValueXRaw; public float fValueYRaw; } [StructLayout(LayoutKind.Sequential)] public struct HVREvent_Process_t { public uint pid; public uint oldPid; [MarshalAs(UnmanagedType.I1)] public bool bForced; } [StructLayout(LayoutKind.Sequential)] public struct HVREvent_Overlay_t { public ulong overlayHandle; } [StructLayout(LayoutKind.Sequential)] public struct HVREvent_Status_t { public uint statusState; } [StructLayout(LayoutKind.Sequential)] public struct HVREvent_Ipd_t { public float ipdMeters; } [StructLayout(LayoutKind.Sequential)] public struct HVREvent_Chaperone_t { public ulong m_nPreviousUniverse; public ulong m_nCurrentUniverse; } [StructLayout(LayoutKind.Sequential)] public struct HVREvent_Reserved_t { public ulong reserved0; public ulong reserved1; } [StructLayout(LayoutKind.Sequential)] public struct HVREvent_t { public uint eventType; public uint trackedDeviceIndex; public float eventAgeSeconds; public HVREvent_Data_t data; } [StructLayout(LayoutKind.Sequential)] public struct HVRHiddenAreaMesh_t { public IntPtr pVertexData; public uint unTriangleCount; } [StructLayout(LayoutKind.Sequential)] public struct HVRControllerAxis_t { public float x; public float y; } [StructLayout(LayoutKind.Sequential)] public struct HVRControllerState_t { public uint unPacketNum; public ulong ulButtonPressed; public ulong ulButtonTouched; public HVRControllerAxis_t rAxis0; public HVRControllerAxis_t rAxis1; public HVRControllerAxis_t rAxis2; public HVRControllerAxis_t rAxis3; public HVRControllerAxis_t rAxis4; } [StructLayout(LayoutKind.Sequential)] public struct HVROverlayIntersectionParams_t { public HVRVector3_t vSource; public HVRVector3_t vDirection; public EHVRTrackingUniverseOrigin eOrigin; } [StructLayout(LayoutKind.Sequential)] public struct VROverlayIntersectionResults_t { public HVRVector3_t vPoint; public HVRVector3_t vNormal; public HVRVector2_t vUVs; public float fDistance; } [StructLayout(LayoutKind.Sequential)] public struct HVRCameraVideoStreamFrameHeader_t { public EHVRTrackedCameraFrameType eFrameType; public uint nWidth; public uint nHeight; public uint nBytesPerPixel; public uint nFrameSequence; public HVRTrackedDevicePose_t standingTrackedDevicePose; } [StructLayout(LayoutKind.Sequential)] public struct RenderModel_ControllerMode_State_t { [MarshalAs(UnmanagedType.I1)] public bool bScrollWheelVisible; } [StructLayout(LayoutKind.Sequential)] public struct RenderModel_ComponentState_t { public HVRMatrix34_t mTrackingToComponentRenderModel; public HVRMatrix34_t mTrackingToComponentLocal; public uint uProperties; } [StructLayout(LayoutKind.Sequential)] public struct RenderModel_TextureMap_t { public ushort unWidth; public ushort unHeight; public IntPtr rubTextureMapData; // const uint8_t* } [StructLayout(LayoutKind.Sequential)] public struct RenderModel_Vertex_t { public HVRVector3_t vPosition; public HVRVector3_t vNormal; public float rfTextureCoord0; public float rfTextureCoord1; } [StructLayout(LayoutKind.Sequential)] public struct RenderModel_t { public IntPtr rVertexData; // const HVRRenderModel_Vertex_t* public uint unVertexCount; public IntPtr rIndexData; // const uint16_t* public uint unTriangleCount; public uint diffuseTextureId; } // This structure is for backwards binary compatibility on Linux and OSX only [StructLayout(LayoutKind.Sequential, Pack = 4)] public struct VRControllerState_t_Packed { public uint unPacketNum; public ulong ulButtonPressed; public ulong ulButtonTouched; public HVRControllerAxis_t rAxis0; //VRControllerAxis_t[5] public HVRControllerAxis_t rAxis1; public HVRControllerAxis_t rAxis2; public HVRControllerAxis_t rAxis3; public HVRControllerAxis_t rAxis4; public VRControllerState_t_Packed(HVRControllerState_t unpacked) { this.unPacketNum = unpacked.unPacketNum; this.ulButtonPressed = unpacked.ulButtonPressed; this.ulButtonTouched = unpacked.ulButtonTouched; this.rAxis0 = unpacked.rAxis0; this.rAxis1 = unpacked.rAxis1; this.rAxis2 = unpacked.rAxis2; this.rAxis3 = unpacked.rAxis3; this.rAxis4 = unpacked.rAxis4; } public void Unpack(ref HVRControllerState_t unpacked) { unpacked.unPacketNum = this.unPacketNum; unpacked.ulButtonPressed = this.ulButtonPressed; unpacked.ulButtonTouched = this.ulButtonTouched; unpacked.rAxis0 = this.rAxis0; unpacked.rAxis1 = this.rAxis1; unpacked.rAxis2 = this.rAxis2; unpacked.rAxis3 = this.rAxis3; unpacked.rAxis4 = this.rAxis4; } } public class HVRClass { public static EHVRErrorCode InitInternal(EHVRApplicationType eApplicationType) { return HVRInterop.HVR_InitInternal(eApplicationType); } public static void ShutdownInternal() { HVRInterop.HVR_ShutdownInternal(); } public static IntPtr GetGenericInterface(string pchInterfaceVersion, ref EHVRErrorCode peError) { return HVRInterop.HVR_GetGenericInterface(pchInterfaceVersion, ref peError); } public const string IHVRSystem_Version = "IHVRSYSTEM_001"; public const string IHVRCompositor_Version = "IHVRCOMPOSITOR_001"; public const string IHVROverlay_Version = "IHVROVERLAY_001"; public const string IHVRTrackedCamera_Version = "IHVRTRACKEDCAMERA_001"; public const string IHVRSettings_Version = "IHVRSETTINGS_001"; public const string IHVRChaperoneSetup_Version = "IHVRCHAPERONESETUP_001"; public const string IHVRRenderModel_Version = "IHVRENDERMODEL_001"; public const uint k_unHVRTrackedDeviceIndex_Hmd = 0; public const uint k_unHVRMaxTrackedDeviceCount = 16; public const uint k_unHVRTrackedDeviceIndexInvalid = 4294967295; public const ulong k_ulHVROverlayHandleInvalid = 0; class CHVRContext { public CHVRContext() { Clear(); } public void Clear() { m_pHVRSystem = null; m_pHVRCompositor = null; m_pHVROverlay = null; m_pHVRTrackedCamera = null; m_pHVRSettings = null; m_pHVRChaperoneSetup = null; m_pHVRRendeModel = null; } public CHVRSystem HVRSystem() { if (m_pHVRSystem == null) { var eError = EHVRErrorCode.HVR_ERR_None; var pInterface = HVRInterop.HVR_GetGenericInterface(IHVRSystem_Version, ref eError); if (pInterface != IntPtr.Zero && eError == EHVRErrorCode.HVR_ERR_None) m_pHVRSystem = new CHVRSystem(pInterface); } return m_pHVRSystem; } public CHVRCompositor HVRCompositor() { if (m_pHVRCompositor == null) { var eError = EHVRErrorCode.HVR_ERR_None; var pInterface = HVRInterop.HVR_GetGenericInterface(IHVRCompositor_Version, ref eError); if (pInterface != IntPtr.Zero && eError == EHVRErrorCode.HVR_ERR_None) m_pHVRCompositor = new CHVRCompositor(pInterface); } return m_pHVRCompositor; } public CHVROverlay HVROverlay() { if (m_pHVROverlay == null) { var eError = EHVRErrorCode.HVR_ERR_None; var pInterface = HVRInterop.HVR_GetGenericInterface(IHVROverlay_Version, ref eError); if (pInterface != IntPtr.Zero && eError == EHVRErrorCode.HVR_ERR_None) m_pHVROverlay = new CHVROverlay(pInterface); } return m_pHVROverlay; } public CHVRTrackedCamera HVRTrackedCamera() { if (m_pHVRTrackedCamera == null) { var eError = EHVRErrorCode.HVR_ERR_None; var pInterface = HVRInterop.HVR_GetGenericInterface(IHVRTrackedCamera_Version, ref eError); if (pInterface != IntPtr.Zero && eError == EHVRErrorCode.HVR_ERR_None) m_pHVRTrackedCamera = new CHVRTrackedCamera(pInterface); } return m_pHVRTrackedCamera; } public CHVRSettings HVRSettings() { if (m_pHVRSettings == null) { var eError = EHVRErrorCode.HVR_ERR_None; var pInterface = HVRInterop.HVR_GetGenericInterface(IHVRSettings_Version, ref eError); if (pInterface != IntPtr.Zero && eError == EHVRErrorCode.HVR_ERR_None) m_pHVRSettings = new CHVRSettings(pInterface); } return m_pHVRSettings; } public CHVRChaperoneSetup HVRChaperoneSetup() { if (m_pHVRChaperoneSetup == null) { var eError = EHVRErrorCode.HVR_ERR_None; var pInterface = HVRInterop.HVR_GetGenericInterface(IHVRChaperoneSetup_Version, ref eError); if (pInterface != IntPtr.Zero && eError == EHVRErrorCode.HVR_ERR_None) m_pHVRChaperoneSetup = new CHVRChaperoneSetup(pInterface); } return m_pHVRChaperoneSetup; } public CHVRRenderModels HVRRenderModelSetup() { if (m_pHVRRendeModel == null) { var eError = EHVRErrorCode.HVR_ERR_None; var pInterface = HVRInterop.HVR_GetGenericInterface(IHVRRenderModel_Version, ref eError); if (pInterface != IntPtr.Zero && eError == EHVRErrorCode.HVR_ERR_None) m_pHVRRendeModel = new CHVRRenderModels(pInterface); } return m_pHVRRendeModel; } private CHVRSystem m_pHVRSystem; private CHVRCompositor m_pHVRCompositor; private CHVROverlay m_pHVROverlay; private CHVRTrackedCamera m_pHVRTrackedCamera; private CHVRSettings m_pHVRSettings; private CHVRChaperoneSetup m_pHVRChaperoneSetup; private CHVRRenderModels m_pHVRRendeModel; }; private static CHVRContext _HVRInternal_ModuleContext = null; static CHVRContext HVRInternal_ModuleContext { get { if (_HVRInternal_ModuleContext == null) _HVRInternal_ModuleContext = new CHVRContext(); return _HVRInternal_ModuleContext; } } public static CHVRSystem System { get { return HVRInternal_ModuleContext.HVRSystem(); } } public static CHVRCompositor Compositor { get { return HVRInternal_ModuleContext.HVRCompositor(); } } public static CHVROverlay Overlay { get { return HVRInternal_ModuleContext.HVROverlay(); } } public static CHVRTrackedCamera TrackedCamera { get { return HVRInternal_ModuleContext.HVRTrackedCamera(); } } public static CHVRSettings Settings { get { return HVRInternal_ModuleContext.HVRSettings(); } } public static CHVRChaperoneSetup ChaperoneSetup { get { return HVRInternal_ModuleContext.HVRChaperoneSetup(); } } public static CHVRRenderModels RenderModels { get { return HVRInternal_ModuleContext.HVRRenderModelSetup(); } } /** Finds the active installation of vrclient.dll and initializes it */ public static CHVRSystem Init(ref EHVRErrorCode peError, EHVRApplicationType eApplicationType = EHVRApplicationType.EHVRApplication_Scene) { peError = InitInternal(eApplicationType); HVRInternal_ModuleContext.Clear(); if (peError != EHVRErrorCode.HVR_ERR_None) return null; return HVRClass.System; } /** unloads vrclient.dll. Any interface pointers from the interface are * invalid after this point */ public static void Shutdown() { ShutdownInternal(); } } }