Merge pull request #7012 from Troy-Ferrell/users/trferrel/fix-solvers

Fix Solvers tracking pointers as target transforms

Author: wiwei

Assets/MixedRealityToolkit.SDK/Features/Input/Handlers/ControllerPoseSynchronizer.cs

@@ -14,15 +14,10 @@ public class ControllerPoseSynchronizer : InputSystemGlobalHandlerListener, IMix
     {
         #region IMixedRealityControllerPoseSynchronizer Implementation
 
-        [SerializeField]
-        [Tooltip("The handedness this controller should synchronize with.")]
-        private Handedness handedness = Handedness.Left;
-
         /// <inheritdoc />
         public Handedness Handedness
         {
-            get { return handedness; }
-            set { handedness = value; }
+            get => Controller == null ? Handedness.None : Controller.ControllerHandedness;
         }
 
         [SerializeField]
@@ -32,8 +27,8 @@ public Handedness Handedness
         /// <inheritdoc />
         public bool DestroyOnSourceLost
         {
-            get { return destroyOnSourceLost; }
-            set { destroyOnSourceLost = value; }
+            get => destroyOnSourceLost;
+            set => destroyOnSourceLost = value;
         }
 
         /// <summary>
@@ -51,17 +46,8 @@ public bool DestroyOnSourceLost
         /// <inheritdoc />
         public virtual IMixedRealityController Controller
         {
-            get { return controller; }
-            set
-            {
-                controller = value;
-
-                if (controller != null && gameObject != null)
-                {
-                    handedness = value.ControllerHandedness;
-                    gameObject.name = $"{handedness}_{gameObject.name}";
-                }
-            }
+            get => controller;
+            set => controller = value;
         }
 
         [SerializeField]
@@ -71,8 +57,8 @@ public virtual IMixedRealityController Controller
         /// <inheritdoc />
         public bool UseSourcePoseData
         {
-            get { return useSourcePoseData; }
-            set { useSourcePoseData = value; }
+            get => useSourcePoseData;
+            set => useSourcePoseData = value;
         }
 
         [SerializeField]
@@ -82,8 +68,8 @@ public bool UseSourcePoseData
         /// <inheritdoc />
         public MixedRealityInputAction PoseAction
         {
-            get { return poseAction; }
-            set { poseAction = value; }
+            get => poseAction;
+            set => poseAction = value;
         }
 
         #endregion IMixedRealityControllerPoseSynchronizer Implementation
@@ -117,7 +103,7 @@ public virtual void OnSourceLost(SourceStateEventData eventData)
             {
                 TrackingState = TrackingState.NotTracked;
 
-                if (destroyOnSourceLost)
+                if (DestroyOnSourceLost)
                 {
                     GameObjectExtensions.DestroyGameObject(gameObject);
                 }
@@ -214,5 +200,18 @@ public virtual void OnInputChanged(InputEventData<MixedRealityPose> eventData)
         }
 
         #endregion  IMixedRealityInputHandler Implementation
+
+        #region Obsolete
+
+        #pragma warning disable 0414
+        [SerializeField]
+        [HideInInspector]
+        [System.Obsolete("Use the Handedness property instead to get current handedness which is set by Controller attached")]
+        [Tooltip("Use the Handedness property instead to get current handedness which is set by Controller attached")]
+        private Handedness handedness = Handedness.Left;
+        #pragma warning restore 0414
+
+        #endregion
+
     }
 }

Assets/MixedRealityToolkit.SDK/Features/UX/Scripts/Pointers/BaseControllerPointer.cs

@@ -208,7 +208,7 @@ public override IMixedRealityController Controller
 
                 if (base.Controller != null && this != null)
                 {
-                    pointerName = gameObject.name;
+                    PointerName = gameObject.name;
                     InputSourceParent = base.Controller.InputSource;
                 }
             }

Assets/MixedRealityToolkit.SDK/Features/UX/Scripts/Pointers/BaseMousePointer.cs

@@ -59,23 +59,14 @@ public abstract class BaseMousePointer : BaseControllerPointer, IMixedRealityMou
 
         protected abstract string ControllerName { get; }
 
