Work on improved hand menu + improved subsystem query API

UnityProjects/MRTKDevTemplate/Assets/Scripts/SampleSceneHandMenu.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Collections.Generic;
+using System.Linq;
 using Microsoft.MixedReality.Toolkit.Input;
 using Microsoft.MixedReality.Toolkit.UX;
 using Microsoft.MixedReality.Toolkit.Diagnostics;
@@ -22,6 +24,9 @@ internal class SampleSceneHandMenu : MonoBehaviour
         [SerializeField]
         private StatefulInteractable gazePinchToggle;
 
+        [SerializeField]
+        private StatefulInteractable handMeshToggle;
+
         [SerializeField]
         private StatefulInteractable perfOverlayToggle;
 
@@ -31,13 +36,16 @@ internal class SampleSceneHandMenu : MonoBehaviour
         [SerializeField]
         private StatefulInteractable nextSceneButton;
 
+
         [SerializeField]
         private TMP_Text sceneTitleLabel;
 
         [SerializeField]
         private GameObject profilerObject;
 
-        private void Awake()
+        private List<RiggedHandMeshVisualizer> handMeshes = new List<RiggedHandMeshVisualizer>();
+
+        private void Start()
         {
             rayToggle.OnClicked.AddListener(() => SetHandRaysActive(rayToggle.IsToggled));
             gazePinchToggle.OnClicked.AddListener(() => SetGazePinchActive(gazePinchToggle.IsToggled));
@@ -57,6 +65,11 @@ private void Awake()
                 perfOverlayToggle.gameObject.SetActive(false);
             }
 
+            handMeshes = new List<RiggedHandMeshVisualizer>(Object.FindObjectsOfType<RiggedHandMeshVisualizer>());
+            handMeshToggle.ForceSetToggled((handMeshes.Any((handMesh) => handMesh.IsShowingHands)));
+            handMeshToggle.OnClicked.AddListener(() => SetHandMeshActive(handMeshToggle.IsToggled));
+
+
             previousSceneButton.OnClicked.AddListener(() => GoToPreviousScene());
             nextSceneButton.OnClicked.AddListener(() => GoToNextScene());
 
@@ -100,6 +113,32 @@ public void SetPerfOverlayActive(bool value)
             }
         }
 
+        void SetHandMeshActive(bool value)
+        {
+            if (handMeshes.Count == 0)
+            {
+                handMeshes = new List<RiggedHandMeshVisualizer>(Object.FindObjectsOfType<RiggedHandMeshVisualizer>());
+            }
+
+            if (handMeshes.Count == 0) {
+                handMeshToggle.enabled = false;
+                return;
+            }
+
+            foreach (var handMesh in handMeshes)
+            {
+                if (value)
+                {
+                    handMesh.ShowHandsOnTransparentDisplays = true;
+                    handMesh.enabled = true;
+                }
+                else
+                {
+                    handMesh.enabled = false;
+                }
+            }
+        }
+
         /// <summary>
         /// Load the next scene in build order.
         /// </summary>

com.microsoft.mrtk.core/Utilities/HandJointPose.cs

@@ -146,5 +146,11 @@ public override int GetHashCode()
         }
 
         #endregion IEqualityComparer Implementation
+
+        #region Conversions
+
+        public static implicit operator Pose(HandJointPose pose) => pose.pose;
+
+        #endregion
     }
 }

com.microsoft.mrtk.core/Utilities/Handedness.cs

@@ -6,27 +6,30 @@
 namespace Microsoft.MixedReality.Toolkit
 {
     /// <summary>
-    /// Defines in which hand a controller is currently being used.
+    /// Represents handedness; as a bitflag, it can represent left-handedness,
+    /// right-handedness, both, or neither.
     /// </summary>
     [Flags]
     public enum Handedness
     {
         /// <summary>
-        /// No hand specified by the SDK for the controller.
+        /// No handedness. Represents a non-handed controller or object.
         /// </summary>
-        /// <remarks>
-        /// This value is used for controllers such as a gamepad or a mouse.
-        /// </remarks>
         None = 0 << 0,
 
         /// <summary>
-        /// The controller is identified as being provided in a Left hand
+        /// The user's left hand or controller.
         /// </summary>
         Left = 1 << 0,
 
         /// <summary>
-        /// The controller is identified as being provided in a Right hand
+        /// The user's right hand or controller.
         /// </summary>
-        Right = 1 << 1
+        Right = 1 << 1,
+
+        /// <summary>
+        /// Both, or either, hands.
+        /// </summary>
+        Both = Left | Right,
     }
 }

