Merge pull request #2398 from StephenHodgson/vNEXT-AttachToControllerRefactor

Refactored Pointers & Broke out raycasting into it's own static class.

Author: StephenHodgson

Assets/MixedRealityToolkit/InputSystem/Focus/FocusProvider.cs

@@ -7,6 +7,7 @@
 using Microsoft.MixedReality.Toolkit.Internal.Interfaces.InputSystem;
 using Microsoft.MixedReality.Toolkit.Internal.Managers;
 using Microsoft.MixedReality.Toolkit.Internal.Utilities;
+using Microsoft.MixedReality.Toolkit.Internal.Utilities.Physics;
 using System;
 using System.Collections.Generic;
 using UnityEngine;
@@ -530,6 +531,8 @@ private void UpdatePointers()
 
                 if (debugDrawPointingRays)
                 {
+                    MixedRealityRaycaster.DebugEnabled = debugDrawPointingRays;
+
                     Color rayColor;
 
                     if ((debugDrawPointingRayColors != null) && (debugDrawPointingRayColors.Length > 0))
@@ -581,7 +584,7 @@ private void UpdatePointer(PointerData pointer)
                     }
 
                     // Set the pointer's result last
-                    pointer.Pointer.Result = pointer as IPointerResult;
+                    pointer.Pointer.Result = pointer;
                 }
             }
 
@@ -591,12 +594,14 @@ private void UpdatePointer(PointerData pointer)
             pointer.Pointer.OnPostRaycast();
         }
 
+        #region Physics Raycasting
+
         /// <summary>
         /// Perform a Unity physics Raycast to determine which scene objects with a collider is currently being gazed at, if any.
         /// </summary>
         /// <param name="pointer"></param>
         /// <param name="prioritizedLayerMasks"></param>
