XR Floor Position Native Unity

Helllooooo,
This has to do with default behaviour if each platform. We have a couple APIs in XRDevice that we are still in the process of migrating up to our InputDevice API level, called [XR.XRDevice.SetTrackingSpaceType] and [XR.XRDevice.GetTrackingSpaceType]. These adjust what we report devices relative to, namely whether it's relative to the floor, or relative to the device at it's initial position. In your case Oculus is defaulting to using the Stationary tracking space type, which is device starting point relative. If you call SetTrackingSpaceType with the RoomScale type, it will bump it upwards to be floor relative. I believe OpenVR defaults to highest available, so RoomScale if a proper bounds were set.

That should work for now, once we move that logic to the InputDevice APIs you will get a clear, concise obsolescence warning of the new API to use.

Edit: Just reread the final question again. You should be able to set it to either mode on application start to enforce some consistency. More platforms support the Stationary mode (tracked devices reported relative to the device on startup mode) than roomscale, so if that works for you, then I'd suggest it.

 

Looking into it.
It was actually a bit of surprise, some of my colleagues was convinced that Oculus would start with the highest level available (i.e. floor-relative if available). We are going over this for Input Device, and hopefully can find a good cross-platform way to always start with positions local to floor if that mode is available.

 

Hi
Just noticed the Scripting Reference doesn't pick up the in-code ObsoleteAttribute tags I added. Will work to get those added to the scripting reference, since that is the first places users may look.

You are on the right track: In order to get the floor height, you need to set the device's origin to the floor. That way the 0,0,0 point of the device is no longer wherever the device was at the last Recenter or on App Start, but is located somewhere on the floor.

Once set, you can deduce the player's height by asking them to stand and getting the device's Y-height. At least that is the height of his eyes.

As we are moving to the new Plugin Architecture, we now use a concept of Subsystems. In this case, the XRInputSubsystem has a concept of TrackingOriginMode. Someone just linked a quick example of setting the XRInputSubsystem's TrackingOriginMode: https://forum.unity.com/threads/any...-1-xr-input-system.629824/page-2#post-5438118

Rewritten for Floor:

Code (CSharp):

1. List<XRInputSubsystem> subsystems = new List<XRInputSubsystem>();
2. SubsystemManager.GetInstances<XRInputSubsystem>(subsystems);
3. for (int i = 0; i < subsystems.Count; i++)
4. {
5.    subsystems[i].TrySetTrackingOriginMode(TrackingOriginModeFlags.Floor);
6. }
7.  

TrackingOriginModeFlags has 3 settings:
Device places the origin at scene start position and Yaw.
Floor picks a spot on the floor, SDK set but normally the center of the tracking boundary as the Origin. Recenter may change the Yaw or position, but the Y=0 will always be the floor.
TrackingReference uses a fixed tracking object as the origin, think tracking sensor. Probably not something you need to worry about at this time.

Let me know if this gets you back on track!

 

@unitylepi
Which XR Platforms are you targeting? (e.g. WMR, Oculus, OpenVR)

 

Hello, the replacement is in the XRInputSubsystem. Here is a short snippet. Each platform sets it's own default, but if you want a floor height tracking, here is a quick example:

Code (CSharp):

1. // Use a cache to be heap efficient, not necessary if you only call on startup.
2. static List<XRInputSubsystem> k_CachedSubsystems = new List<XRInputSubsystem>();
3. XRInputSubsystem m_InputSubsystem;
4.  
5. public void SetTrackingOriginMode()
6. {
7.     if (m_InputSubsystem == null)
8.     {
9.         SubsystemManager.GetInstances(k_CachedSubsystems);
10.         if (k_CachedSubsystems.Count != 0)
11.             m_InputSubsystem = k_CachedSubsystems[0];
12.     }
13.  
14.     Debug.Log($"Tracking Origin Mode is [{m_InputSubsystem.GetTrackingOriginMode()}]");
15.     if (m_InputSubsystem.TrySetTrackingOriginMode(TrackingOriginModeFlags.Floor))
16.         Debug.Log($"Successfully set tracking origin mode to [{m_InputSubsystem.GetTrackingOriginMode()}]");
17.     else
18.         Debug.Log("Failed to set tracking origin mode");
19. }

Keep in mind not all platforms support all tracking modes. We have packages such as the XR Interaction Toolkit that comes with a rig that is able to set to floor mode, but if not available use a simulated player height, to keep the view up off the floor.

 

This is because the default tracking origin for different platforms is different.
The origin represents a fixed point in the real world. All tracking values, like the position or rotation of a headset are reported relative to this fixed point. So when a controller's position in Unity is [0.0, 1.5, 1.0], that controller is physically 1.5 meters above, and 1 meter in front of this invisible, fixed point. Depending on the SDK, that fixed point can be the location of the headset when the application started (Device tracking origin), a location on the floor that is either at the center of a tracking boundary, or directly below the headset on application start if no boundary is set (Floor tracking origin), or it can be a nearby point in space selected by the SDK and updated based on distance from previous origin (Unbounded tracking origin). It sounds like sometimes you are using an SDK set to use the 'Floor' tracking origin. This puts the 0,0,0 point where you'd expect the headset to be, and then places the actual headset way above that, up to 2m if you are tall (and standing). Sometimes it can be off to the left or right, especially if your setup is like mine and the actual space that I sit down is often far from the center of the tracking boundary. It sounds like you are expecting it to be in Device tracking origin mode, where the headset starts at that 0,0,0 point.

I would suggest setting the tracking origin to Device on startup (using the sample above). As well, what you are doing with the Holder object is a good practice. In the XR Interaction Toolkit the same 'holder' object is called a player rig. It let's you treat the entire real world tracking space as a single game object. Want to move the real world tracked objects? Just move the holder! This type of movement, where you move the rig or holder object in such a way that you have the tracked headset in the *actual* desired location, is a common technique, and how the XR Interaction Toolkit, and other locomotion systems handle VR teleportation.

If you want to go a little further than that, you can listen for a change in user presence. Something like this:

Code (CSharp):

1. bool userWasPresent;
2.        
3.         void Update()
4.         {
5.             // First we get a headset
6.             var device = InputDevices.GetDeviceAtXRNode(XRNode.Head);
7.             if (!device.isValid)
8.             {
9.                 userWasPresent = false;
10.                 return;
11.             }
12.            
13.             // Then we see if this device has a user presence sensor. If not, we assume the user is always present.
14.             var userPresent = true;
15.             if (device.TryGetFeatureValue(CommonUsages.userPresence, out bool featureValue))
16.                 userPresent = featureValue;
17.  
18.             // Headset JUST put on this frame. Also triggered the first frame
19.             if (!userWasPresent & userPresent)
20.                 ResetPosition();
21.            
22.             userWasPresent = userPresent;
23.         }

This should perform a reset the first frame that a headset is available. As well, if the device supports user presence, will also perform a reset for the first frame that the headset is put on. This means if they remove the headset, put it down for a moment, and put it back on, you can detect that and make sure the scene is right in front of the user on that first frame he's back in the world.

 

so, you can ask the device to be in a particular mode via code, or using the XR Rig (in either the XR Interaction Toolkit or the Legacy Input Helpers package.

the function call is
https://docs.unity3d.com/2019.1/Documentation/ScriptReference/XR.TrackingOriginMode.html