com.microsoft.mrtk.core/Utilities/XRSubsystemHelpers.cs

@@ -3,6 +3,7 @@
 
 using Microsoft.MixedReality.Toolkit.Subsystems;
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Reflection;
 using UnityEngine;
@@ -16,21 +17,21 @@ namespace Microsoft.MixedReality.Toolkit
     /// <remarks>These properties are only valid for the XR SDK pipeline.</remarks>
     public static class XRSubsystemHelpers
     {
+        private static Dictionary<Type, IList> scratchCaches = new Dictionary<Type, IList>();
+
         /// <summary>
         /// Get the first active subsystem of type T.
         /// </summary>
         /// <remarks>
-        /// Caution: this method allocs a new list of subsystems.
-        /// For performance critical (frame loop) applications,
-        /// consider calling SubsystemManager.GetSubsystems directly
-        /// with a pre-allocated list.
+        /// This method allocates on the first invocation with a new, unique type T.
+        /// Subsequent invocations with the same type T will no longer allocate.
         /// </remarks>
         public static T GetFirstSubsystem<T>() where T : ISubsystem
         {
-            List<T> subsystems = GetAllSubsystems<T>();
+            List<T> results = GetAllSubsystems<T>();
 
             // default returns null on reference type
-            return subsystems.Count > 0 ? subsystems[0] : default;
+            return results.Count > 0 ? results[0] : default;
         }
 
         /// <summary>
@@ -51,53 +52,56 @@ public static class XRSubsystemHelpers
         }
 
         /// <summary>
-        /// Get all running subsystems of type T without allocating a new list.
+        /// Get all running subsystems of type T.
         /// </summary>
         /// <param name="runningSubsystems">The list to fill with all running subsystems of the specified type.</param>
+        [Obsolete("GetAllRunningSubsystems now internally caches for you; this separate NonAlloc method is no longer necessary.")]
         public static void GetAllRunningSubsystemsNonAlloc<T>(List<T> runningSubsystems) where T : ISubsystem
         {
             SubsystemManager.GetSubsystems(runningSubsystems);
             runningSubsystems.RemoveAll(subsystem => !subsystem.running);
         }
 
         /// <summary>
-        /// Get all running subsystems of type T.
+        /// Get all running subsystems of type T. Note, this is internally cached, so
+        /// the list is only valid immediately after invocation.
         /// </summary>
         /// <remarks>
-        /// Caution: this method allocs a new list of subsystems.
-        /// For performance critical (frame loop) applications,
-        /// consider calling SubsystemManager.GetSubsystems directly
-        /// with a pre-allocated list.
+        /// This method allocates on the first invocation with a new, unique type T.
+        /// Subsequent invocations with the same type T will no longer allocate.
         /// </remarks>
         public static List<T> GetAllRunningSubsystems<T>() where T : ISubsystem
         {
-            List<T> filtered = new List<T>();
-
-            foreach (T sys in GetAllSubsystems<T>())
-            {
-                if (sys.running)
-                {
-                    filtered.Add(sys);
-                }
-            }
-
-            return filtered;
+            List<T> subsystems = GetAllSubsystems<T>();
+            subsystems.RemoveAll(subsystem => !subsystem.running);
+            return subsystems;
         }
 
         /// <summary>
-        /// Get all subsystems (not necessarily running) of type T.
+        /// Get all subsystems (not necessarily running) of type T. Note, this is
+        /// internally cached, so the list is only valid immediately after invocation.
         /// </summary>
         /// <remarks>
