Fixed mouse resetting after timer wind down even though it was still enabled.

Made sure that disabling the "Hide Cursor when active" flag didn't hide it after timer winddown
Consolidated some duplicated code.
Updated inspector.

Author: StephenHodgson

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

@@ -55,9 +55,9 @@ MonoBehaviour:
   destroyOnSourceLost: 0
   useSourcePoseData: 1
   poseAction:
-    id: 0
-    description: None
-    axisConstraint: 0
+    id: 12
+    description: Mouse Delta
+    axisConstraint: 4
   cursorPrefab: {fileID: 1151083198953756, guid: 667821d88830305449757690d22f71e0,
     type: 2}
   disableCursorOnStart: 1

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

@@ -30,6 +30,8 @@ public abstract class BaseControllerPointer : ControllerPoseSynchronizer, IMixed
         [SerializeField]
         private bool disableCursorOnStart = false;
 
+        protected bool DisableCursorOnStart => disableCursorOnStart;
+
         [SerializeField]
         private bool setCursorVisibilityOnSourceDetected = false;
 

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

@@ -17,34 +17,42 @@ namespace Microsoft.MixedReality.Toolkit.SDK.UX.Pointers
     /// </summary>
     public class MousePointer : BaseControllerPointer, IMixedRealityMousePointer
     {
+        private float timeoutTimer = 0.0f;
+
+        private bool isInteractionEnabled = false;
+
+        private bool cursorWasDisabledOnDown = false;
+
+        private bool isDisabled = true;
+
+        #region IMixedRealityMousePointer Implementaiton
+
         [SerializeField]
         [Tooltip("Should the mouse cursor be hidden when no active input is received?")]
         private bool hideCursorWhenInactive = true;
 
         /// <inheritdoc />
-        public bool HideCursorWhenInactive => hideCursorWhenInactive;
+        bool IMixedRealityMousePointer.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;
+        float IMixedRealityMousePointer.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;
+        float IMixedRealityMousePointer.HideTimeout => hideTimeout;
 
-        private float timeoutTimer;
+        #endregion IMixedRealityMousePointer Implementation
 
-        private bool isInteractionEnabled = false;
-
-        private bool cursorWasDisabledOnDown = false;
+        #region IMixedRealityPointer Implementaiton
 
         /// <inheritdoc />
         public override bool IsInteractionEnabled => isInteractionEnabled;
@@ -82,61 +90,57 @@ public override void OnPreRaycast()
             }
         }
 
