Add generic easing pathway for ValueAt

osu.Framework/Utils/Interpolation.cs

···
             return numerator / denominator;
         }
 
+        #region ValueAt
+
         public static ColourInfo ValueAt(double time, ColourInfo startColour, ColourInfo endColour, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, startColour, endColour, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static EdgeEffectParameters ValueAt(double time, EdgeEffectParameters startParams, EdgeEffectParameters endParams, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, startParams, endParams, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static SRGBColour ValueAt(double time, SRGBColour startColour, SRGBColour endColour, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, startColour, endColour, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static Color4 ValueAt(double time, Color4 startColour, Color4 endColour, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, startColour, endColour, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static byte ValueAt(double time, byte val1, byte val2, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, val1, val2, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static sbyte ValueAt(double time, sbyte val1, sbyte val2, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, val1, val2, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static short ValueAt(double time, short val1, short val2, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, val1, val2, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static ushort ValueAt(double time, ushort val1, ushort val2, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, val1, val2, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static int ValueAt(double time, int val1, int val2, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, val1, val2, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static uint ValueAt(double time, uint val1, uint val2, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, val1, val2, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static long ValueAt(double time, long val1, long val2, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, val1, val2, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static ulong ValueAt(double time, ulong val1, ulong val2, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, val1, val2, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static float ValueAt(double time, float val1, float val2, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, val1, val2, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static decimal ValueAt(double time, decimal val1, decimal val2, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, val1, val2, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static double ValueAt(double time, double val1, double val2, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, val1, val2, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static Vector2 ValueAt(double time, Vector2 val1, Vector2 val2, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, val1, val2, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static RectangleF ValueAt(double time, RectangleF val1, RectangleF val2, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, val1, val2, startTime, endTime, new DefaultEasingFunction(easing));
+
+        public static TValue ValueAt<TValue>(double time, TValue startValue, TValue endValue, double startTime, double endTime, Easing easing = Easing.None)
+            => ValueAt(time, startValue, endValue, startTime, endTime, new DefaultEasingFunction(easing));
+
+        #endregion
+
+        #region ValueAt<TEasing>
+
+        public static ColourInfo ValueAt<TEasing>(double time, ColourInfo startColour, ColourInfo endColour, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
         {
             if (startColour.HasSingleColour && endColour.HasSingleColour)
                 return ValueAt(time, (Color4)startColour, (Color4)endColour, startTime, endTime, easing);
···
             };
         }
 
-        public static EdgeEffectParameters ValueAt(double time, EdgeEffectParameters startParams, EdgeEffectParameters endParams, double startTime, double endTime, Easing easing = Easing.None) =>
-            new EdgeEffectParameters
+        public static EdgeEffectParameters ValueAt<TEasing>(double time, EdgeEffectParameters startParams, EdgeEffectParameters endParams, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
+            => new EdgeEffectParameters
             {
                 Type = startParams.Type,
                 Hollow = startParams.Hollow,
···
                 Roundness = ValueAt(time, startParams.Roundness, endParams.Roundness, startTime, endTime, easing),
             };
 
-        public static SRGBColour ValueAt(double time, SRGBColour startColour, SRGBColour endColour, double startTime, double endTime, Easing easing = Easing.None) =>
-            ValueAt(time, (Color4)startColour, (Color4)endColour, startTime, endTime, easing);
+        public static SRGBColour ValueAt<TEasing>(double time, SRGBColour startColour, SRGBColour endColour, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
+            => ValueAt(time, (Color4)startColour, (Color4)endColour, startTime, endTime, easing);
 
-        public static Color4 ValueAt(double time, Color4 startColour, Color4 endColour, double startTime, double endTime, Easing easing = Easing.None)
+        public static Color4 ValueAt<TEasing>(double time, Color4 startColour, Color4 endColour, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
         {
             if (startColour == endColour)
                 return startColour;
···
                 startColour.A + t * (endColour.A - startColour.A));
         }
 
-        public static byte ValueAt(double time, byte val1, byte val2, double startTime, double endTime, Easing easing = Easing.None) =>
-            (byte)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
+        public static byte ValueAt<TEasing>(double time, byte val1, byte val2, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
+            => (byte)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
 
-        public static sbyte ValueAt(double time, sbyte val1, sbyte val2, double startTime, double endTime, Easing easing = Easing.None) =>
-            (sbyte)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
+        public static sbyte ValueAt<TEasing>(double time, sbyte val1, sbyte val2, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
+            => (sbyte)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
 
-        public static short ValueAt(double time, short val1, short val2, double startTime, double endTime, Easing easing = Easing.None) =>
-            (short)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
+        public static short ValueAt<TEasing>(double time, short val1, short val2, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
+            => (short)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
 
-        public static ushort ValueAt(double time, ushort val1, ushort val2, double startTime, double endTime, Easing easing = Easing.None) =>
-            (ushort)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
+        public static ushort ValueAt<TEasing>(double time, ushort val1, ushort val2, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
+            => (ushort)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
 
-        public static int ValueAt(double time, int val1, int val2, double startTime, double endTime, Easing easing = Easing.None) =>
-            (int)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
+        public static int ValueAt<TEasing>(double time, int val1, int val2, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
+            => (int)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
 
-        public static uint ValueAt(double time, uint val1, uint val2, double startTime, double endTime, Easing easing = Easing.None) =>
-            (uint)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
+        public static uint ValueAt<TEasing>(double time, uint val1, uint val2, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
+            => (uint)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
 
-        public static long ValueAt(double time, long val1, long val2, double startTime, double endTime, Easing easing = Easing.None) =>
-            (long)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
+        public static long ValueAt<TEasing>(double time, long val1, long val2, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
+            => (long)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
 
-        public static ulong ValueAt(double time, ulong val1, ulong val2, double startTime, double endTime, Easing easing = Easing.None) =>
-            (ulong)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
+        public static ulong ValueAt<TEasing>(double time, ulong val1, ulong val2, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
+            => (ulong)Math.Round(ValueAt(time, (double)val1, val2, startTime, endTime, easing));
 
-        public static float ValueAt(double time, float val1, float val2, double startTime, double endTime, Easing easing = Easing.None) =>
-            (float)ValueAt(time, (double)val1, val2, startTime, endTime, easing);
+        public static float ValueAt<TEasing>(double time, float val1, float val2, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
+            => (float)ValueAt(time, (double)val1, val2, startTime, endTime, easing);
 
-        public static decimal ValueAt(double time, decimal val1, decimal val2, double startTime, double endTime, Easing easing = Easing.None) =>
-            (decimal)ValueAt(time, (double)val1, (double)val2, startTime, endTime, easing);
+        public static decimal ValueAt<TEasing>(double time, decimal val1, decimal val2, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
+            => (decimal)ValueAt(time, (double)val1, (double)val2, startTime, endTime, easing);
 
-        public static double ValueAt(double time, double val1, double val2, double startTime, double endTime, Easing easing = Easing.None)
+        public static double ValueAt<TEasing>(double time, double val1, double val2, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
         {
             if (val1 == val2)
                 return val1;
···
             return val1 + t * (val2 - val1);
         }
 
-        public static Vector2 ValueAt(double time, Vector2 val1, Vector2 val2, double startTime, double endTime, Easing easing = Easing.None)
+        public static Vector2 ValueAt<TEasing>(double time, Vector2 val1, Vector2 val2, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
         {
             float current = (float)(time - startTime);
             float duration = (float)(endTime - startTime);
···
             return val1 + t * (val2 - val1);
         }
 
-        public static RectangleF ValueAt(double time, RectangleF val1, RectangleF val2, double startTime, double endTime, Easing easing = Easing.None)
+        public static RectangleF ValueAt<TEasing>(double time, RectangleF val1, RectangleF val2, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
         {
             float current = (float)(time - startTime);
             float duration = (float)(endTime - startTime);
···
                 val1.Height + t * (val2.X - val1.Height));
         }
 
-        public static TValue ValueAt<TValue>(double time, TValue startValue, TValue endValue, double startTime, double endTime, Easing easing = Easing.None)
+        public static TValue ValueAt<TValue, TEasing>(double time, TValue startValue, TValue endValue, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
             => GenericInterpolation<TValue>.FUNCTION(time, startValue, endValue, startTime, endTime, easing);
+
+        #endregion
 
         public static double ApplyEasing(Easing easing, double time)
-            => new DefaultEasingFunction(easing).ApplyEasing(time);
+            => ApplyEasing(new DefaultEasingFunction(easing), time);
+
+        public static double ApplyEasing<TEasing>(TEasing easing, double time)
+            where TEasing : IEasingFunction
+            => easing.ApplyEasing(time);
 
         private static class GenericInterpolation<TValue>
         {