-        private void RaycastPhysics(PointerData pointer, LayerMask[] prioritizedLayerMasks)
+        private static void RaycastPhysics(PointerData pointer, LayerMask[] prioritizedLayerMasks)
         {
             bool isHit = false;
             int rayStepIndex = 0;
@@ -609,15 +614,34 @@ private void RaycastPhysics(PointerData pointer, LayerMask[] prioritizedLayerMas
             // Check raycast for each step in the pointing source
             for (int i = 0; i < pointer.Pointer.Rays.Length; i++)
             {
-                if (RaycastPhysicsStep(pointer.Pointer.Rays[i], prioritizedLayerMasks, out physicsHit))
+                switch (pointer.Pointer.RaycastMode)
                 {
-                    // Set the pointer source's origin ray to this step
-                    isHit = true;
-                    rayStep = pointer.Pointer.Rays[i];
-                    rayStepIndex = i;
-                    // No need to continue once we've hit something
-                    break;
+                    case RaycastModeType.Simple:
+                        if (MixedRealityRaycaster.RaycastSimplePhysicsStep(pointer.Pointer.Rays[i], prioritizedLayerMasks, out physicsHit))
+                        {
+                            // Set the pointer source's origin ray to this step
+                            isHit = true;
+                            rayStep = pointer.Pointer.Rays[i];
+                            rayStepIndex = i;
+                        }
+                        break;
+                    case RaycastModeType.Box:
+                        Debug.LogWarning("Box Raycasting Mode not supported for pointers.");
+                        break;
+                    case RaycastModeType.Sphere:
+                        if (MixedRealityRaycaster.RaycastSpherePhysicsStep(pointer.Pointer.Rays[i], pointer.Pointer.SphereCastRadius, prioritizedLayerMasks, out physicsHit))
+                        {
+                            // Set the pointer source's origin ray to this step
+                            isHit = true;
+                            rayStep = pointer.Pointer.Rays[i];
+                            rayStepIndex = i;
+                        }
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
                 }
+
+                if (isHit) { break; }
             }
 
             if (isHit)
@@ -630,62 +654,9 @@ private void RaycastPhysics(PointerData pointer, LayerMask[] prioritizedLayerMas
             }
         }
 
-        /// <summary>
-        /// Raycasts each physics <see cref="RayStep"/>
-        /// </summary>
-        /// <param name="step"></param>
-        /// <param name="prioritizedLayerMasks"></param>
-        /// <param name="physicsHit"></param>
-        /// <returns></returns>
-        private bool RaycastPhysicsStep(RayStep step, LayerMask[] prioritizedLayerMasks, out RaycastHit physicsHit)
-        {
-            return prioritizedLayerMasks.Length == 1
-                // If there is only one priority, don't prioritize
-                ? Physics.Raycast(step.Origin, step.Direction, out physicsHit, step.Length, prioritizedLayerMasks[0])
-                // Raycast across all layers and prioritize
-                : TryGetPrioritizedHit(Physics.RaycastAll(step.Origin, step.Direction, step.Length, Physics.AllLayers), prioritizedLayerMasks, out physicsHit);
-        }
-
-        /// <summary>
-        /// Tries to ge the prioritized raycast hit based on the prioritized layer masks.
-        /// <para><remarks>Sorts all hit objects first by layerMask, then by distance.</remarks></para>
-        /// </summary>
-        /// <param name="hits"></param>
-        /// <param name="priorityLayers"></param>
-        /// <param name="raycastHit"></param>
-        /// <returns>The minimum distance hit within the first layer that has hits</returns>
-        private static bool TryGetPrioritizedHit(RaycastHit[] hits, LayerMask[] priorityLayers, out RaycastHit raycastHit)
-        {
-            raycastHit = default(RaycastHit);
-
-            if (hits.Length == 0)
-            {
-                return false;
-            }
-
-            for (int layerMaskIdx = 0; layerMaskIdx < priorityLayers.Length; layerMaskIdx++)
-            {
-                RaycastHit? minHit = null;
-
-                for (int hitIdx = 0; hitIdx < hits.Length; hitIdx++)
-                {
-                    RaycastHit hit = hits[hitIdx];
-                    if (hit.transform.gameObject.layer.IsInLayerMask(priorityLayers[layerMaskIdx]) &&
-                        (minHit == null || hit.distance < minHit.Value.distance))
-                    {
-                        minHit = hit;
-                    }
-                }
-
-                if (minHit != null)
-                {
-                    raycastHit = minHit.Value;
-                    return true;
-                }
-            }
+        #endregion Physics Raycasting
 
-            return false;
-        }
+        #region uGUI Graphics Raycasting
 
         /// <summary>
         /// Perform a Unity Graphics Raycast to determine which uGUI element is currently being gazed at, if any.
@@ -736,6 +707,15 @@ private void RaycastGraphics(PointerData pointer, LayerMask[] prioritizedLayerMa
             }
         }
 