-        /// Caution: this method allocs a new list of subsystems.
-        /// For performance critical (frame loop) applications,
-        /// consider calling SubsystemManager.GetSubsystems directly
-        /// with a pre-allocated list.
+        /// This method allocates on the first invocation with a new, unique type T.
+        /// Subsequent invocations with the same type T will no longer allocate.
         /// </remarks>
         public static List<T> GetAllSubsystems<T>() where T : ISubsystem
         {
-            List<T> subsystems = new List<T>();
-            SubsystemManager.GetSubsystems(subsystems);
-            return subsystems;
+            // If we haven't queried subsystems of this type before,
+            // we'll need to add a new entry in our cache. This will
+            // allocate the first time, but subsequent queries will
+            // reuse the same cached list. (The list will still be cleared
+            // and re-filled by the GetSubsystems call, but nothing will be
+            // allocated.)
+            if (!scratchCaches.ContainsKey(typeof(T)))
+            {
+                scratchCaches.Add(typeof(T), new List<T>());
+            }
+
+            List<T> cache = scratchCaches[typeof(T)] as List<T>;
+            SubsystemManager.GetSubsystems<T>(cache);
+
+            return cache;
         }
 
         private static XRInputSubsystem inputSubsystem = null;
@@ -151,6 +155,23 @@ public static XRDisplaySubsystem DisplaySubsystem
             }
         }
 
+        private static HandsAggregatorSubsystem handsAggregator = null;
+
+        /// <summary>
+        /// The currently loaded and running hands aggregator, if any.
+        /// </summary>
+        public static HandsAggregatorSubsystem HandsAggregator
+        {
+            get
+            {
+                if (handsAggregator == null || !handsAggregator.running)
+                {
+                    handsAggregator = GetFirstRunningSubsystem<HandsAggregatorSubsystem>();
+                }
+                return handsAggregator;
+            }
+        }
+
         #region Subsystem internal utilities
 
         /// <summary>

com.microsoft.mrtk.input/Visualizers/RiggedHandVisualizer/RiggedHandMeshVisualizer.cs

@@ -47,6 +47,25 @@ public bool ShowHandsOnTransparentDisplays
             set => showHandsOnTransparentDisplays = value;
         }
 
+        /// <summary>
+        /// Is the hand actually visible?
+        /// </summary>
+        public bool IsShowingHands
+        {
+            get
+            {
+                if (handRenderer != null)
+                {
+                    return handRenderer.enabled &&
+                           handRenderer.gameObject.activeInHierarchy;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+        }
+
         [SerializeField]
         [Tooltip("The transform of the wrist joint.")]
         private Transform wrist;

com.microsoft.mrtk.spatialmanipulation/Editor/Solvers/HandMenuEditor.cs

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using UnityEditor;
+using UnityEngine;
+
+namespace Microsoft.MixedReality.Toolkit.SpatialManipulation.Editor
+{
+    [CustomEditor(typeof(HandMenu))]
+    [CanEditMultipleObjects]
+    public class HandMenuEditor : UnityEditor.Editor
+    {
+        private SerializedProperty leftHandPosition;
+
+        private SerializedProperty leftHandRotation;
+
+        private SerializedProperty rightHandPosition;
+
+        private SerializedProperty rightHandRotation;
+
+        private static bool expanded = false;
+
+        private string[] drawnProperties = new string[]
+        {
+            nameof(leftHandPosition),
+            nameof(leftHandRotation),
+            nameof(rightHandPosition),
+            nameof(rightHandRotation)
+        };
+
+        protected virtual void OnEnable()
+        {
+            leftHandPosition = serializedObject.FindProperty(nameof(leftHandPosition));
+            leftHandRotation = serializedObject.FindProperty(nameof(leftHandRotation));
+            rightHandPosition = serializedObject.FindProperty(nameof(rightHandPosition));
+            rightHandRotation = serializedObject.FindProperty(nameof(rightHandRotation));
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+            DrawPropertiesExcluding(serializedObject, drawnProperties);
+            EditorGUILayout.Space();
+
+            if (expanded = EditorGUILayout.BeginFoldoutHeaderGroup(expanded, "Fallback Bindings"))
+            {
+                EditorGUILayout.PropertyField(leftHandPosition);
+                EditorGUILayout.PropertyField(leftHandRotation);
+                EditorGUILayout.PropertyField(rightHandPosition);
+                EditorGUILayout.PropertyField(rightHandRotation);
+                EditorGUILayout.EndFoldoutHeaderGroup();
+            }
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}