private static bool PollNextEventWithPose_Hooked(IntPtr instance, ETrackingUniverseOrigin eOrigin, IntPtr pEvent, uint uncbVREvent, IntPtr pTrackedDevicePose) { OpenVRInject This = (OpenVRInject)HookRuntimeInfo.Callback; bool res = false; try { var pollNextEventWithPose = Marshal.GetDelegateForFunctionPointer <vr_PollNextEventWithPoseDelegate>(This.PollNextEventPtr); res = pollNextEventWithPose(instance, eOrigin, pEvent, uncbVREvent, pTrackedDevicePose); if (res) { //This.Interface.Write("Event type: " + (EVREventType)pEvent.eventType); //This.Interface.Write("Device index: " + pEvent.trackedDeviceIndex); return(true); } else if (This.MyEvent.Queued) { res = This.CreateEvent(pEvent); //This.Interface.Write("Event type: " + (EVREventType)pEvent.eventType); //This.Interface.Write("Device index: " + pEvent.trackedDeviceIndex); return(true); } } catch { } return(res); }
public override void OnActivated() { // Make sure SteamVR_Render instance exist. It Polls New Poses Event if (SteamVR_Render.instance == null) { } // setup tracking space m_prevTrackingSpace = trackingSpace; UpdateTrackingSpaceType(); EnsureDeviceStateLength(OpenVR.k_unMaxTrackedDeviceCount); m_hasInputFocus = inputFocus; #if VIU_STEAMVR_1_2_1_OR_NEWER SteamVR_Events.NewPoses.AddListener(OnSteamVRNewPose); SteamVR_Events.InputFocus.AddListener(OnInputFocus); SteamVR_Events.System(EVREventType.VREvent_TrackedDeviceRoleChanged).AddListener(OnTrackedDeviceRoleChanged); #elif VIU_STEAMVR_1_2_0_OR_NEWER SteamVR_Events.NewPoses.AddListener(OnSteamVRNewPose); SteamVR_Events.InputFocus.AddListener(OnInputFocus); SteamVR_Events.System("TrackedDeviceRoleChanged").AddListener(OnTrackedDeviceRoleChanged); #elif VIU_STEAMVR_1_1_1 SteamVR_Utils.Event.Listen("new_poses", OnSteamVRNewPoseArgs); SteamVR_Utils.Event.Listen("input_focus", OnInputFocusArgs); SteamVR_Utils.Event.Listen("TrackedDeviceRoleChanged", OnTrackedDeviceRoleChangedArgs); #endif }
public override void OnActivated() { var system = OpenVR.System; if (system != null) { #if VIU_STEAMVR_1_2_3_OR_NEWER m_hasInputFocus = !system.IsInputAvailable(); #elif VIU_STEAMVR_1_1_1 || VIU_STEAMVR_1_2_0_OR_NEWER m_hasInputFocus = !system.IsInputFocusCapturedByAnotherProcess(); #endif } var compositor = OpenVR.Compositor; if (compositor != null) { m_prevTrackingSpace = compositor.GetTrackingSpace(); UpdateTrackingSpaceType(); } #if VIU_STEAMVR_1_2_1_OR_NEWER SteamVR_Events.InputFocus.AddListener(OnInputFocus); SteamVR_Events.System(EVREventType.VREvent_TrackedDeviceRoleChanged).AddListener(OnTrackedDeviceRoleChanged); #elif VIU_STEAMVR_1_2_0_OR_NEWER SteamVR_Events.InputFocus.AddListener(OnInputFocus); SteamVR_Events.System("TrackedDeviceRoleChanged").AddListener(OnTrackedDeviceRoleChanged); #elif VIU_STEAMVR_1_1_1 SteamVR_Utils.Event.Listen("input_focus", OnInputFocusArgs); SteamVR_Utils.Event.Listen("TrackedDeviceRoleChanged", OnTrackedDeviceRoleChangedArgs); #endif }
//姿勢を取得する(独自クラス) public PoseAction GetPoseActionData(string ActionPath, ETrackingUniverseOrigin UniverseOrigin = ETrackingUniverseOrigin.TrackingUniverseStanding, string RestrictToDevicePath = "") { InputPoseActionData_t data; GetPoseActionDataRaw(ActionPath, out data, UniverseOrigin, RestrictToDevicePath); return(new PoseAction(data, GetOriginSourceFromInternalHandle(data.activeOrigin))); }
private void UpdateControllerState() { ETrackingUniverseOrigin tracktype = OpenVR.Compositor.GetTrackingSpace(); TrackedDevicePose_t newposes = new TrackedDevicePose_t(); openvrsystem.GetControllerStateWithPose(tracktype, (uint)index, ref controllerstate, controllerstatesize, ref newposes); OnNewPoses(newposes); }
/// <summary> /// Sets all pose (and skeleton) actions to use the specified universe origin without going through the sourcemap indexer /// </summary> public void SetTrackingUniverseOrigin(ETrackingUniverseOrigin newOrigin) { var sourceEnumerator = sources.GetEnumerator(); while (sourceEnumerator.MoveNext()) { var sourceElement = sourceEnumerator.Current; sourceElement.Value.universeOrigin = newOrigin; } }
/// <summary> /// Sets all pose (and skeleton) actions to use the specified universe origin without going through the sourcemap indexer /// </summary> public void SetTrackingUniverseOrigin(ETrackingUniverseOrigin newOrigin) { for (int sourceIndex = 0; sourceIndex < sources.Length; sourceIndex++) { if (sources[sourceIndex] != null) { sources[sourceIndex].universeOrigin = newOrigin; } } }
//---------------Device Pose------------------ //全デバイス情報を更新 public void Update(ETrackingUniverseOrigin origin = ETrackingUniverseOrigin.TrackingUniverseStanding) { ReadyCheck(); //実行可能な状態かチェック allDevicePose = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount]; //すべてのデバイスの情報を取得 openvr.GetDeviceToAbsoluteTrackingPose(origin, PredictedTime, allDevicePose); //最終更新フレームを更新 LastFrameCount = Time.frameCount; }
private void Update() { if (currentTrackingSpace != SteamVRManager.trackingSpace) { currentTrackingSpace = SteamVRManager.trackingSpace; if (isOpened) { ToggleTheBar(false); } } }
public override void OnActivated() { m_digitalDataSize = (uint)Marshal.SizeOf(new InputDigitalActionData_t()); m_analogDataSize = (uint)Marshal.SizeOf(new InputAnalogActionData_t()); m_originInfoSize = (uint)Marshal.SizeOf(new InputOriginInfo_t()); m_activeActionSetSize = (uint)Marshal.SizeOf(new VRActiveActionSet_t()); m_poses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount]; m_gamePoses = new TrackedDevicePose_t[0]; m_originDataCache = new Dictionary <ulong, OriginData>((int)OpenVR.k_unMaxActionOriginCount); InitializeHandles(); #if VIU_STEAMVR_2_1_0_OR_NEWER SteamVR_Input.GetActionSet(ACTION_SET_NAME).Activate(SteamVR_Input_Sources.Any, 0, false); #else var actionSet = SteamVR_Input.GetActionSetFromPath(ACTION_SET_PATH); if (actionSet != null) { actionSet.ActivatePrimary(); } #endif #if !VIU_STEAMVR_2_1_0_OR_NEWER m_activeActionSets = new VRActiveActionSet_t[1] { new VRActiveActionSet_t() { ulActionSet = s_actionSetHandle, } }; #endif #if VIU_STEAMVR_2_2_0_OR_NEWER SteamVR_Input.onNonVisualActionsUpdated += UpdateDeviceInput; SteamVR_Input.onPosesUpdated += UpdateDevicePose; #else SteamVR_Input.OnNonVisualActionsUpdated += UpdateDeviceInput; SteamVR_Input.OnPosesUpdated += UpdateDevicePose; #endif s_devicePathHandles = new ulong[OpenVR.k_unMaxTrackedDeviceCount]; EnsureDeviceStateLength(OpenVR.k_unMaxTrackedDeviceCount); // preserve previous tracking space m_prevTrackingSpace = trackingSpace; m_hasInputFocus = inputFocus; SteamVR_Events.InputFocus.AddListener(OnInputFocus); SteamVR_Events.System(EVREventType.VREvent_TrackedDeviceRoleChanged).AddListener(OnTrackedDeviceRoleChanged); s_moduleInstance = this; }
/// <summary> /// Sets all pose (and skeleton) actions to use the specified universe origin. /// </summary> protected static void SetUniverseOrigin(ETrackingUniverseOrigin newOrigin) { for (int actionIndex = 0; actionIndex < SteamVR_Input.actionsPose.Length; actionIndex++) { SteamVR_Input.actionsPose[actionIndex].sourceMap.SetTrackingUniverseOrigin(newOrigin); } for (int actionIndex = 0; actionIndex < SteamVR_Input.actionsSkeleton.Length; actionIndex++) { SteamVR_Input.actionsSkeleton[actionIndex].sourceMap.SetTrackingUniverseOrigin(newOrigin); } }
internal static InputPoseActionData_t GetPoseActionData(ulong actionHandle, ETrackingUniverseOrigin origin = ETrackingUniverseOrigin.TrackingUniverseStanding) { InputPoseActionData_t actionData = default; EVRInputError error = OpenVR.Input.GetPoseActionData(actionHandle, origin, 0, ref actionData, (uint)Marshal.SizeOf(typeof(InputPoseActionData_t)), OpenVR.k_ulInvalidInputValueHandle); if (error != EVRInputError.None && error != EVRInputError.NoData) { throw new OpenVRInputException($"Could not get pose data for action with handle {actionHandle}: {error}", error); } return(actionData); }
// Token: 0x06001EF8 RID: 7928 RVA: 0x0009CC28 File Offset: 0x0009AE28 public bool GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin, uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize, ref TrackedDevicePose_t pTrackedDevicePose) { if (Environment.OSVersion.Platform == PlatformID.MacOSX || Environment.OSVersion.Platform == PlatformID.Unix) { VRControllerState_t_Packed vrcontrollerState_t_Packed = new VRControllerState_t_Packed(pControllerState); CVRSystem.GetControllerStateWithPoseUnion getControllerStateWithPoseUnion; getControllerStateWithPoseUnion.pGetControllerStateWithPosePacked = null; getControllerStateWithPoseUnion.pGetControllerStateWithPose = this.FnTable.GetControllerStateWithPose; bool result = getControllerStateWithPoseUnion.pGetControllerStateWithPosePacked(eOrigin, unControllerDeviceIndex, ref vrcontrollerState_t_Packed, (uint)Marshal.SizeOf(typeof(VRControllerState_t_Packed)), ref pTrackedDevicePose); vrcontrollerState_t_Packed.Unpack(ref pControllerState); return(result); } return(this.FnTable.GetControllerStateWithPose(eOrigin, unControllerDeviceIndex, ref pControllerState, unControllerStateSize, ref pTrackedDevicePose)); }
//全デバイス情報を更新 public void Update(ETrackingUniverseOrigin origin = ETrackingUniverseOrigin.TrackingUniverseStanding) { allDevicePose = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount]; allDevicePoseRaw = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount]; if (!IsReady()) { return; } //すべてのデバイスの情報を取得 openvr.GetDeviceToAbsoluteTrackingPose(origin, PredictedTime, allDevicePose); openvr.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseRawAndUncalibrated, PredictedTime, allDevicePoseRaw); //最終更新フレームを更新 LastFrameCount = DateTime.Now.Ticks; }
private static bool GetControllerStateWithPose_Hooked(IntPtr instance, ETrackingUniverseOrigin eOrigin, uint unControllerDeviceIndex, IntPtr pControllerState, uint unControllerStateSize, IntPtr pTrackedDevicePose) { bool res = false; OpenVRInject This = (OpenVRInject)HookRuntimeInfo.Callback; try { var getControllerStateWithPose = Marshal.GetDelegateForFunctionPointer <vr_GetControllerStateWithPoseDelegate>(This.GetControllerStateWithPosePtr); res = getControllerStateWithPose(instance, eOrigin, unControllerDeviceIndex, pControllerState, unControllerStateSize, pTrackedDevicePose); This.SetControllerState(pControllerState, unControllerDeviceIndex); } catch { } return(res); }
public override void OnActivated() { var compositor = OpenVR.Compositor; if (compositor != null) { m_prevTrackingSpace = compositor.GetTrackingSpace(); UpdateTrackingSpaceType(); } #if VIU_STEAMVR_1_2_1_OR_NEWER SteamVR_Events.System(EVREventType.VREvent_TrackedDeviceRoleChanged).AddListener(OnTrackedDeviceRoleChanged); #elif VIU_STEAMVR_1_2_0_OR_NEWER SteamVR_Events.System("TrackedDeviceRoleChanged").AddListener(OnTrackedDeviceRoleChanged); #else SteamVR_Utils.Event.Listen("TrackedDeviceRoleChanged", OnTrackedDeviceRoleChangedArgs); #endif }
/// <summary> /// Set the overlay transform in SteamVR /// </summary> /// <param name="newPos">The new position</param> /// <param name="newRot">The new rotation</param> /// <param name="setTarget">Should this be the new target position, or is this temporary?</param> public void SetTransform(Vector3 newPos, Vector3 newRot, bool setTarget = true) { pos = newPos; rot = newRot; if (setTarget) { targetPos = newPos; targetRot = newRot; } matrixConverter.pos = newPos; matrixConverter.rot = Quaternion.Euler(newRot); _overlayTransform = matrixConverter.ToHmdMatrix34(); _overlayTransformAbsoluteTrackingOrigin = SteamVRManager.trackingSpace; if (!CheckValid()) { return; } switch (_overlayTransformType) { default: case VROverlayTransformType.VROverlayTransform_Absolute: error = OpenVR.Overlay.SetOverlayTransformAbsolute(handle, _overlayTransformAbsoluteTrackingOrigin, ref _overlayTransform); break; case VROverlayTransformType.VROverlayTransform_TrackedDeviceRelative: error = OpenVR.Overlay.SetOverlayTransformTrackedDeviceRelative(handle, _overlayTransformTrackedDeviceRelativeIndex, ref _overlayTransform); break; } }
public override void OnActivated() { m_digitalDataSize = (uint)Marshal.SizeOf(new InputDigitalActionData_t()); m_analogDataSize = (uint)Marshal.SizeOf(new InputAnalogActionData_t()); m_poses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount]; m_gamePoses = new TrackedDevicePose_t[0]; InitializeHandles(); #if VIU_STEAMVR_2_1_0_OR_NEWER SteamVR_Input.GetActionSet(ACTION_SET_NAME).Activate(SteamVR_Input_Sources.Any, 0, false); #else var actionSet = SteamVR_Input.GetActionSetFromPath(ACTION_SET_PATH); if (actionSet != null) { actionSet.ActivatePrimary(); } #endif #if VIU_STEAMVR_2_2_0_OR_NEWER SteamVR_Input.onNonVisualActionsUpdated += UpdateDeviceInput; SteamVR_Input.onPosesUpdated += UpdateDeviceConnectionAndPose; #else SteamVR_Input.OnNonVisualActionsUpdated += UpdateDeviceInput; SteamVR_Input.OnPosesUpdated += UpdateDeviceConnectionAndPose; #endif //s_devicePathHandles = new ulong[OpenVR.k_unMaxTrackedDeviceCount]; EnsureDeviceStateLength(8); // preserve previous tracking space m_prevTrackingSpace = trackingSpace; m_hasInputFocus = inputFocus; SteamVR_Events.InputFocus.AddListener(OnInputFocus); s_moduleInstance = this; m_submodules.ActivateAllModules(); }
protected virtual void UpdateControllerState() { lastcontrollerstate = controllerstate; //Update position. if (index > EIndex.Hmd) { ETrackingUniverseOrigin tracktype = OpenVR.Compositor.GetTrackingSpace(); TrackedDevicePose_t[] absoluteposes = new TrackedDevicePose_t[16]; openvrsystem.GetDeviceToAbsoluteTrackingPose(tracktype, 0, absoluteposes); TrackedDevicePose_t newposes = absoluteposes[(int)index]; OnNewPoses(newposes); } //We need to check for this always in case the user uses the deprecated GetVRButton methods. if (useLegacySteamVRInput) { openvrsystem.GetControllerState((uint)index, ref controllerstate, controllerstatesize); } }
public override void OnActivated() { var system = OpenVR.System; if (system != null) { m_hasInputFocus = !system.IsInputFocusCapturedByAnotherProcess(); } var compositor = OpenVR.Compositor; if (compositor != null) { m_prevTrackingSpace = compositor.GetTrackingSpace(); UpdateTrackingSpaceType(); } SteamVR_Events.InputFocus.AddListener(OnInputFocus); SteamVR_Events.System(EVREventType.VREvent_TrackedDeviceRoleChanged).AddListener(OnTrackedDeviceRoleChanged); }
/// <summary> /// Update loop that occasionally polls SteamVR components at <see cref="steamVRUpdateRate"/> /// </summary> /// <returns></returns> private IEnumerator SteamVRUpdateLoop() { while (!isConnected) { yield return(null); } while (true) { FetchDeviceIndexes(); yield return(null); HandleDisplayFrequency(); yield return(null); FetchPointerOffset(leftHandIndex, lPointerTrans); yield return(null); FetchPointerOffset(rightHandIndex, rPointerTrans); trackingSpace = OpenVR.Compositor.GetTrackingSpace(); //yield return null; yield return(new WaitForSeconds(steamVRUpdateRate / 2f)); HandleHMDWearing(); yield return(new WaitForSeconds(steamVRUpdateRate / 2f)); HandleHMDWearing(); } }
public override void OnActivated() { m_digitalDataSize = (uint)Marshal.SizeOf(new InputDigitalActionData_t()); m_analogDataSize = (uint)Marshal.SizeOf(new InputAnalogActionData_t()); m_originInfoSize = (uint)Marshal.SizeOf(new InputOriginInfo_t()); m_activeActionSetSize = (uint)Marshal.SizeOf(new VRActiveActionSet_t()); m_poses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount]; m_gamePoses = new TrackedDevicePose_t[0]; m_originDataCache = new Dictionary <ulong, OriginData>((int)OpenVR.k_unMaxActionOriginCount); InitializeHandles(); m_activeActionSets = new VRActiveActionSet_t[1] { new VRActiveActionSet_t() { ulActionSet = s_actionSetHandle, } }; SteamVR_Input.OnNonVisualActionsUpdated += UpdateDeviceInput; SteamVR_Input.OnPosesUpdated += UpdateDevicePose; s_devicePathHandles = new ulong[OpenVR.k_unMaxTrackedDeviceCount]; EnsureDeviceStateLength(OpenVR.k_unMaxTrackedDeviceCount); // preserve previous tracking space m_prevTrackingSpace = trackingSpace; m_hasInputFocus = inputFocus; SteamVR_Events.InputFocus.AddListener(OnInputFocus); SteamVR_Events.System(EVREventType.VREvent_TrackedDeviceRoleChanged).AddListener(OnTrackedDeviceRoleChanged); s_moduleInstance = this; }
internal static extern bool VR_IVRSystem_GetControllerStateWithPose(IntPtr instancePtr, ETrackingUniverseOrigin eOrigin, uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, ref TrackedDevicePose_t pTrackedDevicePose);
public abstract bool GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin,uint unControllerDeviceIndex,ref VRControllerState_t pControllerState,ref TrackedDevicePose_t pTrackedDevicePose);
public abstract EVROverlayError GetOverlayTransformAbsolute(ulong ulOverlayHandle,ref ETrackingUniverseOrigin peTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform);
internal static extern EVROverlayError VR_IVROverlay_GetOverlayTransformAbsolute(IntPtr instancePtr, ulong ulOverlayHandle, ref ETrackingUniverseOrigin peTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform);
public abstract void GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin,float fPredictedSecondsToPhotonsFromNow,TrackedDevicePose_t [] pTrackedDevicePoseArray);
// Token: 0x06001F53 RID: 8019 RVA: 0x0009D559 File Offset: 0x0009B759 public void SetTrackingSpace(ETrackingUniverseOrigin eOrigin) { this.FnTable.SetTrackingSpace(eOrigin); }
public override EVROverlayError GetOverlayTransformAbsolute(ulong ulOverlayHandle,ref ETrackingUniverseOrigin peTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform) { CheckIfUsable(); EVROverlayError result = VRNativeEntrypoints.VR_IVROverlay_GetOverlayTransformAbsolute(m_pVROverlay,ulOverlayHandle,ref peTrackingOrigin,ref pmatTrackingOriginToOverlayTransform); return result; }
public abstract EVROverlayError GetTransformForOverlayCoordinates(ulong ulOverlayHandle,ETrackingUniverseOrigin eTrackingOrigin,HmdVector2_t coordinatesInOverlay,ref HmdMatrix34_t pmatTransform);
internal static extern void VR_IVROverlay_SetKeyboardTransformAbsolute(IntPtr instancePtr, ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform);
public EVROverlayError GetOverlayTransformAbsolute(ulong ulOverlayHandle,ref ETrackingUniverseOrigin peTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform) { EVROverlayError result = FnTable.GetOverlayTransformAbsolute(ulOverlayHandle,ref peTrackingOrigin,ref pmatTrackingOriginToOverlayTransform); return result; }
public EVROverlayError GetTransformForOverlayCoordinates(ulong ulOverlayHandle,ETrackingUniverseOrigin eTrackingOrigin,HmdVector2_t coordinatesInOverlay,ref HmdMatrix34_t pmatTransform) { EVROverlayError result = FnTable.GetTransformForOverlayCoordinates(ulOverlayHandle,eTrackingOrigin,coordinatesInOverlay,ref pmatTransform); return result; }
public void SetTrackingSpace(ETrackingUniverseOrigin eOrigin) { FnTable.SetTrackingSpace(eOrigin); }
public bool GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin,uint unControllerDeviceIndex,ref VRControllerState_t pControllerState,ref TrackedDevicePose_t pTrackedDevicePose) { bool result = FnTable.GetControllerStateWithPose(eOrigin,unControllerDeviceIndex,ref pControllerState,ref pTrackedDevicePose); return result; }
public bool PollNextEventWithPose(ETrackingUniverseOrigin eOrigin,ref VREvent_t pEvent,uint uncbVREvent,ref TrackedDevicePose_t pTrackedDevicePose) { bool result = FnTable.PollNextEventWithPose(eOrigin,ref pEvent,uncbVREvent,ref pTrackedDevicePose); return result; }
public void GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin,float fPredictedSecondsToPhotonsFromNow,TrackedDevicePose_t [] pTrackedDevicePoseArray) { FnTable.GetDeviceToAbsoluteTrackingPose(eOrigin,fPredictedSecondsToPhotonsFromNow,pTrackedDevicePoseArray,(uint) pTrackedDevicePoseArray.Length); }
internal static extern EVROverlayError VR_IVROverlay_GetTransformForOverlayCoordinates(IntPtr instancePtr, ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, ref HmdMatrix34_t pmatTransform);
public bool IsOverlayVisible(ulong ulOverlayHandle) => default; // 0x00000001811DE880-0x00000001811DE8B0 public EVROverlayError GetTransformForOverlayCoordinates(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, ref HmdMatrix34_t pmatTransform) => default; // 0x00000001811DE730-0x00000001811DE760
public override bool PollNextEventWithPose(ETrackingUniverseOrigin eOrigin,ref VREvent_t pEvent,ref TrackedDevicePose_t pTrackedDevicePose) { CheckIfUsable(); bool result = VRNativeEntrypoints.VR_IVRSystem_PollNextEventWithPose(m_pVRSystem,eOrigin,ref pEvent,ref pTrackedDevicePose); return result; }
public override void SetTrackingSpace(ETrackingUniverseOrigin eOrigin) { CheckIfUsable(); VRNativeEntrypoints.VR_IVRCompositor_SetTrackingSpace(m_pVRCompositor,eOrigin); }
public void GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin universeOrigin, TrackedDevicePose_t[] poses) { OpenVR.System.GetDeviceToAbsoluteTrackingPose(universeOrigin, GetPredictedSecondsToPhotons(), poses); }
internal static extern void VR_IVRCompositor_SetTrackingSpace(IntPtr instancePtr, ETrackingUniverseOrigin eOrigin);
public override EVROverlayError GetTransformForOverlayCoordinates(ulong ulOverlayHandle,ETrackingUniverseOrigin eTrackingOrigin,HmdVector2_t coordinatesInOverlay,ref HmdMatrix34_t pmatTransform) { CheckIfUsable(); EVROverlayError result = VRNativeEntrypoints.VR_IVROverlay_GetTransformForOverlayCoordinates(m_pVROverlay,ulOverlayHandle,eTrackingOrigin,coordinatesInOverlay,ref pmatTransform); return result; }
internal static extern void VR_IVRSystem_GetDeviceToAbsoluteTrackingPose(IntPtr instancePtr, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, [In, Out] TrackedDevicePose_t[] pTrackedDevicePoseArray, uint unTrackedDevicePoseArrayCount);
public override void SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform) { CheckIfUsable(); VRNativeEntrypoints.VR_IVROverlay_SetKeyboardTransformAbsolute(m_pVROverlay,eTrackingOrigin,ref pmatTrackingOriginToKeyboardTransform); }
public abstract bool PollNextEventWithPose(ETrackingUniverseOrigin eOrigin,ref VREvent_t pEvent,ref TrackedDevicePose_t pTrackedDevicePose);
public static void SetTrackingSpace(ETrackingUniverseOrigin space) { Valve.VR.OpenVR.Compositor.SetTrackingSpace(space); }
public abstract void SetTrackingSpace(ETrackingUniverseOrigin eOrigin);
} // 0x00000001811DE790-0x00000001811DE7C0 public void SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform) { } // 0x00000001811DEB60-0x00000001811DEB90
internal static extern bool VR_IVRSystem_PollNextEventWithPose(IntPtr instancePtr, ETrackingUniverseOrigin eOrigin, ref VREvent_t pEvent, ref TrackedDevicePose_t pTrackedDevicePose);
public EVROverlayError SetOverlayTransformAbsolute(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform) => default; // 0x00000001811DEED0-0x00000001811DEF00 public EVROverlayError GetOverlayTransformAbsolute(ulong ulOverlayHandle, ref ETrackingUniverseOrigin peTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform) => default; // 0x00000001811DE5E0-0x00000001811DE610
public override void GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin,float fPredictedSecondsToPhotonsFromNow,TrackedDevicePose_t [] pTrackedDevicePoseArray) { CheckIfUsable(); VRNativeEntrypoints.VR_IVRSystem_GetDeviceToAbsoluteTrackingPose(m_pVRSystem,eOrigin,fPredictedSecondsToPhotonsFromNow,pTrackedDevicePoseArray,(uint) pTrackedDevicePoseArray.Length); }
public abstract void SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform);
public override bool GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin,uint unControllerDeviceIndex,ref VRControllerState_t pControllerState,ref TrackedDevicePose_t pTrackedDevicePose) { CheckIfUsable(); bool result = VRNativeEntrypoints.VR_IVRSystem_GetControllerStateWithPose(m_pVRSystem,eOrigin,unControllerDeviceIndex,ref pControllerState,ref pTrackedDevicePose); return result; }
public EVROverlayError GetTransformForOverlayCoordinates(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, ref HmdMatrix34_t pmatTransform) { return(this.FnTable.GetTransformForOverlayCoordinates(ulOverlayHandle, eTrackingOrigin, coordinatesInOverlay, ref pmatTransform)); }
public void SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform) { FnTable.SetKeyboardTransformAbsolute(eTrackingOrigin,ref pmatTrackingOriginToKeyboardTransform); }
public void SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform) { this.FnTable.SetKeyboardTransformAbsolute(eTrackingOrigin, ref pmatTrackingOriginToKeyboardTransform); }