Merge pull request #2201 from keveleigh/PointingRaysExtra

[May18] Updating pointing rays to extend out to the pointing extent off holograms

Author: David Kline

Assets/HoloToolkit/Input/Prefabs/LinearControllerPointer.prefab

@@ -62,7 +62,6 @@ MonoBehaviour:
   ScaleOffset: {x: 1, y: 1, z: 1}
   SetScaleOnAttach: 0
   CurrentPointerOrientation: 0
-  extentOverride: 2
   RaycastOrigin: {fileID: 0}
   LineColorSelected:
     serializedVersion: 2

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

@@ -20,7 +20,24 @@ public abstract class Cursor : MonoBehaviour, ICursor
         /// <summary>
         /// The pointer that this cursor should follow and process input from.
         /// </summary>
-        public IPointingSource Pointer { get; set; }
+        public IPointingSource Pointer
+        {
+            get { return pointer; }
+            set
+            {
+                // This value is used to determine the cursor's default distance.
+                // It is cached here to prevent repeated casting in the update loop.
+                pointerIsInputSourcePointer = value is InputSourcePointer;
+                pointer = value;
+            }
+        }
+        private IPointingSource pointer;
+
+        /// <summary>
+        /// Cached value if the pointer is of type InputSourcePointer,
+        /// to prevent repeated casting in the update loop.
+        /// </summary>
+        private bool pointerIsInputSourcePointer = false;
 
         /// <summary>
         /// Minimum distance for cursor if nothing is hit
@@ -110,6 +127,12 @@ public Vector3 LocalScale
         private Vector3 targetScale;
         private Quaternion targetRotation;
 
+        /// <summary>
+        /// Keeps track of the starting setting for DefaultCursorDistance,
+        /// to revert after a pointer overrides the value.
+        /// </summary>
+        private float originalDefaultCursorDistance;
+
         /// <summary>
         /// Indicates if the cursor should be visible
         /// </summary>
@@ -126,6 +149,8 @@ public bool IsVisible
 
         private void Awake()
         {
+            originalDefaultCursorDistance = DefaultCursorDistance;
+
             // Use the setter to update visibility of the cursor at startup based on user preferences
             IsVisible = isVisible;
             SetVisibility(isVisible);
@@ -298,6 +323,21 @@ protected virtual void UpdateCursorTransform()
                 TargetedObject = null;
                 TargetedCursorModifier = null;
 
+                if (pointerIsInputSourcePointer)
+                {
+                    // This value get re-queried every update, in case the app has
+                    // changed the pointing extent of the pointer for the current scenario.
+                    float distance = FocusManager.Instance.GetPointingExtent(Pointer);
+                    if (DefaultCursorDistance != distance)
+                    {
+                        DefaultCursorDistance = distance;
+                    }
+                }
+                else if (DefaultCursorDistance != originalDefaultCursorDistance)
+                {
+                    DefaultCursorDistance = originalDefaultCursorDistance;
+                }
+
                 targetPosition = RayStep.GetPointByDistance(Pointer.Rays, DefaultCursorDistance);
                 lookForward = -RayStep.GetDirectionByDistance(Pointer.Rays, DefaultCursorDistance);
                 targetRotation = lookForward.magnitude > 0 ? Quaternion.LookRotation(lookForward, Vector3.up) : transform.rotation;

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

@@ -129,7 +129,7 @@ public virtual void OnPostRaycast()
         {
             if (PointerRay != null)
             {
-                PointerRay.UpdateRenderedLine(rays, Result, selectPressed);
+                PointerRay.UpdateRenderedLine(rays, Result, selectPressed, FocusManager.Instance.GetPointingExtent(this));
             }
         }
 

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

@@ -30,14 +30,16 @@ public class SimpleSinglePointerSelector : MonoBehaviour, ISourceStateHandler, I
         private bool searchForCursorIfUnset = true;
         public bool SearchForCursorIfUnset { get { return searchForCursorIfUnset; } set { searchForCursorIfUnset = value; } }
 
-        [Tooltip("If true, always select the best pointer available (OS behaviour does not autoselect).")]
+        [Tooltip("If true, always select the best pointer available (OS behavior does not auto-select).")]
         [SerializeField]
         private bool autoselectBestAvailable = false;
         public bool AutoselectBestAvailable { get { return autoselectBestAvailable; } set { autoselectBestAvailable = value; } }
 
         [Tooltip("The line pointer prefab to use, if any.")]
         [SerializeField]
-        private GameObject linePointerPrefab;
+        private GameObject linePointerPrefab = null;
+
+        private PointerLine instantiatedPointerLine;
 
         #endregion
 
@@ -301,30 +303,43 @@ private void AttachInputSourcePointer(IInputSource inputSource, uint sourceId)
             inputSourcePointer.ExtentOverride = null;
             inputSourcePointer.PrioritizedLayerMasksOverride = null;
 
-            if (inputSourcePointer.PointerRay != null)
+            InteractionInputSource interactionInputSource = inputSource as InteractionInputSource;
+
+            // If the InputSource is not an InteractionInputSource, we don't display any ray visualizations.
+            if (interactionInputSource == null)
             {
-                Destroy(inputSourcePointer.PointerRay.gameObject);
+                return;
             }
 
-            if (inputSource is InteractionInputSource && linePointerPrefab != null)
+            // If no pointing ray prefab has been provided, we return early as there's nothing to display.
+            if (linePointerPrefab == null)
+            {
+                return;
+            }
+
+            // If the pointer line hasn't already been instantiated, create it and store it here.
+            if (instantiatedPointerLine == null)
+            {
+                instantiatedPointerLine = Instantiate(linePointerPrefab).GetComponent<PointerLine>();
+            }
+
+            inputSourcePointer.PointerRay = instantiatedPointerLine;
+
+            Handedness handedness;
+            if (interactionInputSource.TryGetHandedness(sourceId, out handedness))
             {
-                inputSourcePointer.PointerRay = Instantiate(linePointerPrefab).GetComponent<PointerLine>();
-                inputSourcePointer.PointerRay.ExtentOverride = Cursor.DefaultCursorDistance;
-                Handedness handedness;
-                if (((InteractionInputSource)inputSource).TryGetHandedness(sourceId, out handedness))
-                {
 #if UNITY_WSA && UNITY_2017_2_OR_NEWER
-                    inputSourcePointer.PointerRay.Handedness = (InteractionSourceHandedness)handedness;
+                // This updates the handedness of the pointer line, allowing for re-use if it was already in the scene.
+                instantiatedPointerLine.ChangeHandedness((InteractionSourceHandedness)handedness);
 #endif
-                }
             }
         }
 
         private void DetachInputSourcePointer()
         {
-            if (inputSourcePointer.PointerRay != null)
+            if (instantiatedPointerLine != null)
             {
-                Destroy(inputSourcePointer.PointerRay.gameObject);
+                Destroy(instantiatedPointerLine.gameObject);
             }
         }
 

