Basic Tweening library compatible with DefaultEcs

[bootzin]

Hi all

Just wanted to share something I've been working on.
I managed to create a dynamic Tweening library that works nicely along DefaultEcs. It uses quite a bit of reflection, so maybe not the best for performance, but the usability is very simple and it works with any value-property from Components. I'm also somewhat confident it doesn't do any copies nor any boxing, but I might be wrong in that regard since I'm somewhat new to the scene. Please let me know if you have any critics or suggestions!

Usage was one of my main concerns, so I tried to make it as simple and as versatile as possible. Here is how you would create a tween for a TransformComponent to update both its Position and Scale:

var entity = World.CreateEntity();
entity.Set<TransformComponent>();
var tweener = new Tweener();
tweener.AddTween(entity, (TransformComponent t) => t.Scale, Vector2.One * 2, 2, EasingFunctions.Linear); // EasingFunctions is a support class I use, but this can be as simple as "x => x"
tweener.AddTween(entity, (TransformComponent t) => t.Position, Vector2.One, 1, EasingFunctions.ExponentialIn);

And this in your update loop:

tweener.Update(deltaTime);

The code to make that possible is a bit more complicated, but this is the Tween class itself:

public class Tween<T>(T startValue, T endValue, float duration, LerpFunc<T> lerpFunction, EasingFunc easingFunc, Action<T> updateAction) : TweenBase
{
    private readonly LerpFunc<T> _lerpFunction = lerpFunction;
    private readonly EasingFunc _easingFunc = easingFunc;
    private readonly Action<T> _updateAction = updateAction;
    private readonly T _startValue = startValue;
    private readonly T _endValue = endValue;
    private readonly float _duration = duration;
    
    private float _elapsedTime;

    public override void Update(float deltaTime)
    {
        if (IsCompleted || IsPaused)
            return;

        _elapsedTime += deltaTime;
        _updateAction(_lerpFunction(_startValue, _endValue, _easingFunc(Math.Clamp(_elapsedTime / _duration, 0, 1))));

        if (_elapsedTime >= _duration)
        {
            IsCompleted = true;
        }
    }

    public override void ForceComplete()
    {
        if (IsCompleted) return;

        _elapsedTime = _duration;
        _updateAction(_lerpFunction(_startValue, _endValue, _easingFunc(1)));
        IsCompleted = true;
    }
}

public abstract class TweenBase
{
    public bool IsCompleted { get; protected set; }
    public bool IsPaused { get; protected set; }

    public abstract void Update(float deltaTime);
    public abstract void ForceComplete();

    public void Pause()
    {
        IsPaused = true;
    }

    public void Resume()
    {
        IsPaused = false;
    }
}

And here is a Tweener to manage those Tweens:

public class Tweener
{
    private readonly List<TweenBase> _activeTweens = [];

    // Creates a Tween and adds it to the list of managed Tweens
    public Tween<TProperty> AddTween<TStruct, TProperty>(Entity entity, Expression<Func<TStruct, TProperty>> propertySelector, TProperty endValue, float duration, EasingFunc easingFunc = null, LerpFunc<TProperty> lerpFunction = null)
        where TStruct : struct
    {
        var tween = CreateTween(entity, propertySelector, endValue, duration, easingFunc, lerpFunction);
        _activeTweens.Add(tween);
        return tween;
    }

    public void Update(float deltaTime)
    {
        for (int i = 0; i < _activeTweens.Count; i++)
        {
            var tween = _activeTweens[i];
            tween.Update(deltaTime);

            if (tween.IsCompleted)
            {
                _activeTweens.RemoveAt(i);
            }
        }
    }

    public bool IsCompleted => _activeTweens.Count == 0;

    public void PauseAll() => _activeTweens.ForEach(x => x.Pause());
    public void ResumeAll() => _activeTweens.ForEach(x => x.Resume());

    public void ForceCompleteAll()
    {
        foreach (var tween in _activeTweens)
        {
            tween.ForceComplete();
        }

        _activeTweens.Clear();
    }

    public TweenBase FindTween(Predicate<TweenBase> predicate) => _activeTweens.Find(predicate);

