Add generic easing to transforms

osu.Framework/Graphics/MarginPadding.cs

···
 
 using osuTK;
 using System;
+using osu.Framework.Graphics.Transforms;
 using osu.Framework.Utils;
 
 namespace osu.Framework.Graphics
···
                 Bottom = -mp.Bottom,
             };
 
-        public MarginPadding ValueAt(double time, MarginPadding startValue, MarginPadding endValue, double startTime, double endTime, Easing easingType)
+        public MarginPadding ValueAt<TEasing>(double time, MarginPadding startValue, MarginPadding endValue, double startTime, double endTime, in TEasing easing)
+            where TEasing : IEasingFunction
             => new MarginPadding
             {
-                Left = Interpolation.ValueAt(time, startValue.Left, endValue.Left, startTime, endTime, easingType),
-                Top = Interpolation.ValueAt(time, startValue.Top, endValue.Top, startTime, endTime, easingType),
-                Right = Interpolation.ValueAt(time, startValue.Right, endValue.Right, startTime, endTime, easingType),
-                Bottom = Interpolation.ValueAt(time, startValue.Bottom, endValue.Bottom, startTime, endTime, easingType),
+                Left = Interpolation.ValueAt(time, startValue.Left, endValue.Left, startTime, endTime, easing),
+                Top = Interpolation.ValueAt(time, startValue.Top, endValue.Top, startTime, endTime, easing),
+                Right = Interpolation.ValueAt(time, startValue.Right, endValue.Right, startTime, endTime, easing),
+                Bottom = Interpolation.ValueAt(time, startValue.Bottom, endValue.Bottom, startTime, endTime, easing),
             };
     }
 }

osu.Framework/Graphics/TransformableExtensions.cs

···
         /// <param name="easing">The transform easing to be used for tweening.</param>
         /// <returns>A <see cref="TransformSequence{T}"/> to which further transforms can be added.</returns>
         public static TransformSequence<TThis> TransformTo<TThis, TValue>(this TThis t, string propertyOrFieldName, TValue newValue, double duration = 0, Easing easing = Easing.None)
-            where TThis : class, ITransformable =>
-            t.TransformTo(t.MakeTransform(propertyOrFieldName, newValue, duration, easing));
+            where TThis : class, ITransformable
+            => t.TransformTo(t.MakeTransform(propertyOrFieldName, newValue, duration, new DefaultEasingFunction(easing)));
+
+        /// <summary>
+        /// Transforms a given property or field member of a given <see cref="ITransformable"/> <typeparamref name="TThis"/> to <paramref name="newValue"/>.
+        /// The value of the given member is smoothly changed over time using the given <paramref name="easing"/> for tweening.
+        /// </summary>
+        /// <typeparam name="TThis">The type of the <see cref="ITransformable"/> to apply the <see cref="Transform{TValue, T}"/> to.</typeparam>
+        /// <typeparam name="TValue">The value type which is being transformed.</typeparam>
+        /// <typeparam name="TEasing">The type of easing.</typeparam>
+        /// <param name="t">The <see cref="ITransformable"/> to apply the <see cref="Transform{TValue, T}"/> to.</param>
+        /// <param name="propertyOrFieldName">The property or field name of the member ot <typeparamref name="TThis"/> to transform.</param>
+        /// <param name="newValue">The value to transform to.</param>
+        /// <param name="duration">The transform duration.</param>
+        /// <param name="easing">The transform easing to be used for tweening.</param>
+        /// <returns>A <see cref="TransformSequence{T}"/> to which further transforms can be added.</returns>
+        public static TransformSequence<TThis> TransformTo<TThis, TValue, TEasing>(this TThis t, string propertyOrFieldName, TValue newValue, double duration, TEasing easing)
+            where TThis : class, ITransformable
+            where TEasing : IEasingFunction
+            => t.TransformTo(t.MakeTransform(propertyOrFieldName, newValue, duration, easing));
 
         /// <summary>
         /// Applies a <see cref="Transform"/> to a given <see cref="ITransformable"/>.
···
         /// <summary>
         /// Creates a <see cref="Transform{TValue, T}"/> for smoothly changing <paramref name="propertyOrFieldName"/>
         /// over time using the given <paramref name="easing"/> for tweening.