+        /// <summary>
+        /// Raycasts each graphic <see cref="RayStep"/>
+        /// </summary>
+        /// <param name="pointer"></param>
+        /// <param name="step"></param>
+        /// <param name="prioritizedLayerMasks"></param>
+        /// <param name="overridePhysicsRaycast"></param>
+        /// <param name="uiRaycastResult"></param>
+        /// <returns></returns>
         private bool RaycastGraphicsStep(PointerData pointer, RayStep step, LayerMask[] prioritizedLayerMasks, out bool overridePhysicsRaycast, out RaycastResult uiRaycastResult)
         {
             // Move the uiRaycast camera to the current pointer's position.
@@ -790,6 +770,8 @@ private bool RaycastGraphicsStep(PointerData pointer, RayStep step, LayerMask[]
             return false;
         }
 
+        #endregion uGUI Graphics Raycasting
+
         /// <summary>
         /// Raises the Focus Events to the Input Manger if needed.
         /// </summary>

Assets/MixedRealityToolkit/InputSystem/Gaze/GazeProvider.cs

@@ -18,6 +18,10 @@ namespace Microsoft.MixedReality.Toolkit.InputSystem.Gaze
     [DisallowMultipleComponent]
     public class GazeProvider : MonoBehaviour, IMixedRealityGazeProvider
     {
+        private const float VelocityThreshold = 0.1f;
+
+        private const float MovementThreshold = 0.01f;
+
         [SerializeField]
         [Tooltip("Optional Cursor Prefab to use if you don't wish to reference a cursor in the scene.")]
         private GameObject cursorPrefab = null;
@@ -60,6 +64,16 @@ public class GazeProvider : MonoBehaviour, IMixedRealityGazeProvider
         [Tooltip("Transform that should be used to represent the gaze position and rotation. Defaults to CameraCache.Main")]
         private Transform gazeTransform = null;
 
+        [SerializeField]
+        [Range(0.01f, 1f)]
+        [Tooltip("Minimum head velocity threshold")]
+        private float minHeadVelocityThreshold = 0.5f;
+
+        [SerializeField]
+        [Range(0.1f, 5f)]
+        [Tooltip("Maximum head velocity threshold")]
+        private float maxHeadVelocityThreshold = 2f;
+
         [SerializeField]
         [Tooltip("True to draw a debug view of the ray.")]
         private bool debugDrawRay = false;
@@ -103,10 +117,18 @@ public IMixedRealityInputSource GazeInputSource
         /// <inheritdoc />
         public Vector3 GazeDirection => GazePointer.Rays[0].Direction;
 
+        /// <inheritdoc />
+        public Vector3 HeadVelocity { get; private set; }
+
+        /// <inheritdoc />
+        public Vector3 HeadMovementDirection { get; private set; }
+
         private float lastHitDistance = 2.0f;
 
         private bool delayInitialization = true;
 
+        private Vector3 lastHeadPosition = Vector3.zero;
+
         private IMixedRealityInputSystem inputSystem = null;
         private IMixedRealityInputSystem InputSystem => inputSystem ?? (inputSystem = MixedRealityManager.Instance.GetManager<IMixedRealityInputSystem>());
 
@@ -197,6 +219,11 @@ public override bool TryGetPointerRotation(out Quaternion rotation)
 
         #region Monobehaiour Implementation
 
+        private void OnValidate()
+        {
+            Debug.Assert(minHeadVelocityThreshold < maxHeadVelocityThreshold, "Minimum head velocity threshold should be less than the maximum velocity threshold.");
+        }
+
         protected virtual void OnEnable()
         {
             if (!delayInitialization)
@@ -241,6 +268,44 @@ private void Update()
             }
         }
 
+        private void LateUpdate()
+        {
+            // Update head velocity.
+            Vector3 headPosition = GazeOrigin;
+            Vector3 headDelta = headPosition - lastHeadPosition;
+
+            if (headDelta.sqrMagnitude < MovementThreshold * MovementThreshold)
+            {
+                headDelta = Vector3.zero;
+            }
+
+            if (Time.fixedDeltaTime > 0)
+            {
+                float velocityAdjustmentRate = 3f * Time.fixedDeltaTime;
+                HeadVelocity = HeadVelocity * (1f - velocityAdjustmentRate) + headDelta * velocityAdjustmentRate / Time.fixedDeltaTime;
+
+                if (HeadVelocity.sqrMagnitude < VelocityThreshold * VelocityThreshold)
+                {
+                    HeadVelocity = Vector3.zero;
+                }
+            }
+
+            // Update Head Movement Direction
+            float multiplier = Mathf.Clamp01(Mathf.InverseLerp(minHeadVelocityThreshold, maxHeadVelocityThreshold, HeadVelocity.magnitude));
+
+            Vector3 newHeadMoveDirection = Vector3.Lerp(headPosition, HeadVelocity, multiplier).normalized;
+            lastHeadPosition = headPosition;
+            float directionAdjustmentRate = Mathf.Clamp01(5f * Time.fixedDeltaTime);
+
+            HeadMovementDirection = Vector3.Slerp(HeadMovementDirection, newHeadMoveDirection, directionAdjustmentRate);
+
+            if (debugDrawRay)
+            {
+                Debug.DrawLine(lastHeadPosition, lastHeadPosition + HeadMovementDirection * 10f, Color.Lerp(Color.red, Color.green, multiplier));
+                Debug.DrawLine(lastHeadPosition, lastHeadPosition + HeadVelocity, Color.yellow);
+            }
+        }
+
         private void OnDisable()
         {
             GazePointer.BaseCursor?.SetVisibility(false);