Merge pull request #2784 from keveleigh/AddControllerFinder

[Solver PR 4] Add controller-tracking support to solvers

Author: keveleigh

Assets/MixedRealityToolkit-SDK/Features/Utilities/Solvers/ControllerFinder.cs

@@ -0,0 +1,151 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using Microsoft.MixedReality.Toolkit.Core.Definitions.Utilities;
+using Microsoft.MixedReality.Toolkit.Core.EventDatum.Input;
+using Microsoft.MixedReality.Toolkit.Core.Interfaces.Devices;
+using Microsoft.MixedReality.Toolkit.Core.Interfaces.InputSystem.Handlers;
+using Microsoft.MixedReality.Toolkit.Core.Managers;
+using UnityEngine;
+
+namespace Microsoft.MixedReality.Toolkit.SDK.Utilities.Solvers
+{
+    /// <summary>
+    /// ControllerFinder is a base class providing simple event handling for getting/releasing MotionController Transforms.
+    /// </summary>
+    public abstract class ControllerFinder : MonoBehaviour, IMixedRealitySourceStateHandler
+    {
+        [SerializeField]
+        [Tooltip("The handedness of the controller that should be found.")]
+        private Handedness handedness = Handedness.None;
+
+        /// <summary>
+        /// The handedness of the controller that should be found.
+        /// </summary>
+        public Handedness Handedness
+        {
+            get { return handedness; }
+            set
+            {
+                // We need to refresh which controller we're attached to if we switch handedness.
+                if (handedness != value)
+                {
+                    handedness = value;
+                    RefreshControllerTransform();
+                }
+            }
+        }
+
+        /// <summary>
+        /// The Transform of the currently found controller.
+        /// </summary>
+        protected Transform ControllerTransform;
+
+        #region MonoBehaviour Implementation
+
+        protected virtual void OnEnable()
+        {
+            // Look if the controller has loaded.
+            RefreshControllerTransform();
+        }
+
+        #endregion MonoBehaviour Implementation
+
+        #region IMixedRealitySourceStateHandler Implementation
+
+        public void OnSourceDetected(SourceStateEventData eventData)
+        {
+            if (eventData.Controller.ControllerHandedness == handedness)
+            {
+                AddControllerTransform(eventData.Controller);
+            }
+        }
+
+        public void OnSourceLost(SourceStateEventData eventData)
+        {
+            if (eventData.Controller.ControllerHandedness == handedness)
+            {
+                RemoveControllerTransform();
+            }
+        }
+
+        #endregion IMixedRealitySourceStateHandler Implementation
+
+        /// <summary>
+        /// Looks to see if the controller model already exists and registers it if so.
+        /// </summary>
+        protected virtual void TryAndAddControllerTransform()
+        {
+            // Look if the controller was already loaded. This could happen if the
+            // GameObject was instantiated at runtime and the model loaded event has already fired.
+            if (MixedRealityManager.InputSystem == null)
+            {
+                // The InputSystem could not be found.
+                return;
+            }
+
+            foreach (IMixedRealityController controller in MixedRealityManager.InputSystem.DetectedControllers)
+            {
+                if (controller.ControllerHandedness == handedness)
+                {
+                    AddControllerTransform(controller);
+                    return;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Starts to track the passed in controller's transform, assuming it meets the previously set handedness criteria.
+        /// </summary>
+        /// <param name="newController">The new controller to be tracked.</param>
+        protected virtual void AddControllerTransform(IMixedRealityController newController)
+        {
+            if (newController.ControllerHandedness == handedness && newController.Visualizer.GameObjectProxy.transform != null && !newController.Visualizer.GameObjectProxy.transform.Equals(ControllerTransform))
+            {
+                ControllerTransform = newController.Visualizer.GameObjectProxy.transform;
+
+                OnControllerFound();
+            }
+        }
+
+        /// <summary>
+        /// Remove whichever controller is currently tracked, if any.
+        /// </summary>
+        protected virtual void RemoveControllerTransform()
+        {
+            if (ControllerTransform != null)
+            {
+                OnControllerLost();
+
+                ControllerTransform = null;
+            }
+        }
+
+        /// <summary>
+        /// Remove whichever controller is currently tracked, if any, and try to add a new one based on existing sources.
+        /// </summary>
+        protected virtual void RefreshControllerTransform()
+        {
+            if (ControllerTransform != null)
+            {
+                RemoveControllerTransform();
+            }
+
+            TryAndAddControllerTransform();
+        }
+
+        /// <summary>
+        /// Override this method to act when the correct controller is actually found.
+        /// This provides similar functionality to overriding AddControllerTransform,
+        /// without the overhead of needing to check that handedness matches.
+        /// </summary>
+        protected virtual void OnControllerFound() { }
+
+        /// <summary>
+        /// Override this method to act when the correct controller is actually lost.
+        /// This provides similar functionality to overriding AddControllerTransform,
+        /// without the overhead of needing to check that handedness matches.
+        /// </summary>
+        protected virtual void OnControllerLost() { }
+    }
+}

Assets/MixedRealityToolkit-SDK/Features/Utilities/Solvers/ControllerFinder.cs.meta

@@ -11,7 +11,7 @@ namespace Microsoft.MixedReality.Toolkit.SDK.Utilities.Solvers
     /// <summary>
     /// This class handles the solver components that are attached to this <see cref="GameObject"/>
     /// </summary>
-    public class SolverHandler : MonoBehaviour
+    public class SolverHandler : ControllerFinder
     {
         [SerializeField]
         [Tooltip("Tracked object to calculate position and orientation from. If you want to manually override and use a scene object, use the TransformTarget field.")]
@@ -46,7 +46,7 @@ public Vector3 AdditionalOffset
             set
             {
                 additionalOffset = value;
-                TransformTarget = MakeOffsetTransform(TransformTarget);
+                transformTarget = MakeOffsetTransform(transformTarget);
             }
         }
 
@@ -63,7 +63,7 @@ public Vector3 AdditionalRotation
             set
             {
                 additionalRotation = value;
-                TransformTarget = MakeOffsetTransform(TransformTarget);
+                transformTarget = MakeOffsetTransform(transformTarget);
             }
         }
 
@@ -136,7 +136,7 @@ private void Awake()
             solvers.AddRange(GetComponents<Solver>());
 
             // TransformTarget overrides TrackedObjectToReference
-            if (!TransformTarget)
+            if (!transformTarget)
             {
                 AttachToNewTrackedObject();
             }
@@ -174,12 +174,38 @@ protected void OnDestroy()
 
         #endregion MonoBehaviour Implementation
 
+        protected override void OnControllerFound()
+        {
+            if (!transformTarget)
+            {
+                TrackTransform(ControllerTransform);
+            }
+        }
+
+        protected override void OnControllerLost()
+        {
+            transformTarget = null;
+
+            if (transformWithOffset != null)
+            {
+                Destroy(transformWithOffset);
+                transformWithOffset = null;
+            }
+        }
+
         /// <summary>
         /// Clears the transform target and attaches to the current <see cref="TrackedObjectToReference"/>.
         /// </summary>
         public void RefreshTrackedObject()
         {
             transformTarget = null;
+
+            if (transformWithOffset != null)
+            {
+                Destroy(transformWithOffset);
+                transformWithOffset = null;
+            }
+
             AttachToNewTrackedObject();
         }
 
@@ -188,15 +214,22 @@ protected virtual void AttachToNewTrackedObject()
             switch (TrackedObjectToReference)
             {
                 case TrackedObjectType.Head:
+                    // No need to search for a controller if we've already attached to the head.
+                    Handedness = Handedness.None;
                     TrackTransform(CameraCache.Main.transform);
                     break;
-                // Other cases will come online as ControllerFinder is ported appropriately.
+                case TrackedObjectType.MotionControllerLeft:
+                    Handedness = Handedness.Left;
+                    break;
+                case TrackedObjectType.MotionControllerRight:
+                    Handedness = Handedness.Right;
+                    break;
             }
         }
 
         private void TrackTransform(Transform newTrackedTransform)
         {
-            TransformTarget = RequiresOffset ? MakeOffsetTransform(newTrackedTransform) : newTrackedTransform;
+            transformTarget = RequiresOffset ? MakeOffsetTransform(newTrackedTransform) : newTrackedTransform;
         }
 
         private Transform MakeOffsetTransform(Transform parentTransform)

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

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using Microsoft.MixedReality.Toolkit.SDK.Utilities.Solvers;
+using UnityEditor;
+using UnityEngine;
+
+namespace Microsoft.MixedReality.Toolkit.SDK.Inspectors.Utilities.Solvers
+{
+    [CustomEditor(typeof(ControllerFinder))]
+    public abstract class ControllerFinderInspector : Editor
+    {
+        private SerializedProperty handednessProperty;
+
+        protected virtual void OnEnable()
+        {
+            handednessProperty = serializedObject.FindProperty("handedness");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Controller Options", new GUIStyle("Label") { fontStyle = FontStyle.Bold });
+            EditorGUILayout.Space();
+            EditorGUI.indentLevel++;
+
+            EditorGUILayout.PropertyField(handednessProperty);
+
+            EditorGUI.indentLevel--;
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Assets/MixedRealityToolkit-SDK/Inspectors/Utilities/Solvers/ControllerFinderInspector.cs

@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using Microsoft.MixedReality.Toolkit.Core.Definitions.Utilities;
+using Microsoft.MixedReality.Toolkit.SDK.Utilities.Solvers;
+using UnityEditor;
+using UnityEngine;
+
+namespace Microsoft.MixedReality.Toolkit.SDK.Inspectors.Utilities.Solvers
+{
+    [CustomEditor(typeof(SolverHandler))]
+    [CanEditMultipleObjects]
+    public class SolverHandlerInspector : ControllerFinderInspector
+    {
+        private SerializedProperty trackedObjectProperty;
+        private SerializedProperty transformTargetProperty;
+        private SerializedProperty additionalOffsetProperty;
+        private SerializedProperty additionalRotationProperty;
+        private SerializedProperty updateSolversProperty;
+        private SolverHandler solverHandler;
+        private readonly GUIContent trackedTransformGUIContent = new GUIContent("Tracked Transform");
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+
+            trackedObjectProperty = serializedObject.FindProperty("trackedObjectToReference");
+            transformTargetProperty = serializedObject.FindProperty("transformTarget");
+            additionalOffsetProperty = serializedObject.FindProperty("additionalOffset");
+            additionalRotationProperty = serializedObject.FindProperty("additionalRotation");
+            updateSolversProperty = serializedObject.FindProperty("updateSolvers");
+
+            solverHandler = target as SolverHandler;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+            EditorGUILayout.Space();
+
+            bool trackedObjectChanged = false;
+
+            if (transformTargetProperty.objectReferenceValue == null || Application.isPlaying)
+            {
+                EditorGUI.BeginChangeCheck();
+                EditorGUILayout.PropertyField(trackedObjectProperty);
+                trackedObjectChanged = EditorGUI.EndChangeCheck();
+            }
+
+            EditorGUILayout.PropertyField(transformTargetProperty, trackedTransformGUIContent);
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(additionalOffsetProperty);
+            EditorGUILayout.PropertyField(additionalRotationProperty);
+            bool additionalOffsetChanged = EditorGUI.EndChangeCheck();
+
+            EditorGUILayout.PropertyField(updateSolversProperty);
+
+            serializedObject.ApplyModifiedProperties();
+
+            if (Application.isPlaying && trackedObjectChanged)
+            {
+                solverHandler.RefreshTrackedObject();
+            }
+
+            if (Application.isPlaying && additionalOffsetChanged)
+            {
+                solverHandler.AdditionalOffset = additionalOffsetProperty.vector3Value;
+                solverHandler.AdditionalRotation = additionalRotationProperty.vector3Value;
+            }
+        }
+    }
+}