-        private IMixedRealityController controller;
-
         /// <inheritdoc />
         public override IMixedRealityController Controller
         {
-            get { return controller; }
+            get => base.Controller;
             set
             {
-                controller = value;
+                base.Controller = value;
                 TrackingState = TrackingState.NotApplicable;
-
-                if (controller != null && gameObject != null)
-                {
-                    InputSourceParent = controller.InputSource;
-                    Handedness = controller.ControllerHandedness;
-                    gameObject.name = ControllerName;
-                }
             }
         }
 

Assets/MixedRealityToolkit.SDK/Features/Utilities/Solvers/SolverHandler.cs

@@ -27,7 +27,7 @@ public class SolverHandler : MonoBehaviour
         /// </summary>
         public TrackedObjectType TrackedTargetType
         {
-            get { return trackedTargetType; }
+            get => trackedTargetType;
             set
             {
                 if (trackedTargetType != value && IsValidTrackedObjectType(value))
@@ -38,23 +38,6 @@ public TrackedObjectType TrackedTargetType
             }
         }
 
-        /// <summary>
-        /// Tracked object to calculate position and orientation from. If you want to manually override and use a scene object, use the TransformTarget field.
-        /// </summary>
-        [Obsolete("Use TrackedTargetType instead")]
-        public TrackedObjectType TrackedObjectToReference
-        {
-            get { return trackedTargetType; }
-            set
-            {
-                if (trackedTargetType != value)
-                {
-                    trackedTargetType = value;
-                    RefreshTrackedObject();
-                }
-            }
-        }
-
         [SerializeField]
         [Tooltip("If tracking hands or motion controllers, determines which hand(s) are valid attachments")]
         private Handedness trackedHandness = Handedness.Both;
