Remove allocs from idle and selecting ray interactor (#11344)

* Line visual now only applies compression effect when the ray interactor has hit an object

* adjusted gradient compress algorithm to be more compact and efficient

* added deadzone parameter to the input simulator so axis values would reach 0 or 1

* reorganized line visuals script, made adjustments to minimize color utilities calls when not needed

* adjusted prefab values to be less aggressive with the compression effect

* removing unused perf marker

Co-authored-by: Finn Sinclair <finnnorth@gmail.com>

Author: RogPodge

com.microsoft.mrtk.core/Utilities/ColorUtilities.cs

@@ -56,38 +56,26 @@ public static Gradient GradientCompress(Gradient a, float p1, float p2)
                 return a;
             }
 
-            // List of all the unique key times
-            cachedKeyTimes.Clear();
-
-            for (int i = 0; i < a.colorKeys.Length; i++)
+            float compressionRatio = p2 - p1;
+            if (p1 == 0.0f && compressionRatio == 1.0f)
             {
-                float k = a.colorKeys[i].time;
-                if (!cachedKeyTimes.Contains(k))
-                    cachedKeyTimes.Add(k);
+                return a;
             }
 
-            for (int i = 0; i < a.alphaKeys.Length; i++)
+            // This call will alloc because .colorKeys and .alphaKeys creates copies of the underlying arrays
+            GradientColorKey[] clrs = a.colorKeys;
+            GradientAlphaKey[] alphas = a.alphaKeys;
+
+            for (int i = 0; i < clrs.Length; i++)
             {
-                float k = a.alphaKeys[i].time;
-                if (!cachedKeyTimes.Contains(k))
-                    cachedKeyTimes.Add(k);
+                var newTime = p1 + compressionRatio * clrs[i].time;
+                clrs[i].time = newTime;
             }
 
-            GradientColorKey[] clrs = new GradientColorKey[cachedKeyTimes.Count];
-            GradientAlphaKey[] alphas = new GradientAlphaKey[cachedKeyTimes.Count];
-            int gradientIdx = 0;
-
-            float compressionRatio = p2 - p1;
-
-            // Pick colors of both gradients at key times and lerp them
-            foreach (float time in cachedKeyTimes)
+            for (int i = 0; i < alphas.Length; i++)
             {
-                var newTime = p1 + compressionRatio * time;
-
-                var clr = a.Evaluate(time);
-                clrs[gradientIdx] = new GradientColorKey(clr, newTime);
-                alphas[gradientIdx] = new GradientAlphaKey(clr.a, newTime);
-                gradientIdx++;
+                var newTime = p1 + compressionRatio * alphas[i].time;
+                alphas[i].time = newTime;
             }
 
             var g = new Gradient();
@@ -97,8 +85,8 @@ public static Gradient GradientCompress(Gradient a, float p1, float p2)
         }
 
         // Caching the key times to not create a new HashSet every time this is called.