-        public override void OnSourcePoseChanged(SourcePoseEventData<Vector2> eventData)
+        #endregion IMixedRealityPointer Implementaiton
+
+        #region IMixedRealitySourcePoseHandler Implementaiton
+
+        /// <inheritdoc />
+        public override void OnSourceDetected(SourceStateEventData eventData)
         {
-            if (Controller == null ||
-                eventData.Controller == null ||
-                eventData.Controller.InputSource.SourceId != Controller.InputSource.SourceId)
+            if (RayStabilizer != null)
             {
-                return;
+                RayStabilizer = null;
             }
 
-            if (UseSourcePoseData)
-            {
-                if (BaseCursor != null &&
-                    !BaseCursor.IsVisible &&
-                    (eventData.SourceData.x >= movementThresholdToUnHide ||
-                     eventData.SourceData.y >= MovementThresholdToUnHide))
-                {
-                    BaseCursor.SetVisibility(true);
-                    transform.rotation = CameraCache.Main.transform.rotation;
-                }
+            base.OnSourceDetected(eventData);
 
-                var newRotation = Vector3.zero;
-                newRotation.x += eventData.SourceData.y;
-                newRotation.y += eventData.SourceData.x;
-                transform.Rotate(newRotation, Space.World);
+            if (eventData.SourceId == Controller?.InputSource.SourceId)
+            {
+                isInteractionEnabled = true;
             }
         }
 
         /// <inheritdoc />
-        public override void OnPositionInputChanged(InputEventData<Vector2> eventData)
+        public override void OnSourceLost(SourceStateEventData eventData)
         {
+            base.OnSourceLost(eventData);
+
             if (eventData.SourceId == Controller?.InputSource.SourceId)
             {
-                if (!UseSourcePoseData &&
-                    PoseAction == eventData.MixedRealityInputAction)
-                {
-                    if (BaseCursor != null &&
-                        !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;
-                    transform.Rotate(newRotation, Space.World);
-                }
+                isInteractionEnabled = false;
             }
         }
 
+        /// <inheritdoc />
+        public override void OnSourcePoseChanged(SourcePoseEventData<Vector2> eventData)
+        {
+            if (Controller == null ||
+                eventData.Controller == null ||
+                eventData.Controller.InputSource.SourceId != Controller.InputSource.SourceId)
+            {
+                return;
+            }
+
+            if (UseSourcePoseData)
+            {
+                UpdateMousePosition(eventData.SourceData.x, eventData.SourceData.y);
+            }
+        }
+
+        #endregion IMixedRealitySourcePoseHandler Implementaiton
+
+        #region IMixedRealityInputHandler Implementaiton
+
         /// <inheritdoc />
         public override void OnInputDown(InputEventData eventData)
         {
@@ -162,8 +166,27 @@ public override void OnInputUp(InputEventData eventData)
             }
         }
 
+        /// <inheritdoc />
+        public override void OnPositionInputChanged(InputEventData<Vector2> eventData)
+        {
+            if (eventData.SourceId == Controller?.InputSource.SourceId)
+            {
+                if (!UseSourcePoseData &&
+                    PoseAction == eventData.MixedRealityInputAction)
+                {
+                    UpdateMousePosition(eventData.InputData.x, eventData.InputData.y);
+                }
+            }
+        }
+
+        #endregion IMixedRealityInputHandler Implementaiton
+
+        #region Monobehaviour Implementaiton
+
         protected override void Start()
         {
+            isDisabled = DisableCursorOnStart;
+
             base.Start();
 
             if (RayStabilizer != null)
@@ -183,42 +206,42 @@ protected override void Start()
 
         private void Update()
         {
-            if (!isInteractionEnabled) { return; }
+            if (!hideCursorWhenInactive || isDisabled) { return; }
 
             timeoutTimer += Time.unscaledDeltaTime;
 
             if (timeoutTimer >= hideTimeout)
             {
                 timeoutTimer = 0.0f;
                 BaseCursor?.SetVisibility(false);
+                isDisabled = true;
             }
         }
 
-        /// <inheritdoc />
-        public override void OnSourceDetected(SourceStateEventData eventData)
+        #endregion Monobehaviour Implementaiton
+
+        private void UpdateMousePosition(float mouseX, float mouseY)
         {
-            if (RayStabilizer != null)
+            if (Mathf.Abs(mouseX) >= movementThresholdToUnHide ||
+                Mathf.Abs(mouseY) >= movementThresholdToUnHide)
             {
-                RayStabilizer = null;
-            }
-
-            base.OnSourceDetected(eventData);
+                if (isDisabled)
+                {
+                    BaseCursor?.SetVisibility(true);
+                    transform.rotation = CameraCache.Main.transform.rotation;
+                }
+                else
+                {
+                    timeoutTimer = 0.0f;
+                }
 
-            if (eventData.SourceId == Controller?.InputSource.SourceId)
-            {
-                isInteractionEnabled = true;
+                isDisabled = false;
             }
-        }
-
-        /// <inheritdoc />
-        public override void OnSourceLost(SourceStateEventData eventData)
-        {
-            base.OnSourceLost(eventData);
 
-            if (eventData.SourceId == Controller?.InputSource.SourceId)
-            {
-                isInteractionEnabled = false;
-            }
+            var newRotation = Vector3.zero;
+            newRotation.x += mouseX;
+            newRotation.y += mouseY;
+            transform.Rotate(newRotation, Space.World);
         }
     }
 }

Assets/MixedRealityToolkit-SDK/Features/UX/Scripts/Utilities/HoverLight.cs

@@ -91,7 +91,8 @@ private void AddHoverLight(HoverLight light)
         {
             if (activeHoverLights.Count >= hoverLightCount)
             {
-                Debug.LogWarningFormat("Max hover light count ({0}) exceeded.", hoverLightCount);
+                Debug.LogWarning($"Max hover light count ({hoverLightCount}) exceeded.");
+                return;
             }
 
             activeHoverLights.Add(light);

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

@@ -10,8 +10,8 @@ namespace Microsoft.MixedReality.Toolkit.SDK.Inspectors.UX.Pointers
     public class MousePointerInspector : BaseControllerPointerInspector
     {
         private SerializedProperty hideCursorWhenInactive;
-        private SerializedProperty movementThresholdToUnHide;
         private SerializedProperty hideTimeout;
+        private SerializedProperty movementThresholdToUnHide;
         private bool mousePointerFoldout = true;
 
         protected override void OnEnable()
@@ -38,8 +38,8 @@ public override void OnInspectorGUI()
 
                 if (hideCursorWhenInactive.boolValue)
                 {
-                    EditorGUILayout.PropertyField(movementThresholdToUnHide);
                     EditorGUILayout.PropertyField(hideTimeout);
+                    EditorGUILayout.PropertyField(movementThresholdToUnHide);
                 }
 
                 EditorGUI.indentLevel--;

Assets/MixedRealityToolkit/_Core/Devices/UnityInput/MouseController.cs

@@ -74,8 +74,8 @@ public void Update()
             }
 
             // Don't ask me why it's mapped weird. Bc Unity...
-            mouseDelta.x = Input.GetAxis("Mouse X");
-            mouseDelta.y = -Input.GetAxis("Mouse Y");
+            mouseDelta.x = -Input.GetAxis("Mouse Y");
+            mouseDelta.y = Input.GetAxis("Mouse X");
             MixedRealityToolkit.InputSystem?.RaiseSourcePositionChanged(InputSource, this, mouseDelta);
             MixedRealityToolkit.InputSystem?.RaiseSourcePoseChanged(InputSource, this, controllerPose);
             MixedRealityToolkit.InputSystem?.RaiseSourcePositionChanged(InputSource, this, Input.mouseScrollDelta);