@@ -67,7 +50,7 @@ public TrackedObjectType TrackedObjectToReference
         /// </remarks>
         public Handedness TrackedHandness
         {
-            get { return trackedHandness; }
+            get => trackedHandness;
             set
             {
                 if (trackedHandness != value && IsValidHandedness(value))
@@ -87,7 +70,7 @@ public Handedness TrackedHandness
         /// </summary>
         public TrackedHandJoint TrackedHandJoint
         {
-            get { return trackedHandJoint; }
+            get => trackedHandJoint;
             set
             {
                 if (trackedHandJoint != value)
@@ -126,7 +109,7 @@ public Transform TransformOverride
         /// </summary>
         public Vector3 AdditionalOffset
         {
-            get { return additionalOffset; }
+            get => additionalOffset;
             set
             {
                 if (additionalOffset != value)
@@ -146,7 +129,7 @@ public Vector3 AdditionalOffset
         /// </summary>
         public Vector3 AdditionalRotation
         {
-            get { return additionalRotation; }
+            get => additionalRotation;
             set
             {
                 if (additionalRotation != value)
@@ -166,8 +149,8 @@ public Vector3 AdditionalRotation
         /// </summary>
         public bool UpdateSolvers
         {
-            get { return updateSolvers; }
-            set { updateSolvers = value; }
+            get => updateSolvers;
+            set => updateSolvers = value;
         }
 
         protected readonly List<Solver> solvers = new List<Solver>();
@@ -178,17 +161,13 @@ public bool UpdateSolvers
         /// </summary>
         public IReadOnlyCollection<Solver> Solvers
         {
-            get
-            {
-                return solvers.AsReadOnly();
-            }
-
+            get => solvers.AsReadOnly();
             set
             {
                 if (value != null)
                 {
-                    this.solvers.Clear();
-                    this.solvers.AddRange(value);
+                    solvers.Clear();
+                    solvers.AddRange(value);
                 }
             }
         }
@@ -230,7 +209,7 @@ public Transform TransformTarget
                     RefreshTrackedObject();
                 }
 
-                return (trackingTarget != null) ? trackingTarget.transform : null;
+                return trackingTarget != null ? trackingTarget.transform : null;
             }
         }
 
@@ -243,13 +222,7 @@ public Transform TransformTarget
         /// /// <remarks>
         /// Only possible values Left, Right, or None
         /// </remarks>
-        public Handedness CurrentTrackedHandedness
-        {
-            get
-            {
-                return currentTrackedHandedness;
-            }
-        }
+        public Handedness CurrentTrackedHandedness => currentTrackedHandedness;
 
         // Stores controller side to favor if TrackedHandedness is set to both
         protected Handedness preferredTrackedHandedness = Handedness.Left;
@@ -277,6 +250,8 @@ public Handedness PreferredTrackedHandedness
         // Hidden GameObject managed by this component and attached as a child to the tracked target type (i.e head, hand etc)
         private GameObject trackingTarget;
 
+        private LinePointer controllerRay;
+
         private float lastUpdateTime;
 
         private IMixedRealityHandJointService HandJointService => handJointService ?? (handJointService = (CoreServices.InputSystem as IMixedRealityDataProviderAccess)?.GetDataProvider<IMixedRealityHandJointService>());
@@ -397,6 +372,7 @@ protected virtual void DetachFromCurrentTrackedObject()
         protected virtual void AttachToNewTrackedObject()
         {
             currentTrackedHandedness = Handedness.None;
+            controllerRay = null;
 
             Transform target = null;
             if (TrackedTargetType == TrackedObjectType.Head)
@@ -408,21 +384,28 @@ protected virtual void AttachToNewTrackedObject()
                 if (TrackedHandness == Handedness.Both)
                 {
                     currentTrackedHandedness = PreferredTrackedHandedness;
-                    target = GetControllerRay(currentTrackedHandedness);
-                    if (target == null)
+                    controllerRay = PointerUtils.GetPointer<LinePointer>(currentTrackedHandedness);
+
+                    if (controllerRay == null)
                     {
+                        // If no pointer found, try again on the the opposite hand
                         currentTrackedHandedness = currentTrackedHandedness.GetOppositeHandedness();
-                        target = GetControllerRay(currentTrackedHandedness);
-                        if (target == null)
-                        {
-                            currentTrackedHandedness = Handedness.None;
-                        }
+                        controllerRay = PointerUtils.GetPointer<LinePointer>(currentTrackedHandedness);
                     }
                 }
                 else
                 {
                     currentTrackedHandedness = TrackedHandness;
-                    target = GetControllerRay(TrackedHandness);
+                    controllerRay = PointerUtils.GetPointer<LinePointer>(currentTrackedHandedness);
+                }
+
+                if (controllerRay != null)
+                {
+                    target = controllerRay.transform;
+                }
+                else
+                {
+                    currentTrackedHandedness = Handedness.None;
                 }
             }
             else if (TrackedTargetType == TrackedObjectType.HandJoint)
@@ -470,10 +453,9 @@ private void TrackTransform(Transform target)
             trackingTarget.transform.localRotation = Quaternion.Euler(AdditionalRotation);
         }
 
-        private Transform GetControllerRay(Handedness handedness)
+        private LinePointer GetControllerRay(Handedness handedness)
         {
-            var pointer = PointerUtils.GetPointer<LinePointer>(handedness);
-            return pointer?.transform;
+            return PointerUtils.GetPointer<LinePointer>(handedness);
         }
 
         /// <summary>
@@ -486,7 +468,15 @@ private bool IsInvalidTracking()
             {
                 return true;
             }
-
+            
+            // If we are attached to a pointer (i.e controller ray), 
+            // check if pointer's controller is still be tracked
+            if (TrackedTargetType == TrackedObjectType.ControllerRay &&
+                (controllerRay == null || !controllerRay.IsTracked))
+            {
+                return true;
+            }
+            
             // If we were tracking a particular hand, check that our transform is still valid
             // The HandJointService does not destroy it's own hand joint tracked GameObjects even when a hand is no longer tracked
             // Those HandJointService's GameObjects though are the parents of our tracked transform and thus will not be null/destroyed
@@ -511,5 +501,26 @@ public static bool IsValidTrackedObjectType(TrackedObjectType type)
         {
             return type == TrackedObjectType.Head || type >= TrackedObjectType.ControllerRay;
         }
+
+        #region Obsolete
+
+        /// <summary>
+        /// Tracked object to calculate position and orientation from. If you want to manually override and use a scene object, use the TransformTarget field.
+        /// </summary>
+        [Obsolete("Use TrackedTargetType instead")]
+        public TrackedObjectType TrackedObjectToReference
+        {
+            get => trackedTargetType;
+            set
+            {
+                if (trackedTargetType != value)
+                {
+                    trackedTargetType = value;
+                    RefreshTrackedObject();
+                }
+            }
+        }
+
+        #endregion
     }
 }