-        static HashSet<float> cachedKeyTimes = new HashSet<float>();
-        static Gradient GradientLerp(Gradient a, Gradient b, float t, bool noAlpha, bool noColor)
+        private static HashSet<float> cachedKeyTimes = new HashSet<float>();
+        private static Gradient GradientLerp(Gradient a, Gradient b, float t, bool noAlpha, bool noColor)
         {
             if (t == 0.0f)
             {

com.microsoft.mrtk.input/Assets/Prefabs/MRTK LeftHand Controller.prefab

@@ -410,7 +410,7 @@ MonoBehaviour:
     m_Mode: 0
     m_NumColorKeys: 2
     m_NumAlphaKeys: 2
-  maxGradientLength: 0.1
+  maxGradientLength: 0.3
   lineWidth:
     serializedVersion: 2
     m_Curve:

com.microsoft.mrtk.input/Interactors/InteractorVisuals/MRTKLineVisual.cs

@@ -70,12 +70,12 @@ public Gradient SelectActiveColorGradient
         }
 
         [SerializeField]
-        [Tooltip("Controls the length of the visual that the gradient is applied relative to the ray interactor's max raycast distance")]
+        [Tooltip("On hit, the gradient will be applied evenly along the line renderer until it's total length is longer than this value multiplied by the ray interactor's max raycast distance")]
         [Range(0.01f, 1)]
-        float maxGradientLength = 0.1f;
+        float maxGradientLength = 0.3f;
 
         /// <summary>
-        /// Controls the length of the visual that the gradient is applied relative to the ray interactor's max raycast distance
+        /// On hit, the gradient will be applied evenly along the line renderer until it's total length is longer than this value multiplied by the ray interactor's max raycast distance.
         /// </summary>
         public float MaxGradientLength
         {
@@ -268,6 +268,9 @@ protected void OnDisable()
 
         private static readonly ProfilerMarker UpdateLinePerfMarker = new ProfilerMarker("[MRTK] MRTKLineVisual.UpdateLineVisual");
 
+        // Cached value of the current gradient. Used to avoid making calls to lineRenderer.colorGradient, which allocs
+        private Gradient cachedGradient = new Gradient();
+
         [BeforeRenderOrder(XRInteractionUpdateOrder.k_BeforeRenderLineVisual)]
         private void UpdateLineVisual()
         {
@@ -307,21 +310,18 @@ private void UpdateLineVisual()
                 // Finally enable the line renderer if we pass the other checks
                 lineRenderer.enabled = rayInteractor.isHoverActive;
 
-                // Assign the first point to the ray origin
-                lineDataProvider.FirstPoint = rayPositions[0];
-
-                IVariableSelectInteractor variableSelectInteractor = rayInteractor as IVariableSelectInteractor;
-
-                if (variableSelectInteractor != null)
+                // Exit early if the line renderer is ultimately disabled
+                if (!lineRenderer.enabled)
                 {
-                    lineRenderer.GetPropertyBlock(propertyBlock);
-                    propertyBlock.SetFloat("_Shift_", variableSelectInteractor.SelectProgress);
-                    lineRenderer.colorGradient = ColorUtilities.GradientLerp(ValidColorGradient, SelectActiveColorGradient, variableSelectInteractor.SelectProgress);
-                    lineRenderer.SetPropertyBlock(propertyBlock);
+                    ClearLineRenderer();
+                    return;
                 }
 
+                // Assign the first point to the ray origin
+                lineDataProvider.FirstPoint = rayPositions[0];
+
                 // If the interactor is currently selecting, lock the end of the ray to the selected object
-                if (rayInteractor.interactablesSelected.Count > 0)
+                if (rayInteractor.hasSelection)
                 {
                     // Assign the last point to the one saved by the callback
                     lineDataProvider.LastPoint = hitTargetTransform.TransformPoint(targetLocalHitPoint);
@@ -355,26 +355,6 @@ private void UpdateLineVisual()
 
                     // Assign the last point to last point in the data structure
                     lineDataProvider.LastPoint = rayPositions[rayPositionsCount - 1];
-
-                    // If we are hovering over a valid object, lerp the color based on pinchedness if applicable
-                    if (rayHasHit)
-                    {
-                        if (variableSelectInteractor != null)
-                        {
-                            lineRenderer.colorGradient = ColorUtilities.GradientLerp(ValidColorGradient, SelectActiveColorGradient, variableSelectInteractor.SelectProgress);
-                        }
-                        else
-                        {
-                            lineRenderer.colorGradient = ColorUtilities.GradientLerp(ValidColorGradient, SelectActiveColorGradient, rayInteractor.hasSelection ? 1 : 0);
-                        }
-                    }
-                    else
-                    {
-                        lineRenderer.colorGradient = NoTargetColorGradient;
-                    }
-
-                    var compressionAmount = Mathf.Clamp(rayInteractor.maxRaycastDistance * MaxGradientLength / hitDistance, 0.0f, 1.0f);
-                    lineRenderer.colorGradient = ColorUtilities.GradientCompress(lineRenderer.colorGradient, 0.0f, compressionAmount);
                 }
 
                 // Project forward based on pointer direction to get an 'expected' position of the first control point if we've hit an object
@@ -407,6 +387,39 @@ private void UpdateLineVisual()
                     rendererPositions[i] = lineDataProvider.GetPoint(normalizedDistance);
                 }
                 lineRenderer.SetPositions(rendererPositions);
+
+                // Now handle coloring the line visual
+                // If our interactor is a variable select interactor, change the material property based on select progress
+                IVariableSelectInteractor variableSelectInteractor = rayInteractor as IVariableSelectInteractor;
+                if (variableSelectInteractor != null)
+                {
+                    lineRenderer.GetPropertyBlock(propertyBlock);
+                    propertyBlock.SetFloat("_Shift_", variableSelectInteractor.SelectProgress);
+                    lineRenderer.SetPropertyBlock(propertyBlock);
+                }
+
+                // If we are hovering over a valid object or are currently selecting one, lerp the color based on selectedness
+                if (rayHasHit || rayInteractor.hasSelection)
+                {
+                    if (variableSelectInteractor != null)
+                    {
+                        cachedGradient = ColorUtilities.GradientLerp(ValidColorGradient, SelectActiveColorGradient, variableSelectInteractor.SelectProgress);
+                    }
+                    else
+                    {
+                        cachedGradient = ColorUtilities.GradientLerp(ValidColorGradient, SelectActiveColorGradient, rayInteractor.hasSelection ? 1 : 0);
+                    }
+
+                    // apply the compression effect
+                    var compressionAmount = Mathf.Clamp(rayInteractor.maxRaycastDistance * MaxGradientLength / hitDistance, 0.0f, 1.0f);
+                    cachedGradient = ColorUtilities.GradientCompress(cachedGradient, 0.0f, compressionAmount);
+                }
+                else
+                {
+                    cachedGradient = NoTargetColorGradient;
+                }
+
+                lineRenderer.colorGradient = cachedGradient;
             }
         }
 

com.microsoft.mrtk.input/Simulation/InputSimulator.cs

@@ -310,6 +310,9 @@ public ControllerSimulationSettings RightControllerSettings
         // TODO: Drive from inspector/simulator options.
         private float triggerSmoothTime = 0.1f;
 
+        // TODO: Drive from inspector/simulator options.
+        private float triggerSmoothDeadzone = 0.005f;
+
         /// <summary>
         /// Enables the simulated controller.
         /// </summary>
@@ -500,11 +503,17 @@ private void UpdateSimulatedController(Handedness handedness)
                 // TODO: Currently triggerAxis is driven only from ctrlSettings.TriggerButton.action.
                 // We will eventually drive this from the ctrlSettings.TriggerAxis.action as well.
                 // Needs work to be able to intuitively combine trigger axis from sim input with click.
+                float targetValue = ctrlSettings.TriggerButton.action.IsPressed() ? 1 : 0;
+
                 controls.TriggerAxis = Mathf.SmoothDamp(controls.TriggerAxis,
-                                                        ctrlSettings.TriggerButton.action.IsPressed() ? 1 : 0,
+                                                        targetValue,
                                                         ref triggerSmoothVelocity,
                                                         triggerSmoothTime);
 
+                if(Mathf.Abs(controls.TriggerAxis - targetValue) < triggerSmoothDeadzone)
+                {
+                    controls.TriggerAxis = targetValue;
+                }
 #if LATER
 // TODO: mappings need to be sorted out for these
                 // Axes available to hands and controllers