Cursor now honors default distances via RayStep utility functions

Author: Railboy

Assets/HoloToolkit/Input/Scripts/Cursor/Cursor.cs

@@ -288,10 +288,7 @@ protected virtual void UpdateCursorTransform()
         {
             FocusDetails focusDetails = FocusManager.Instance.GetFocusDetails(Pointer);
             GameObject newTargetedObject = focusDetails.Object;
-
-            // Get the forward vector looking back along the pointing ray.
-            RayStep lastStep = Pointer.Rays[Pointer.Rays.Length - 1];
-            Vector3 lookForward = -lastStep.direction;
+            Vector3 lookForward = Vector3.forward;
 
             // Normalize scale on before update
             targetScale = Vector3.one;
@@ -301,7 +298,9 @@ protected virtual void UpdateCursorTransform()
             {
                 TargetedObject = null;
                 TargetedCursorModifier = null;
-                targetPosition = lastStep.terminus;
+
+                targetPosition = RayStep.GetPointByDistance(Pointer.Rays, DefaultCursorDistance);
+                lookForward = -RayStep.GetDirectionByDistance(Pointer.Rays, DefaultCursorDistance);
                 targetRotation = lookForward.magnitude > 0 ? Quaternion.LookRotation(lookForward, Vector3.up) : transform.rotation;
             }
             else
@@ -316,6 +315,10 @@ protected virtual void UpdateCursorTransform()
                 else
                 {
                     // If no modifier is on the target, just use the hit result to set cursor position
+                    // Get the look forward by using distance between pointer origin and target position
+                    // (This may not be strictly accurate for extremely wobbly pointers, but it should produce usable results)
+                    float distanceToTarget = Vector3.Distance(Pointer.Rays[0].origin, focusDetails.Point);
+                    lookForward = -RayStep.GetDirectionByDistance(Pointer.Rays, distanceToTarget);
                     targetPosition = focusDetails.Point + (lookForward * SurfaceCursorDistance);
                     Vector3 lookRotation = Vector3.Slerp(focusDetails.Normal, lookForward, LookRotationBlend);
                     targetRotation = Quaternion.LookRotation(lookRotation == Vector3.zero ? lookForward : lookRotation, Vector3.up);

Assets/HoloToolkit/Input/Scripts/Focus/RayStep.cs

@@ -44,5 +44,94 @@ public static implicit operator Ray(RayStep r)
         {
             return new Ray(r.origin, r.direction);
         }
+
+        #region static utility functions
+
+        /// <summary>
+        /// Returns a point along an array of RaySteps by distance
+        /// </summary>
+        /// <param name="steps"></param>
+        /// <param name="distance"></param>
+        /// <returns></returns>
+        public static Vector3 GetPointByDistance(RayStep[] steps, float distance)
+        {
+            Debug.Assert(steps != null);
+            Debug.Assert(steps.Length > 0);
+
+            Vector3 point = Vector3.zero;
+            float remainingDistance = distance;
+
+            for (int i = 0; i < steps.Length; i++)
+            {
+                if (remainingDistance > steps[i].length)
+                {
+                    remainingDistance -= steps[i].length;
+                }
+                else
+                {
+                    point = Vector3.Lerp(steps[i].origin, steps[i].terminus, remainingDistance / steps[i].length);
+                    remainingDistance = 0;
+                    break;
+                }
+            }
+
+            if (remainingDistance > 0)
+            {
+                // If we reach the end and still have distance left, set the point to the terminus of the last step
+                point = steps[steps.Length - 1].terminus;
+            }
+
+            return point;
+        }
+
+        /// <summary>
+        /// Returns a RayStep along an array of RaySteps by distance
+        /// </summary>
+        /// <param name="steps"></param>
+        /// <param name="distance"></param>
+        /// <returns></returns>
+        public static RayStep GetStepByDistance(RayStep[] steps, float distance)
+        {
+            Debug.Assert(steps != null);
+            Debug.Assert(steps.Length > 0);
+
+            RayStep step = new RayStep();
+            float remainingDistance = distance;
+
+            for (int i = 0; i < steps.Length; i++)
+            {
+                if (remainingDistance > steps[i].length)
+                {
+                    remainingDistance -= steps[i].length;
+                }
+                else
+                {
+                    step = steps[i];
+                    remainingDistance = 0;
+                    break;
+                }
+            }
+            
+            if (remainingDistance > 0)
+            {
+                // If we reach the end and still have distance left, return the last step
+                step = steps[steps.Length - 1];
+            }
+
+            return step;
+        }
+
+        /// <summary>
+        /// Returns a direction along an array of RaySteps by distance
+        /// </summary>
+        /// <param name="steps"></param>
+        /// <param name="distance"></param>
+        /// <returns></returns>
+        public static Vector3 GetDirectionByDistance(RayStep[] steps, float distance)
+        {
+            return GetStepByDistance(steps, distance).direction;
+        }
+
+        #endregion
     }
 }