Added mouse controller intelligent switching.

Author: StephenHodgson

Assets/MixedRealityToolkit-SDK/Features/UX/Prefabs/Pointers/MousePointer.prefab

@@ -60,7 +60,7 @@ MonoBehaviour:
     axisConstraint: 0
   cursorPrefab: {fileID: 1151083198953756, guid: 667821d88830305449757690d22f71e0,
     type: 2}
-  disableCursorOnStart: 0
+  disableCursorOnStart: 1
   setCursorVisibilityOnSourceDetected: 0
   raycastOrigin: {fileID: 0}
   activeHoldAction:
@@ -75,3 +75,6 @@ MonoBehaviour:
   overrideGlobalPointerExtent: 0
   pointerExtent: 10
   pointerOrientation: 0
+  hideCursorWhenInactive: 1
+  movementThresholdToUnHide: 0.1
+  hideTimeout: 3

Assets/MixedRealityToolkit-SDK/Features/UX/Scripts/Cursors/BaseCursor.cs

@@ -110,6 +110,9 @@ public virtual void SetVisibility(bool visible)
             }
         }
 
+        /// <inheritdoc />
+        public bool IsVisible => PrimaryCursorVisual != null ? PrimaryCursorVisual.gameObject.activeInHierarchy : gameObject.activeInHierarchy;
+
         /// <inheritdoc />
         public bool SetVisibilityOnSourceDetected { get; set; } = false;
 

Assets/MixedRealityToolkit-SDK/Features/UX/Scripts/Pointers/MousePointer.cs

@@ -17,8 +17,35 @@ namespace Microsoft.MixedReality.Toolkit.SDK.UX.Pointers
     /// </summary>
     public class MousePointer : BaseControllerPointer, IMixedRealityMousePointer
     {
+        [SerializeField]
+        [Tooltip("Should the mouse cursor be hidden when no active input is received?")]
+        private bool hideCursorWhenInactive = true;
+
+        /// <inheritdoc />
+        public bool HideCursorWhenInactive => hideCursorWhenInactive;
+
+        [SerializeField]
+        [Range(0.01f, 1f)]
+        [Tooltip("What is the movement threshold to reach before un-hiding mouse cursor?")]
+        private float movementThresholdToUnHide = 0.1f;
+
+        /// <inheritdoc />
+        public float MovementThresholdToUnHide => movementThresholdToUnHide;
+
+        [SerializeField]
+        [Range(0f, 10f)]
+        [Tooltip("How long should it take before the mouse cursor is hidden?")]
+        private float hideTimeout = 3.0f;
+
+        /// <inheritdoc />
+        public float HideTimeout => hideTimeout;
+
+        private float timeoutTimer;
+
         private bool isInteractionEnabled = false;
 
+        private bool cursorWasDisabledOnDown = false;
+
         /// <inheritdoc />
         public override bool IsInteractionEnabled => isInteractionEnabled;
 
@@ -66,6 +93,14 @@ public override void OnSourcePoseChanged(SourcePoseEventData<Vector2> eventData)
 
             if (UseSourcePoseData)
             {
+                if (!BaseCursor.IsVisible &&
+                    (eventData.SourceData.x >= movementThresholdToUnHide ||
+                     eventData.SourceData.y >= MovementThresholdToUnHide))
+                {
+                    BaseCursor?.SetVisibility(true);
+                    transform.rotation = CameraCache.Main.transform.rotation;
+                }
+
                 var newRotation = Vector3.zero;
                 newRotation.x += eventData.SourceData.y;
                 newRotation.y += eventData.SourceData.x;
@@ -81,8 +116,17 @@ public override void OnPositionInputChanged(InputEventData<Vector2> eventData)
                 if (!UseSourcePoseData &&
                     PoseAction == eventData.MixedRealityInputAction)
                 {
+                    if (!BaseCursor.IsVisible &&
+                        (eventData.InputData.x >= movementThresholdToUnHide ||
+                         eventData.InputData.y >= MovementThresholdToUnHide))
+                    {
+                        BaseCursor?.SetVisibility(true);
+                        transform.rotation = CameraCache.Main.transform.rotation;
+                    }
+
                     IsTracked = true;
                     TrackingState = TrackingState.Tracked;
+
                     var newRotation = Vector3.zero;
                     newRotation.x += eventData.InputData.x;
                     newRotation.y += eventData.InputData.y;
@@ -91,6 +135,31 @@ public override void OnPositionInputChanged(InputEventData<Vector2> eventData)
             }
         }
 
+        /// <inheritdoc />
+        public override void OnInputDown(InputEventData eventData)
+        {
+            cursorWasDisabledOnDown = !BaseCursor.IsVisible;
+
+            if (cursorWasDisabledOnDown)
+            {
+                BaseCursor?.SetVisibility(true);
+                transform.rotation = CameraCache.Main.transform.rotation;
+            }
+            else
+            {
+                base.OnInputDown(eventData);
+            }
+        }
+
+        /// <inheritdoc />
+        public override void OnInputUp(InputEventData eventData)
+        {
+            if (BaseCursor.IsVisible && !cursorWasDisabledOnDown)
+            {
+                base.OnInputUp(eventData);
+            }
+        }
+
         protected override void Start()
         {
             base.Start();
@@ -110,6 +179,19 @@ protected override void Start()
             }
         }
 