-        /// <see cref="PopulateTransform{TValue, TThis}(TThis, Transform{TValue, TThis}, TValue, double, Easing)"/>
-        /// is invoked as part of this method.
+        /// <see cref="PopulateTransform{TValue, DefaultEasingFunction, TThis}"/> is invoked as part of this method.
+        /// </summary>
+        /// <typeparam name="TThis">The type of the <see cref="ITransformable"/> the <see cref="Transform{TValue, T}"/> can be applied to.</typeparam>
+        /// <typeparam name="TValue">The value type which is being transformed.</typeparam>
+        /// <param name="t">The <see cref="ITransformable"/> the <see cref="Transform{TValue, T}"/> will be applied to.</param>
+        /// <param name="propertyOrFieldName">The property or field name of the member ot <typeparamref name="TThis"/> to transform.</param>
+        /// <param name="newValue">The value to transform to.</param>
+        /// <param name="duration">The transform duration.</param>
+        /// <param name="easing">The transform easing to be used for tweening.</param>
+        /// <returns>The resulting <see cref="Transform{TValue, T}"/>.</returns>
+        public static Transform<TValue, DefaultEasingFunction, TThis> MakeTransform<TThis, TValue>(this TThis t, string propertyOrFieldName, TValue newValue, double duration = 0,
+                                                                                                   Easing easing = Easing.None)
+            where TThis : class, ITransformable
+            => t.MakeTransform(propertyOrFieldName, newValue, duration, new DefaultEasingFunction(easing));
+
+        /// <summary>
+        /// Creates a <see cref="Transform{TValue, T}"/> for smoothly changing <paramref name="propertyOrFieldName"/>
+        /// over time using the given <paramref name="easing"/> for tweening.
+        /// <see cref="PopulateTransform{TValue, TEasing, TThis}"/> is invoked as part of this method.
         /// </summary>
         /// <typeparam name="TThis">The type of the <see cref="ITransformable"/> the <see cref="Transform{TValue, T}"/> can be applied to.</typeparam>
         /// <typeparam name="TValue">The value type which is being transformed.</typeparam>
+        /// <typeparam name="TEasing">The type of easing.</typeparam>
         /// <param name="t">The <see cref="ITransformable"/> the <see cref="Transform{TValue, T}"/> will be applied to.</param>
         /// <param name="propertyOrFieldName">The property or field name of the member ot <typeparamref name="TThis"/> to transform.</param>
         /// <param name="newValue">The value to transform to.</param>
         /// <param name="duration">The transform duration.</param>
         /// <param name="easing">The transform easing to be used for tweening.</param>
         /// <returns>The resulting <see cref="Transform{TValue, T}"/>.</returns>
-        public static Transform<TValue, TThis> MakeTransform<TThis, TValue>(this TThis t, string propertyOrFieldName, TValue newValue, double duration = 0, Easing easing = Easing.None)
-            where TThis : class, ITransformable =>
-            t.PopulateTransform(new TransformCustom<TValue, TThis>(propertyOrFieldName), newValue, duration, easing);
+        public static Transform<TValue, TEasing, TThis> MakeTransform<TThis, TEasing, TValue>(this TThis t, string propertyOrFieldName, TValue newValue, double duration, TEasing easing)
+            where TThis : class, ITransformable
+            where TEasing : IEasingFunction
+            => t.PopulateTransform(new TransformCustom<TValue, TEasing, TThis>(propertyOrFieldName), newValue, duration, easing);
 
         /// <summary>
         /// Populates a newly created <see cref="Transform{TValue, T}"/> with necessary values.
···
         /// <param name="duration">The transform duration.</param>
         /// <param name="easing">The transform easing to be used for tweening.</param>
         /// <returns>The populated <paramref name="transform"/>.</returns>
-        public static Transform<TValue, TThis> PopulateTransform<TValue, TThis>(this TThis t, Transform<TValue, TThis> transform, TValue newValue, double duration = 0, Easing easing = Easing.None)
+        public static Transform<TValue, DefaultEasingFunction, TThis> PopulateTransform<TValue, TThis>(this TThis t, Transform<TValue, DefaultEasingFunction, TThis> transform, TValue newValue,
+                                                                                                       double duration = 0, Easing easing = Easing.None)
             where TThis : class, ITransformable
