add IsPosition/RotationAvailable and tracking accuracy

Author: David Kline (ANALOG)

Assets/MixedRealityToolkit/_Core/Definitions/Devices/Headset.cs

@@ -21,16 +21,36 @@ public struct Headset
         /// </summary>
         public SDKType HeadsetSDKType { get; set; }
 
+        /// <summary>
+        /// Indicates whether or not the headset is currently providing position data.
+        /// </summary>
+        public bool IsPositionAvailable { get; set; }
+
         /// <summary>
         /// Outputs the current position of the headset, as defined by the SDK / Unity.
         /// </summary>
         public Vector3 Position { get; set; }
 
+        /// <summary>
+        /// Indicates the accuracy of the position data being reported.
+        /// </summary>
+        public TrackingAccuracy PositionAccuracy { get; set; }
+
+        /// <summary>
+        /// Indicates whether or not the headset is currently providing rotation data.
+        /// </summary>
+        public bool IsRotationAvailable { get; set; }
+
         /// <summary>
         /// Outputs the current rotation of the headset, as defined by the SDK / Unity.
         /// </summary>
         public Quaternion Rotation { get; set; }
 
+        /// <summary>
+        /// Indicates the accuracy of the rotation data being reported.
+        /// </summary>
+        public TrackingAccuracy RotationAccuracy { get; set; }
+
         /// <summary>
         /// Outputs the current state of the headset, whether it is tracked or not. As defined by the SDK / Unity.
         /// </summary>

Assets/MixedRealityToolkit/_Core/Definitions/Devices/TrackingAccuracy.cs

@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace Microsoft.MixedReality.Toolkit.Internal.Definitions.Devices
+{
+    /// <summary>
+    /// The Tracking State defines how a device is currently being tracked.
+    /// This enables developers to be able to handle non-tracked situations and react accordingly
+    /// </summary>
+    public enum TrackingAccuracy
+    {
+        /// <summary>
+        /// There is no accuracy data for this device.
+        /// </summary>
+        /// <remarks>
+        /// This indicates that the device is either not tracked or does not support tracking. The level
+        /// of accuracy is defined by the device's platform or driver and may vary by, for example, the 
+        /// distance between values returned (ex: degrees of rotation or physical distance of position).
+        /// </remarks>
+        None = 0,
+        /// <summary>
+        /// The device is returning approximate data.
+        /// </summary>
+        /// <remarks>
+        /// Approximate accuracy generally implies that the device is not
+        /// visible to sensors and that the system is inferring the data by
+        /// other means.
+        /// </remarks>
+        Approximate,
+        /// <summary>
+        /// The device is returning a low level of accuracy.
+        /// </summary>
+        Low,
+        /// <summary>
+        /// The device is returning a medium level of accuracy.
+        /// </summary>
+        Medium,
+        /// <summary>
+        /// The device is returning a high level of accuracy.
+        /// </summary>
+        High
+    }
+}

Assets/MixedRealityToolkit/_Core/Definitions/Devices/TrackingAccuracy.cs.meta

@@ -4,26 +4,33 @@
 namespace Microsoft.MixedReality.Toolkit.Internal.Definitions.Devices
 {
     /// <summary>
-    /// The Tracking State defines how a controller or headset is currently being tracked.
-    /// This enables developers to be able to handle non-tracked situations and react accordingly
+    /// The Tracking State defines how a device is currently being tracked.
+    /// This enables developers to be able to handle non-tracked situations and react accordingly.
     /// </summary>
+    /// <remarks>
+    /// Tracking is being defined as receiving sensor (positional and/or rotational) data from the device.
+    /// </remarks>
     public enum TrackingState
     {
         /// <summary>
-        /// The controller is currently not tracked.
+        /// The device does not support tracking (ex: a traditional game controller).
         /// </summary>
-        NotTracked = 0,
+        NotApplicable = 0,
         /// <summary>
-        /// The controller is tracked, but has approximate positioning.
+        /// Reserved, for systems that provide alternate tracking.
         /// </summary>
-        Approximate,
+        Other,
         /// <summary>
-        /// The controller is currently fully tracked and has accurate positioning.
+        /// The device is not tracked.
         /// </summary>
-        Tracked,
+        NotTracked,
         /// <summary>
-        /// Reserved, for systems that provide alternate tracking.
+        /// The device is tracked (positionally and/or rotationally).
         /// </summary>
-        Other,
+        /// <remarks>
+        /// Some devices provide additional details regarding the accuracy of the tracking.
+        /// <See cref="Definitions.Devices.TrackingAccuracy"/> for more information.
+        /// </remarks>
+        Tracked
     }
 }

Assets/MixedRealityToolkit/_Core/Definitions/Devices/TrackingState.cs

@@ -29,6 +29,11 @@ protected BaseController(TrackingState trackingState, Handedness controllerHande
             ControllerHandedness = controllerHandedness;
             InputSource = inputSource;
             Interactions = interactions;
+
+            IsPositionAvailable = false;
+            PositionAccuracy = TrackingAccuracy.None;
+            IsRotationAvailable = false;
+            RotationAccuracy = TrackingAccuracy.None;
         }
 
         /// <summary>
