/// Utility helper to migrate from TrackingSpace to TrackingOrigin seamlessly void UpgradeTrackingSpaceToTrackingOriginMode() { #if UNITY_2019_3_OR_NEWER // Disable Obsolete warnings for TrackingSpaceType, explicitly to allow a proper upgrade path. #pragma warning disable 0618 if (m_TrackingOriginMode == TrackingOriginModeFlags.Unknown && m_TrackingSpace <= TrackingSpaceType.RoomScale) { switch (m_TrackingSpace) { case TrackingSpaceType.RoomScale: { m_TrackingOriginMode = TrackingOriginModeFlags.Floor; break; } case TrackingSpaceType.Stationary: { m_TrackingOriginMode = TrackingOriginModeFlags.Device; break; } default: break; } // Tag is Invalid not to be used. m_TrackingSpace = (TrackingSpaceType)3; #if UNITY_EDITOR EditorUtility.SetDirty(this); #endif //UNITY_EDITOR #pragma warning restore 0618 } #endif //UNITY_2019_3_OR_NEWER }
IEnumerator changeOriginModeRoutine(TrackingOriginModeFlags trackingOrigin) { // Wait one frame as Unity has an issue with calling this immediately yield return(null); List <XRInputSubsystem> subsystems = new List <XRInputSubsystem>(); SubsystemManager.GetInstances(subsystems); int subSystemsCount = subsystems.Count; if (subSystemsCount > 0) { for (int x = 0; x < subSystemsCount; x++) { if (subsystems[x].TrySetTrackingOriginMode(trackingOrigin)) { Debug.Log("Successfully set TrackingOriginMode to " + trackingOrigin); } else { Debug.Log("Failed to set TrackingOriginMode to " + trackingOrigin); } } } else { #if UNITY_2020 Debug.LogWarning("No subsystems detected. Unable to set Tracking Origin to " + trackingOrigin); #endif } }
void Update() { XRInputSubsystem subsystem = null; SubsystemManager.GetInstances(s_InputSubsystems); if (s_InputSubsystems.Count > 0) { subsystem = s_InputSubsystems[0]; } m_SupportedTrackingOriginModes = subsystem?.GetSupportedTrackingOriginModes() ?? TrackingOriginModeFlags.Unknown; if (m_CurrentTrackingOriginMode != m_DesiredTrackingOriginMode & m_DesiredTrackingOriginMode != TrackingOriginModeFlags.Unknown) { subsystem?.TrySetTrackingOriginMode(m_DesiredTrackingOriginMode); } m_CurrentTrackingOriginMode = subsystem?.GetTrackingOriginMode() ?? TrackingOriginModeFlags.Unknown; if (m_CurrentTrackingOriginModeDisplay != null) { m_CurrentTrackingOriginModeDisplay.text = m_CurrentTrackingOriginMode.ToString(); } if (m_RecenteredImage != null) { float lerp = (Time.time - m_LastRecenteredTime) / m_RecenteredColorResetTime; lerp = Mathf.Clamp(lerp, 0.0f, 1.0f); m_RecenteredImage.color = Color.Lerp(m_RecenteredColor, m_RecenteredOffColor, lerp); } }
public void SetTrackingOrigin(TrackingOriginModeFlags trackingOrigin) { // Set to Floor Mode List <XRInputSubsystem> subsystems = new List <XRInputSubsystem>(); SubsystemManager.GetInstances(subsystems); for (int i = 0; i < subsystems.Count; i++) { subsystems[i].TrySetTrackingOriginMode(trackingOrigin); } }
private void UpdateTrackingOrigin(TrackingOriginModeFlags trackingOriginModeFlags) { m_TrackingOriginMode = trackingOriginModeFlags; if (m_CameraFloorOffsetObject != null) { m_CameraFloorOffsetObject.transform.localPosition = new Vector3( m_CameraFloorOffsetObject.transform.localPosition.x, m_TrackingOriginMode == TrackingOriginModeFlags.Device ? cameraYOffset : 0.0f, m_CameraFloorOffsetObject.transform.localPosition.z); } }
public virtual void SetTrackingOriginMode(TrackingOriginModeFlags trackingOrigin) { #if UNITY_2019_4 // 2019.4 Needs to use XRDevice.SetTrackingSpaceType; TrySetTrackingOriginMode does not function properly. if (trackingOrigin == TrackingOriginModeFlags.Floor) { XRDevice.SetTrackingSpaceType(TrackingSpaceType.RoomScale); } #endif // Any other versions (including 2019.4) may go ahead and use TrySetTrackingSpaceType StartCoroutine(changeOriginModeRoutine(trackingOrigin)); }
public static void SetTrackingOrigin(TrackingOriginModeFlags trackingOriginMode) { List <XRInputSubsystem> subsystems = new List <XRInputSubsystem>(); SubsystemManager.GetInstances <XRInputSubsystem>(subsystems); for (int i = 0; i < subsystems.Count; i++) { if (subsystems[i].GetTrackingOriginMode() != trackingOriginMode) { subsystems[i].TrySetTrackingOriginMode(trackingOriginMode); } } }
private void SetAllXRInputSubsystemTrackingOriginMode(TrackingOriginModeFlags mode) { List <XRInputSubsystem> systems = new List <XRInputSubsystem>(); SubsystemManager.GetInstances(systems); foreach (XRInputSubsystem system in systems) { if (!system.TrySetTrackingOriginMode(mode)) { Debug.LogWarning("Failed to set TrackingOriginModeFlags to XRInputSubsystem: " + system.SubsystemDescriptor.id); } } }
void SetToNextMode(XRInputSubsystem subsystem) { TrackingOriginModeFlags currentOriginMode = subsystem.GetTrackingOriginMode(); for (int i = 0; i < s_SupportedTrackingOriginModes.Count; i++) { if (currentOriginMode == s_SupportedTrackingOriginModes[i]) { int nextModeIndex = (i + 1) % s_SupportedTrackingOriginModes.Count; subsystem.TrySetTrackingOriginMode(s_SupportedTrackingOriginModes[nextModeIndex]); break; } } }
void UpdateSupportedTrackingOriginModes(XRInputSubsystem subsystem) { TrackingOriginModeFlags supportedOriginModes = subsystem.GetSupportedTrackingOriginModes(); s_SupportedTrackingOriginModes.Clear(); for (int i = 0; i < 31; i++) { uint modeToCheck = 1u << i; if ((modeToCheck & ((UInt32)supportedOriginModes)) != 0) { s_SupportedTrackingOriginModes.Add((TrackingOriginModeFlags)modeToCheck); } } }
public void UpdateAvailableOriginType() { string accumulation = ""; TrackingOriginModeFlags AvailableOrigins = m_InputSubsystem.GetSupportedTrackingOriginModes(); foreach (TrackingOriginModeFlags type in Enum.GetValues(typeof(TrackingOriginModeFlags))) { if ((AvailableOrigins & type) != 0) { accumulation += type.ToString() + ", "; } } availableOriginType.text = accumulation; }
/// <summary> /// Sets the tracking mode of all currently initialized XR Subsystems to the origin specified. /// </summary> public void SetTrackingModeTo(TrackingOriginModeFlags flags, bool recenter) { List<XRInputSubsystem> subsystems = new List<XRInputSubsystem>(); SubsystemManager.GetInstances(subsystems); foreach (var subsystem in subsystems) { if (subsystem.TrySetTrackingOriginMode(flags)) { if (recenter) { // Now that we've changed the origin mode we'll have to recalibrate to this new point // in space (it will re-zero off of the last-set-height, which for Oculus Quest is the // HMD boot position). subsystem.TryRecenter(); } } else { Debug.LogError("Failed to set the TrackingOriginMode of id:" + subsystem.SubsystemDescriptor.id, gameObject); } } }
private IEnumerator UpdateTrackingOrigin(TrackingOriginModeFlags originFlags) { yield return(null); #if USING_XR_MANAGEMENT var subsystems = new List <XRInputSubsystem>(); SubsystemManager.GetInstances <XRInputSubsystem>(subsystems); Debug.Log("Found " + subsystems.Count + " input subsystems."); for (int i = 0; i < subsystems.Count; i++) { if (subsystems[i].TrySetTrackingOriginMode(originFlags)) { Debug.Log("Successfully set TrackingOriginMode to Floor"); } else { Debug.Log("Failed to set TrackingOriginMode to Floor"); } } #elif !UNITY_2020_1_OR_NEWER if (originFlags == TrackingOriginModeFlags.Floor) { #pragma warning disable 0618 if (XRDevice.SetTrackingSpaceType(TrackingSpaceType.RoomScale)) { Debug.Log("Tracking change to RoomScale."); } else { Debug.Log("Failed Tracking change to RoomScale."); } } else { XRDevice.SetTrackingSpaceType(TrackingSpaceType.Stationary); #pragma warning restore 0618 Debug.Log("Tracking change to stationary."); } #endif }
private static void SetAllXRInputSubsystemTrackingOriginMode(TrackingOriginModeFlags value) { var activeSubsys = ListPool <XRInputSubsystem> .Get(); try { SubsystemManager.GetInstances(activeSubsys); foreach (var subsys in activeSubsys) { if (!subsys.running) { continue; } if (!subsys.TrySetTrackingOriginMode(value)) { Debug.LogWarning("Failed to set TrackingOriginModeFlags(" + value + ") to XRInputSubsystem: " + subsys.SubsystemDescriptor.id); } } } finally { ListPool <XRInputSubsystem> .Release(activeSubsys); } }
private bool TrySetTrackingOriginModeOnAllXRInputSystems(TrackingOriginModeFlags trackingOriginMode) { if (XRSubsystemHelpers.InputSubsystem != null && XRSubsystemHelpers.InputSubsystem.TrySetTrackingOriginMode(trackingOriginMode)) { return(true); } #if UNITY_2019_3_OR_NEWER // If the "main" input subsystem can't set the origin mode, check the rest of them SubsystemManager.GetInstances(XRInputSubsystems); foreach (XRInputSubsystem xrInputSubsystem in XRInputSubsystems) { if (xrInputSubsystem.running && xrInputSubsystem.TrySetTrackingOriginMode(trackingOriginMode)) { return(true); } } #endif // UNITY_2019_3_OR_NEWER return(false); }
public void UpdateCurrentOriginType(TrackingOriginModeFlags targetTrackingOriginMode) { Debug.Log((uint)targetTrackingOriginMode); Debug.Log(OnlyOneBitSet((uint)targetTrackingOriginMode)); if (!(OnlyOneBitSet((uint)targetTrackingOriginMode)) && (targetTrackingOriginMode != TrackingOriginModeFlags.Unknown)) { if (m_InputSubsystem.TrySetTrackingOriginMode(targetTrackingOriginMode)) { SetStatus("Error! Tracking mode set to multiple values!"); return; } } if (!m_InputSubsystem.TrySetTrackingOriginMode(targetTrackingOriginMode) && ((targetTrackingOriginMode & m_InputSubsystem.GetSupportedTrackingOriginModes()) != 0)) { SetStatus("Error! Tracking mode could not be set!"); return; } currentOriginType.text = m_InputSubsystem.GetTrackingOriginMode().ToString(); if ((m_InputSubsystem.GetTrackingOriginMode() & m_InputSubsystem.GetSupportedTrackingOriginModes()) == 0) { SetStatus("Error! Tracking mode set to an unsupported mode!"); } else if (targetTrackingOriginMode != m_InputSubsystem.GetTrackingOriginMode()) { SetStatus("Success! Tracking mode not set to an unsupported mode!"); } else { SetStatus("Success! Tracking mode set to a supported mode!"); } }
bool SetupCamera(XRInputSubsystem subsystem) { if (subsystem == null) { return(false); } bool trackingSettingsSet = false; var currentMode = subsystem.GetTrackingOriginMode(); var supportedModes = subsystem.GetSupportedTrackingOriginModes(); TrackingOriginModeFlags requestedMode = TrackingOriginModeFlags.Unknown; // map between the user requested options, and the actual options. if (m_RequestedTrackingMode == UserRequestedTrackingMode.Default) { requestedMode = currentMode; } else if (m_RequestedTrackingMode == UserRequestedTrackingMode.Device) { requestedMode = TrackingOriginModeFlags.Device; } else if (m_RequestedTrackingMode == UserRequestedTrackingMode.Floor) { requestedMode = TrackingOriginModeFlags.Floor; } else { Debug.LogWarning("Unknown Requested Tracking Mode"); } // now we've mapped em. actually go set em. if (requestedMode == TrackingOriginModeFlags.Floor) { // We need to check for Unknown because we may not be in a state where we can read this data yet. if ((supportedModes & (TrackingOriginModeFlags.Floor | TrackingOriginModeFlags.Unknown)) == 0) { Debug.LogWarning("CameraOffset.SetupCamera: Attempting to set the tracking space to Floor, but that is not supported by the SDK."); } else { trackingSettingsSet = subsystem.TrySetTrackingOriginMode(requestedMode); } } else if (requestedMode == TrackingOriginModeFlags.Device) { // We need to check for Unknown because we may not be in a state where we can read this data yet. if ((supportedModes & (TrackingOriginModeFlags.Device | TrackingOriginModeFlags.Unknown)) == 0) { Debug.LogWarning("CameraOffset.SetupCamera: Attempting to set the tracking space to Device, but that is not supported by the SDK."); } else { trackingSettingsSet = subsystem.TrySetTrackingOriginMode(requestedMode) && subsystem.TryRecenter(); } } if (trackingSettingsSet) { UpdateTrackingOrigin(subsystem.GetTrackingOriginMode()); } return(trackingSettingsSet); }
bool SetupCamera(XRInputSubsystem subsystem) { if (subsystem == null) { return(false); } bool trackingSettingsSet = false; float desiredOffset = cameraYOffset; var currentMode = subsystem.GetTrackingOriginMode(); var supportedModes = subsystem.GetSupportedTrackingOriginModes(); TrackingOriginModeFlags requestedMode = TrackingOriginModeFlags.Unknown; // map between the user requested options, and the actual options. if (m_RequestedTrackingMode == UserRequestedTrackingMode.Default) { requestedMode = currentMode; } else if (m_RequestedTrackingMode == UserRequestedTrackingMode.Device) { requestedMode = TrackingOriginModeFlags.Device; } else if (m_RequestedTrackingMode == UserRequestedTrackingMode.Floor) { requestedMode = TrackingOriginModeFlags.Floor; } else { Debug.LogWarning("Unknown Requested Tracking Mode"); } // now we've mapped em. actually go set em. if (requestedMode == TrackingOriginModeFlags.Floor) { // We need to check for Unknown because we may not be in a state where we can read this data yet. if ((supportedModes & (TrackingOriginModeFlags.Floor | TrackingOriginModeFlags.Unknown)) == 0) { Debug.LogWarning("CameraOffset.SetupCamera: Attempting to set the tracking space to Floor, but that is not supported by the SDK."); m_TrackingOriginMode = subsystem.GetTrackingOriginMode(); return(true); } if (subsystem.TrySetTrackingOriginMode(requestedMode)) { desiredOffset = 0.0f; trackingSettingsSet = true; } } else if (requestedMode == TrackingOriginModeFlags.Device) { // We need to check for Unknown because we may not be in a state where we can read this data yet. if ((supportedModes & (TrackingOriginModeFlags.Device | TrackingOriginModeFlags.Unknown)) == 0) { Debug.LogWarning("CameraOffset.SetupCamera: Attempting to set the tracking space to Device, but that is not supported by the SDK."); m_TrackingOriginMode = subsystem.GetTrackingOriginMode(); return(true); } if (subsystem.TrySetTrackingOriginMode(requestedMode)) { trackingSettingsSet = subsystem.TryRecenter(); } } // what did we actually set? m_TrackingOriginMode = subsystem.GetTrackingOriginMode(); if (trackingSettingsSet) { // Move camera to correct height if (m_CameraFloorOffsetObject) { m_CameraFloorOffsetObject.transform.localPosition = new Vector3(m_CameraFloorOffsetObject.transform.localPosition.x, desiredOffset, m_CameraFloorOffsetObject.transform.localPosition.z); } } return(trackingSettingsSet); }
/// <summary> /// Checks to determine if all bits in a provided mask are set. /// </summary> /// <param name="a"><see cref="TrackingOriginModeFlags"/> value.</param> /// <param name="b"><see cref="TrackingOriginModeFlags"/> mask.</param> /// <returns> /// True if all of the bits in the specified mask are set in the current value. /// </returns> public static bool IsMaskSet(this TrackingOriginModeFlags a, TrackingOriginModeFlags b) { return((a & b) == b); }
public extern bool TrySetTrackingOriginMode(TrackingOriginModeFlags origin);