+            => t.PopulateTransform(transform, newValue, duration, new DefaultEasingFunction(easing));
+
+        /// <summary>
+        /// Populates a newly created <see cref="Transform{TValue, T}"/> with necessary values.
+        /// All <see cref="Transform{TValue, T}"/>s must be populated by this method prior to being used.
+        /// </summary>
+        /// <typeparam name="TThis">The type of the <see cref="ITransformable"/> the <see cref="Transform{TValue, T}"/> can be applied to.</typeparam>
+        /// <typeparam name="TValue">The value type which is being transformed.</typeparam>
+        /// <typeparam name="TEasing">The type of easing.</typeparam>
+        /// <param name="t">The <see cref="ITransformable"/> the <see cref="Transform{TValue, T}"/> will be applied to.</param>
+        /// <param name="transform">The transform to populate.</param>
+        /// <param name="newValue">The value to transform to.</param>
+        /// <param name="duration">The transform duration.</param>
+        /// <param name="easing">The transform easing to be used for tweening.</param>
+        /// <returns>The populated <paramref name="transform"/>.</returns>
+        public static Transform<TValue, TEasing, TThis> PopulateTransform<TValue, TEasing, TThis>(this TThis t, Transform<TValue, TEasing, TThis> transform, TValue newValue, double duration,
+                                                                                                  TEasing easing)
+            where TThis : class, ITransformable
+            where TEasing : IEasingFunction
         {
             if (duration < 0)
                 throw new ArgumentOutOfRangeException(nameof(duration), $"{nameof(duration)} must be positive.");
···
         /// <returns>A <see cref="TransformSequence{T}"/> to which further transforms can be added.</returns>
         public static TransformSequence<T> TransformBindableTo<T, TValue>(this T drawable, [NotNull] Bindable<TValue> bindable, TValue newValue, double duration = 0, Easing easing = Easing.None)
             where T : class, ITransformable =>
-            drawable.TransformTo(drawable.PopulateTransform(new TransformBindable<TValue, T>(bindable), newValue, duration, easing));
+            drawable.TransformTo(drawable.PopulateTransform(new TransformBindable<TValue, DefaultEasingFunction, T>(bindable), newValue, duration, new DefaultEasingFunction(easing)));
     }
 }

osu.Framework/Graphics/Transforms/Transform.cs

···
         /// </summary>
         public bool Rewindable = true;
 
-        public Easing Easing;
-
         public abstract ITransformable TargetTransformable { get; }
 
         public double StartTime { get; internal set; }
···
         public TValue EndValue { get; protected internal set; }
     }
 
-    public abstract class Transform<TValue, T> : Transform<TValue>
+    public abstract class Transform<TValue, TEasing, T> : Transform<TValue>
+        where TEasing : IEasingFunction
         where T : class, ITransformable
     {
         public override ITransformable TargetTransformable => Target;
 
         public T Target { get; internal set; }
+
+        public TEasing Easing { get; internal set; }
 
         public sealed override void Apply(double time)
         {
···
         protected abstract void ReadIntoStartValue(T d);
 
         public override string ToString() => $"{Target.GetType().Name}.{TargetMember} {StartTime}-{EndTime}ms {StartValue} -> {EndValue}";
+    }
+
+    public abstract class Transform<TValue, T> : Transform<TValue, DefaultEasingFunction, T>
+        where T : class, ITransformable
+    {
     }
 }

osu.Framework/Graphics/Transforms/TransformBindable.cs

