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);
}