    public Tween<T> FindTween<T>(Predicate<Tween<T>> predicate) => _activeTweens.OfType<Tween<T>>().FirstOrDefault(t => predicate(t));

    // Creates an unmanaged Tween
    public static Tween<TProperty> CreateTween<TStruct, TProperty>(Entity entity, Expression<Func<TStruct, TProperty>> propertySelector, TProperty endValue, float duration, EasingFunc easingFunc, LerpFunc<TProperty> lerpFunction = null)
        where TStruct : struct
    {
        // Compile the getter
        var getter = propertySelector.Compile();

        // Generate the setter delegate
        var setter = CreateRefSetter(propertySelector);

        // Return the tween
        return CreateTweenInternal(() => ref entity.Get<TStruct>(), getter, setter, endValue, duration, easingFunc, GetDefaultLerpFunc(lerpFunction));
    }

    private static RefSetter<TStruct, TProperty> CreateRefSetter<TStruct, TProperty>(Expression<Func<TStruct, TProperty>> propertySelector)
        where TStruct : struct
    {
        if (propertySelector.Body is not MemberExpression member)
            throw new ArgumentException("Selector must target a property or field", nameof(propertySelector));

        // Create parameters for the setter
        var structParam = Expression.Parameter(typeof(TStruct).MakeByRefType(), "component");
        var valueParam = Expression.Parameter(typeof(TProperty), "value");

        // Create an assignment expression
        var assignment = Expression.Assign(Expression.MakeMemberAccess(structParam, member.Member), valueParam);

        // Compile into a delegate
        return Expression.Lambda<RefSetter<TStruct, TProperty>>(assignment, structParam, valueParam).Compile();
    }

    private static Tween<TProperty> CreateTweenInternal<TStruct, TProperty>(RefGetter<TStruct> componentGetter, Func<TStruct, TProperty> getProperty, RefSetter<TStruct, TProperty> setProperty, TProperty endValue, float duration, EasingFunc easingFunc, LerpFunc<TProperty> lerpFunction)
        where TStruct : struct
    {
        var startValue = getProperty(componentGetter());

        return new Tween<TProperty>(startValue, endValue, duration, lerpFunction, easingFunc, value => 
        {
            ref var component = ref componentGetter();
            setProperty(ref component, value);
        });
    }

    private static readonly ConcurrentDictionary<Type, Delegate> LerpFuncCache = [];

    private static LerpFunc<T> GetDefaultLerpFunc<T>(LerpFunc<T> lerpFunction)
    {
        if (LerpFuncCache.TryGetValue(typeof(T), out var cachedFunc))
        {
            return (LerpFunc<T>)cachedFunc;
        }

        if (lerpFunction != null)
        {
            // Automatically register the passed lerp function if not already registered
            LerpFuncCache.TryAdd(typeof(T), lerpFunction);
            return lerpFunction;
        }

        LerpFunc<T> func = typeof(T) switch
        {
            Type t when t == typeof(float) => (LerpFunc<T>)(object)new LerpFunc<float>(float.Lerp),
            Type t when t == typeof(Vector2) => (LerpFunc<T>)(object)new LerpFunc<Vector2>(Vector2.Lerp),
            Type t when t == typeof(Vector3) => (LerpFunc<T>)(object)new LerpFunc<Vector3>(Vector3.Lerp),
            Type t when t == typeof(Quaternion) => (LerpFunc<T>)(object)new LerpFunc<Quaternion>(Quaternion.Lerp),
            _ => throw new NotSupportedException($"No default lerp function is defined for type {typeof(T).Name}.")
        };

        LerpFuncCache[typeof(T)] = func;
        return func;
    }
}

// Custom delegate types to handle ref
public delegate ref TStruct RefGetter<TStruct>() where TStruct : struct;
public delegate void RefSetter<TStruct, TProperty>(ref TStruct component, TProperty value);

// Custom delegate types to handle Easing and Lerp functions
public delegate float EasingFunc(float progress);
public delegate T LerpFunc<T>(T start, T end, float progress);

Let me know your thoughts and if you have any changes/improvements to suggest!