···
 
 namespace osu.Framework.Graphics.Transforms
 {
-    internal class TransformBindable<TValue, T> : Transform<TValue, T>
+    internal class TransformBindable<TValue, TEasing, T> : Transform<TValue, TEasing, T>
         where T : class, ITransformable
+        where TEasing : IEasingFunction
     {
         public override string TargetMember { get; }
 
         private readonly Bindable<TValue> targetBindable;
-        private readonly InterpolationFunc<TValue> interpolationFunc;
+        private readonly InterpolationFunc<TValue, TEasing> interpolationFunc;
 
         public TransformBindable(Bindable<TValue> targetBindable)
         {

osu.Framework/Graphics/Transforms/TransformCustom.cs

···
     /// A transform which operates on arbitrary fields or properties of a given target.
     /// </summary>
     /// <typeparam name="TValue">The type of the field or property to operate upon.</typeparam>
+    /// <typeparam name="TEasing">The type of easing.</typeparam>
     /// <typeparam name="T">The type of the target to operate upon.</typeparam>
-    internal class TransformCustom<TValue, T> : Transform<TValue, T> where T : class, ITransformable
+    internal class TransformCustom<TValue, TEasing, T> : Transform<TValue, TEasing, T>
+        where T : class, ITransformable
+        where TEasing : IEasingFunction
     {
         private delegate TValue ReadFunc(T transformable);
 
···
         private static Accessor getAccessor(string propertyOrFieldName) => accessors.GetOrAdd(propertyOrFieldName, key => findAccessor(typeof(T), key));
 
         private readonly Accessor accessor;
-        private readonly InterpolationFunc<TValue> interpolationFunc;
+        private readonly InterpolationFunc<TValue, TEasing> interpolationFunc;
 
         /// <summary>
         /// Creates a new instance operating on a property or field of <typeparamref name="T"/>. The property or field is
···
         protected override void Apply(T d, double time) => accessor.Write(d, valueAt(time));
 
         protected override void ReadIntoStartValue(T d) => StartValue = accessor.Read(d);
+    }
+
+    internal class TransformCustom<TValue, T> : TransformCustom<TValue, DefaultEasingFunction, T>
+        where T : class, ITransformable
+    {
+        public TransformCustom(string propertyOrFieldName)
+            : base(propertyOrFieldName)
+        {
+        }
     }
 }

osu.Framework/Graphics/Transforms/Transformable.cs

···
 
         /// <summary>
         /// Adds to this object a <see cref="Transform"/> which was previously populated using this object via
-        /// <see cref="TransformableExtensions.PopulateTransform{TValue, TThis}(TThis, Transform{TValue, TThis}, TValue, double, Easing)"/>.
+        /// <see cref="TransformableExtensions.PopulateTransform{TValue, TEasing, TThis}"/>.
         /// Added <see cref="Transform"/>s are immediately applied, and therefore have an immediate effect on this object if the current time of this
         /// object falls within <see cref="Transform.StartTime"/> and <see cref="Transform.EndTime"/>.
         /// If <see cref="Clock"/> is null, e.g. because this object has just been constructed, then the given transform will be finished instantaneously.

osu.Framework/Utils/IInterpolable.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Graphics;
+using osu.Framework.Graphics.Transforms;
 
 namespace osu.Framework.Utils
 {
···
         /// <param name="endValue">The <typeparamref name="TValue"/> at <paramref name="time"/> = <paramref name="endTime"/>.</param>
         /// <param name="startTime">The start time.</param>
         /// <param name="endTime">The end time.</param>
-        /// <param name="easingType">The easing to use.</param>
+        /// <param name="easing">The easing function to use.</param>
         /// <returns>The interpolated value.</returns>
-        TValue ValueAt(double time, TValue startValue, TValue endValue, double startTime, double endTime, Easing easingType = Easing.None);
+        TValue ValueAt<TEasing>(double time, TValue startValue, TValue endValue, double startTime, double endTime, in TEasing easing) where TEasing : IEasingFunction;
     }
 }

osu.Framework/Utils/Interpolation.cs

···
 
         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);
+            => GenericInterpolation<TValue, TEasing>.FUNCTION(time, startValue, endValue, startTime, endTime, easing);
 
         #endregion
 
···
             where TEasing : IEasingFunction
             => easing.ApplyEasing(time);
 
-        private static class GenericInterpolation<TValue>
+        private static class GenericInterpolation<TValue, TEasing>
+            where TEasing : IEasingFunction
         {
-            public static readonly InterpolationFunc<TValue> FUNCTION;
+            public static readonly InterpolationFunc<TValue, TEasing> FUNCTION;
 
             static GenericInterpolation()
             {
                 const string interpolation_method = nameof(Interpolation.ValueAt);
 
-                var parameters = typeof(InterpolationFunc<TValue>)
-                                 .GetMethod(nameof(InterpolationFunc<TValue>.Invoke))
+                var parameters = typeof(InterpolationFunc<TValue, TEasing>)
+                                 .GetMethod(nameof(InterpolationFunc<TValue, TEasing>.Invoke))
                                  ?.GetParameters().Select(p => p.ParameterType).ToArray();
 
                 MethodInfo valueAtMethod = typeof(Interpolation).GetMethod(interpolation_method, parameters);
 
                 if (valueAtMethod != null)
-                    FUNCTION = (InterpolationFunc<TValue>)valueAtMethod.CreateDelegate(typeof(InterpolationFunc<TValue>));
+                    FUNCTION = (InterpolationFunc<TValue, TEasing>)valueAtMethod.CreateDelegate(typeof(InterpolationFunc<TValue, TEasing>));
                 else
                 {
                     var typeRef = FormatterServices.GetSafeUninitializedObject(typeof(TValue)) as IInterpolable<TValue>;
···
         }
     }
 
-    public delegate TValue InterpolationFunc<TValue>(double time, TValue startValue, TValue endValue, double startTime, double endTime, Easing easingType);
+    public delegate TValue InterpolationFunc<TValue, TEasing>(double time, TValue startValue, TValue endValue, double startTime, double endTime, in TEasing easingType) where TEasing : IEasingFunction;
 }