Assets/HoloToolkit/Input/Scripts/Utilities/BaseControllerPointer.cs

@@ -10,20 +10,10 @@ public abstract class BaseControllerPointer : AttachToController
     [Range(0f, 360f)]
     protected float CurrentPointerOrientation;
 
-    [SerializeField]
-    [Range(0.5f, 50f)]
-    private float extentOverride = 2f;
-
     [SerializeField]
     [Tooltip("Source transform for raycast origin - leave null to use default transform")]
     protected Transform RaycastOrigin;
 
-    public float? ExtentOverride
-    {
-        get { return extentOverride; }
-        set { extentOverride = value ?? FocusManager.Instance.GlobalPointingExtent; }
-    }
-
     /// <summary>
     /// The Y orientation of the pointer target - used for touchpad rotation and navigation
     /// </summary>

Assets/HoloToolkit/Input/Scripts/Utilities/ControllerFinder.cs

@@ -90,6 +90,22 @@ protected virtual void OnDestroy()
 #endif
         }
 
+        /// <summary>
+        /// Allows the object to change which controller it tracks, based on handedness.
+        /// </summary>
+        /// <param name="newHandedness">The new handedness to track. Does nothing if the handedness doesn't change.</param>
+#if UNITY_WSA && UNITY_2017_2_OR_NEWER
+        public void ChangeHandedness(InteractionSourceHandedness newHandedness)
+        {
+            if (newHandedness != handedness)
+            {
+                RemoveControllerTransform(ControllerInfo);
+                handedness = newHandedness;
+                CheckModelAlreadyLoaded();
+            }
+        }
+#endif
+
         protected virtual void AddControllerTransform(MotionControllerInfo newController)
         {
 #if UNITY_WSA && UNITY_2017_2_OR_NEWER

Assets/HoloToolkit/Input/Scripts/Utilities/PointerLine.cs

@@ -67,7 +67,7 @@ protected override void OnEnable()
             LineBase.enabled = false;
         }
 
-        public void UpdateRenderedLine(RayStep[] lines, PointerResult result, bool selectPressed)
+        public void UpdateRenderedLine(RayStep[] lines, PointerResult result, bool selectPressed, float extent)
         {
             if (LineBase == null) { return; }
 
@@ -85,7 +85,7 @@ public void UpdateRenderedLine(RayStep[] lines, PointerResult result, bool selec
                 }
                 else
                 {
-                    LineBase.LastPoint = RayStep.GetPointByDistance(lines, ExtentOverride.Value);
+                    LineBase.LastPoint = RayStep.GetPointByDistance(lines, extent);
                 }
 
                 if (selectPressed)