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