Fixed curve caching in volume; optimized curve CPU usage a bit

Author: Chman

PostProcessing/Runtime/ParameterOverride.cs

@@ -186,16 +186,23 @@ protected internal override void OnEnable()
                 value.Cache(int.MinValue);
         }
 
-        public override void Interp(Spline from, Spline to, float t)
+        internal override void SetValue(ParameterOverride parameter)
         {
-            int frameCount = Time.renderedFrameCount;
+            base.SetValue(parameter);
+
+            if (value != null)
+                value.Cache(Time.renderedFrameCount);
+        }
 
+        public override void Interp(Spline from, Spline to, float t)
+        {
             if (from == null || to == null)
             {
                 base.Interp(from, to, t);
                 return;
             }
-
+            
+            int frameCount = Time.renderedFrameCount;
             from.Cache(frameCount);
             to.Cache(frameCount);
 

PostProcessing/Runtime/Utils/Spline.cs

@@ -40,6 +40,8 @@ public Spline(AnimationCurve curve, float zeroValue, bool loop, Vector2 bounds)
             cachedData = new float[k_Precision];
         }
 
+        // Note: it would be nice to have a way to check if a curve has changed in any way, that
+        // would save quite a few CPU cycles instead of having to force cache it once per frame :/
         public void Cache(int frame)
         {
             // Only cache once per frame
@@ -63,22 +65,30 @@ public void Cache(int frame)
             }
 
             for (int i = 0; i < k_Precision; i++)
-                cachedData[i] = Evaluate((float)i * k_Step);
+                cachedData[i] = Evaluate((float)i * k_Step, length);
 
             frameCount = Time.renderedFrameCount;
         }
 
-        public float Evaluate(float t)
+        public float Evaluate(float t, int length)
         {
-            if (curve.length == 0)
+            if (length == 0)
                 return m_ZeroValue;
 
-            if (!m_Loop || curve.length == 1)
+            if (!m_Loop || length == 1)
                 return curve.Evaluate(t);
 
             return m_InternalLoopingCurve.Evaluate(t);
         }
 
+        public float Evaluate(float t)
+        {
+            // Calling the length getter on a curve is expensive (!?) so it's better to cache its
+            // length and call Evaluate(t, length) instead of getting the length for every call to
+            // Evaluate(t)
+            return Evaluate(t, curve.length);
+        }
+
         public override int GetHashCode()
         {
             unchecked