@@ -58,6 +63,18 @@ protected IMixedRealityInputSystem InputSystem
         /// <inheritdoc />
         public IMixedRealityInputSource InputSource { get; }
 
+        /// <inheritdoc />
+        public bool IsPositionAvailable { get; protected set; }
+
+        /// <inheritdoc />
+        public TrackingAccuracy PositionAccuracy { get; protected set; }
+
+        /// <inheritdoc />
+        public bool IsRotationAvailable { get; protected set; }
+
+        /// <inheritdoc />
+        public TrackingAccuracy RotationAccuracy { get; protected set; }
+
         /// <inheritdoc />
         public MixedRealityInteractionMapping[] Interactions { get; private set; }
 

Assets/MixedRealityToolkit/_Core/Devices/BaseController.cs

@@ -38,6 +38,9 @@ public WindowsMixedRealityController(TrackingState trackingState, Handedness con
         /// </summary>
         public InteractionSourceState LastSourceStateReading { get; private set; }
 
+        private Vector3 currentControllerPosition = Vector3.zero;
+        private Quaternion currentControllerRotation = Quaternion.identity;
+
         private Vector3 currentPointerPosition = Vector3.zero;
         private Quaternion currentPointerRotation = Quaternion.identity;
         private MixedRealityPose currentPointerData = new MixedRealityPose(Vector3.zero, Quaternion.identity);
@@ -96,6 +99,8 @@ public void UpdateController(InteractionSourceState interactionSourceState)
                         throw new ArgumentOutOfRangeException();
                 }
             }
+
+            LastSourceStateReading = interactionSourceState;
         }
 
         /// <summary>
@@ -104,24 +109,26 @@ public void UpdateController(InteractionSourceState interactionSourceState)
         /// <param name="interactionSourceState">The InteractionSourceState retrieved from the platform</param>
         private void UpdateControllerData(InteractionSourceState interactionSourceState)
         {
-            LastSourceStateReading = interactionSourceState;
             var lastState = TrackingState;
 
-            switch (interactionSourceState.sourcePose.positionAccuracy)
+            IsPositionAvailable = interactionSourceState.sourcePose.TryGetPosition(out currentControllerPosition);
+            if (IsPositionAvailable)
             {
-                case InteractionSourcePositionAccuracy.None:
-                    TrackingState = TrackingState.NotTracked;
-                    break;
-                case InteractionSourcePositionAccuracy.Approximate:
-                    TrackingState = TrackingState.Approximate;
-                    break;
-                case InteractionSourcePositionAccuracy.High:
-                    TrackingState = TrackingState.Tracked;
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException();
+                PositionAccuracy = (interactionSourceState.sourcePose.positionAccuracy == InteractionSourcePositionAccuracy.High) ?
+                    TrackingAccuracy.High : TrackingAccuracy.Approximate;
+            }
+            else
+            {
+                PositionAccuracy = TrackingAccuracy.None;
             }
 
+            IsRotationAvailable = interactionSourceState.sourcePose.TryGetRotation(out currentControllerRotation);
+            // Windows Mixed Reality does not have a concept of rotation accuracy, therefore we return high accuracy
+            RotationAccuracy = IsRotationAvailable ? TrackingAccuracy.High : TrackingAccuracy.None;
+
+            // Windows Mixed Reality controllers are tracked if we are receiving position or rotation data
+            TrackingState = (IsPositionAvailable || IsRotationAvailable) ? TrackingState.Tracked : TrackingState.NotTracked;
+
             if (lastState != TrackingState)
             {
                 InputSystem?.RaiseSourceTrackingStateChanged(InputSource, this, TrackingState);

Assets/MixedRealityToolkit/_Core/Devices/MixedReality/WindowsMixedRealityController.cs

@@ -27,6 +27,34 @@ public interface IMixedRealityController
         /// </summary>
         IMixedRealityInputSource InputSource { get; }
 
+        /// <summary>
+        /// Indicates that this controller is currently providing position data.
+        /// </summary>
+        /// <remarks>
+        /// This value may change during usage for some controllers. As a best practice,
+        /// be sure to check this value before using position data.
+        /// </remarks>
+        bool IsPositionAvailable { get; }
+
+        /// <summary>
+        /// Indicates the accuracy of the position data being reported.
+        /// </summary>
+        TrackingAccuracy PositionAccuracy { get; }
+
+        /// <summary>
+        /// Indicates that this controller is currently providing rotation data.
+        /// </summary>
+        /// <remarks>
+        /// This value may change during usage for some controllers. As a best practice,
+        /// be sure to check this value before using rotation data.
+        /// </remarks>
+        bool IsRotationAvailable { get; }
+
+        /// <summary>
+        /// Indicates the accuracy of the rotation data being reported.
+        /// </summary>
+        TrackingAccuracy RotationAccuracy { get; }
+
         /// <summary>
         /// Mapping definition for this controller, linking the Physical inputs to logical Input System Actions
         /// </summary>