+        private void Update()
+        {
+            if (!isInteractionEnabled) { return; }
+
+            timeoutTimer += Time.unscaledDeltaTime;
+
+            if (timeoutTimer >= hideTimeout)
+            {
+                timeoutTimer = 0.0f;
+                BaseCursor?.SetVisibility(false);
+            }
+        }
+
         /// <inheritdoc />
         public override void OnSourceDetected(SourceStateEventData eventData)
         {

Assets/MixedRealityToolkit-SDK/Inspectors/UX/Pointers/BaseControllerPointerInspector.cs

@@ -51,6 +51,8 @@ public override void OnInspectorGUI()
 
             if (basePointerFoldout)
             {
+                EditorGUI.indentLevel++;
+
                 EditorGUILayout.PropertyField(cursorPrefab);
                 EditorGUILayout.PropertyField(disableCursorOnStart);
                 EditorGUILayout.PropertyField(setCursorVisibilityOnSourceDetected);
@@ -69,7 +71,9 @@ public override void OnInspectorGUI()
                     }
                 }
 
+                EditorGUI.indentLevel--;
             }
+
             serializedObject.ApplyModifiedProperties();
         }
     }

Assets/MixedRealityToolkit-SDK/Inspectors/UX/Pointers/MousePointerInspector.cs

@@ -9,10 +9,43 @@ namespace Microsoft.MixedReality.Toolkit.SDK.Inspectors.UX.Pointers
     [CustomEditor(typeof(MousePointer))]
     public class MousePointerInspector : BaseControllerPointerInspector
     {
+        private SerializedProperty hideCursorWhenInactive;
+        private SerializedProperty movementThresholdToUnHide;
+        private SerializedProperty hideTimeout;
+        private bool mousePointerFoldout = true;
+
         protected override void OnEnable()
         {
             DrawBasePointerActions = false;
             base.OnEnable();
+
+            hideCursorWhenInactive = serializedObject.FindProperty("hideCursorWhenInactive");
+            movementThresholdToUnHide = serializedObject.FindProperty("movementThresholdToUnHide");
+            hideTimeout = serializedObject.FindProperty("hideTimeout");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+            serializedObject.Update();
+
+            mousePointerFoldout = EditorGUILayout.Foldout(mousePointerFoldout, "Mouse Pointer Settings", true);
+
+            if (mousePointerFoldout)
+            {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(hideCursorWhenInactive);
+
+                if (hideCursorWhenInactive.boolValue)
+                {
+                    EditorGUILayout.PropertyField(movementThresholdToUnHide);
+                    EditorGUILayout.PropertyField(hideTimeout);
+                }
+
+                EditorGUI.indentLevel--;
+            }
+
+            serializedObject.ApplyModifiedProperties();
         }
     }
 }

Assets/MixedRealityToolkit/_Core/Interfaces/InputSystem/IMixedRealityCursor.cs

@@ -42,6 +42,11 @@ public interface IMixedRealityCursor : IMixedRealityFocusChangedHandler, IMixedR
         /// <param name="visible">True if cursor should be visible, false if not.</param>
         void SetVisibility(bool visible);
 
+        /// <summary>
+        /// Is the cursor currently visible?
+        /// </summary>
+        bool IsVisible { get; }
+
         /// <summary>
         /// Sets the visibility of the <see cref="IMixedRealityCursor"/> when the source is detected.
         /// </summary>

Assets/MixedRealityToolkit/_Core/Interfaces/InputSystem/IMixedRealityMousePointer.cs

@@ -8,5 +8,19 @@ namespace Microsoft.MixedReality.Toolkit.Core.Interfaces.InputSystem
     /// </summary>
     public interface IMixedRealityMousePointer : IMixedRealityPointer
     {
+        /// <summary>
+        /// Should the mouse cursor be hidden when no active input is received?
+        /// </summary>
+        bool HideCursorWhenInactive { get; }
+
+        /// <summary>
+        /// What is the movement threshold to reach before un-hiding mouse cursor?
+        /// </summary>
+        float MovementThresholdToUnHide { get; }
+
+        /// <summary>
+        /// How long should it take before the mouse cursor is hidden?
+        /// </summary>
+        float HideTimeout { get; }
     }
 }