Merge pull request #2369 from davidkline-ms/vNext-TrackingAccuracy

add IsPosition/RotationAvailable and IsPositionApproximate

Author: David Kline

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

@@ -21,11 +21,21 @@ 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 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>

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

@@ -4,26 +4,29 @@
 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.
+        /// The device is not tracked.
         /// </summary>
-        Approximate,
+        NotTracked,
         /// <summary>
-        /// The controller is currently fully tracked and has accurate positioning.
+        /// The device is tracked (positionally and/or rotationally).
         /// </summary>
-        Tracked,
-        /// <summary>
-        /// Reserved, for systems that provide alternate tracking.
-        /// </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/Devices/BaseController.cs

@@ -29,6 +29,10 @@ protected BaseController(TrackingState trackingState, Handedness controllerHande
             ControllerHandedness = controllerHandedness;
             InputSource = inputSource;
             Interactions = interactions;
+
+            IsPositionAvailable = false;
+            IsPositionApproximate = false;
+            IsRotationAvailable = false;
         }
 
         /// <summary>
@@ -58,6 +62,15 @@ protected IMixedRealityInputSystem InputSystem
         /// <inheritdoc />
         public IMixedRealityInputSource InputSource { get; }
 
+        /// <inheritdoc />
+        public bool IsPositionAvailable { get; protected set; }
+
+        /// <inheritdoc />
+        public bool IsPositionApproximate { get; protected set; }
+
+        /// <inheritdoc />
+        public bool IsRotationAvailable { get; protected set; }
+
         /// <inheritdoc />
         public MixedRealityInteractionMapping[] Interactions { get; private set; }
 

Assets/MixedRealityToolkit/_Core/Devices/MixedReality/WindowsMixedRealityController.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,23 +109,21 @@ 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();
+                TrackingState = TrackingState.Tracked;
+                IsPositionApproximate = (interactionSourceState.sourcePose.positionAccuracy == InteractionSourcePositionAccuracy.Approximate);
             }
+            else
+            {
+                TrackingState = TrackingState.NotTracked;
+                IsPositionApproximate = true;
+            }
+
+            IsRotationAvailable = interactionSourceState.sourcePose.TryGetRotation(out currentControllerRotation);
 
             if (lastState != TrackingState)
             {

Assets/MixedRealityToolkit/_Core/Interfaces/Devices/IMixedRealityController.cs

@@ -27,6 +27,29 @@ 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>
+        bool IsPositionApproximate { 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>
         /// Mapping definition for this controller, linking the Physical inputs to logical Input System Actions
         /// </summary>