Add Spring Animation Support

.gitignore

@@ -1,4 +1,4 @@
 *.DS_Store
 
 # Project for Asset Store
-src/LitMotion.AssetStore/*
+src/LitMotion.AssetStore/*

samples/LitMotion.Samples/Assets/Samples/0. Basic/7. Coroutine/Sample_0_Coroutine.cs

@@ -16,8 +16,7 @@ IEnumerator Start()
                 var direction = i % 2 == 0 ? 1 : -1;
                 yield return LMotion.Create(-5f * direction, 5f * direction, 2f)
                     .WithEase(Ease.InOutSine)
-                    .BindToPositionX(targets[i])
-                    .ToYieldInteraction();
+                    .BindToPositionX(targets[i]);
             }
         }
     }

src/LitMotion/Assets/LitMotion/Runtime/Adapters/SpringMotionAdapters.cs

@@ -0,0 +1,126 @@
+using Unity.Jobs;
+using UnityEngine;
+using Unity.Mathematics;
+using LitMotion;
+using LitMotion.Adapters;
+
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<float, SpringOptions, FloatSpringMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<Vector2, SpringOptions, Vector2SpringMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<Vector3, SpringOptions, Vector3SpringMotionAdapter>))]
+[assembly: RegisterGenericJobType(typeof(MotionUpdateJob<Vector4, SpringOptions, Vector4SpringMotionAdapter>))]
+
+namespace LitMotion.Adapters
+{
+    public readonly struct FloatSpringMotionAdapter : IMotionAdapter<float, SpringOptions>
+    {
+        public float Evaluate(ref float startValue, ref float endValue, ref SpringOptions options, in MotionEvaluationContext context)
+        {
+            options.TargetValue.x = endValue;
+            SpringUtility.SpringElastic(
+                (float)context.DeltaTime,
+                ref options.CurrentValue.x,
+                ref options.CurrentVelocity.x,
+                options.TargetValue.x,
+                options.TargetVelocity.x,
+                options.DampingRatio,
+                options.Stiffness
+            );
+            return options.CurrentValue.x;
+        }
+
+        public bool IsCompleted(ref float startValue, ref float endValue, ref SpringOptions options)
+        {
+            return SpringUtility.Approximately(options.CurrentValue.x, options.TargetValue.x);
+        }
+
+        public bool IsDurationBased => false;
+    }
+
+    /// <summary>
+    /// Spring motion adapter for Vector2 using float4 SpringElastic method.
+    /// </summary>
+    public readonly struct Vector2SpringMotionAdapter : IMotionAdapter<Vector2, SpringOptions>
+    {
+        public Vector2 Evaluate(ref Vector2 startValue, ref Vector2 endValue, ref SpringOptions options, in MotionEvaluationContext context)
+        {
+            float deltaTime = (float)context.DeltaTime;
+            options.TargetValue.xy = endValue;
+            SpringUtility.SpringElastic(
+                deltaTime,
+                ref options.CurrentValue,
+                ref options.CurrentVelocity,
+                options.TargetValue,
+                options.TargetVelocity,
+                options.DampingRatio,
+                options.Stiffness
+            );
+            return options.CurrentValue.xy;
+        }
+
+        public bool IsCompleted(ref Vector2 startValue, ref Vector2 endValue, ref SpringOptions options)
+        {
+            return SpringUtility.Approximately(options.CurrentValue, options.TargetValue);
+        }
+
+        public bool IsDurationBased => false;
+    }
+
+    /// <summary>
+    /// Spring motion adapter for Vector3 using float4 SpringElastic method.
+    /// </summary>
+    public readonly struct Vector3SpringMotionAdapter : IMotionAdapter<Vector3, SpringOptions>
+    {
+        public Vector3 Evaluate(ref Vector3 startValue, ref Vector3 endValue, ref SpringOptions options, in MotionEvaluationContext context)
+        {
+            float deltaTime = (float)context.DeltaTime;
+            options.TargetValue.xyz = endValue;
+            SpringUtility.SpringElastic(
+                deltaTime,
+                ref options.CurrentValue,
+                ref options.CurrentVelocity,
+                options.TargetValue,
+                options.TargetVelocity,
+                options.DampingRatio,
+                options.Stiffness
+            );
+            return options.CurrentValue.xyz;
+        }
+
+        public bool IsCompleted(ref Vector3 startValue, ref Vector3 endValue, ref SpringOptions options)
+        {
+            return SpringUtility.Approximately(options.CurrentValue, options.TargetValue);
+        }
+
+        public bool IsDurationBased => false;
+    }
+
+    /// <summary>
+    /// Spring motion adapter for Vector4 using float4 SpringElastic method.
+    /// </summary>
+    public readonly struct Vector4SpringMotionAdapter : IMotionAdapter<Vector4, SpringOptions>
+    {
+        public Vector4 Evaluate(ref Vector4 startValue, ref Vector4 endValue, ref SpringOptions options, in MotionEvaluationContext context)
+        {
+            float deltaTime = (float)context.DeltaTime;
+            options.TargetValue = endValue;
+            SpringUtility.SpringElastic(
+                deltaTime,
+                ref options.CurrentValue,
+                ref options.CurrentVelocity,
+                options.TargetValue,
+                options.TargetVelocity,
+                options.DampingRatio,
+                options.Stiffness
+            );
+
+            return options.CurrentValue;
+        }
+
+        public bool IsCompleted(ref Vector4 startValue, ref Vector4 endValue, ref SpringOptions options)
+        {
+            return SpringUtility.Approximately(options.CurrentValue, options.TargetValue);
+        }
+
+        public bool IsDurationBased => false;
+    }
+}

src/LitMotion/Assets/LitMotion/Runtime/IMotionAdapter.cs

@@ -18,5 +18,12 @@ public interface IMotionAdapter<TValue, TOptions>
         /// <param name="context">Animation context</param>
         /// <returns>Current value</returns>
         TValue Evaluate(ref TValue startValue, ref TValue endValue, ref TOptions options, in MotionEvaluationContext context);
+
+        bool IsCompleted(ref TValue startValue, ref TValue endValue, ref TOptions options)
+        {
+            return false;
+        }
+
+        bool IsDurationBased => true;
     }
 }

src/LitMotion/Assets/LitMotion/Runtime/IMotionOptions.cs

@@ -3,5 +3,8 @@ namespace LitMotion
     /// <summary>
     /// Implement this interface to define special options that can be applied to motion.
     /// </summary>
-    public interface IMotionOptions { }
+    public interface IMotionOptions
+    {
+        void Restart() { }
+     }
 }

src/LitMotion/Assets/LitMotion/Runtime/Internal/MotionData.cs

@@ -54,10 +54,11 @@ public readonly double TotalDuration
 
         public MotionState State;
         public MotionParameters Parameters;
+        public double CurrentLoopStartTime;
 
         public readonly double TimeSinceStart => State.Time - Parameters.Delay;
 
-        public void Update(double time, out float progress)
+        public void UpdateDurationBasedState(double time, out float progress)
         {
             State.PrevCompletedLoops = State.CompletedLoops;
             State.PrevStatus = State.Status;
@@ -172,6 +173,41 @@ public void Update(double time, out float progress)
             }
         }
 
+        public void UpdateIterationState(double time, double deltaTime,bool isOnceCompleted)
+        {
+            State.PrevCompletedLoops = State.CompletedLoops;
+            State.PrevStatus = State.Status;
+            State.Time = time;
+            bool isDelayed;
+            if(time == 0 || (isOnceCompleted && State.CompletedLoops <= Parameters.Loops - 1))
+            {
+                CurrentLoopStartTime = time;
+            }
+            if (Parameters.DelayType == DelayType.FirstLoop)
+                isDelayed = TimeSinceStart < 0f;
+            else
+            {
+                isDelayed = State.Time - CurrentLoopStartTime - Parameters.Delay < 0f;
+            }
+
+            if (isOnceCompleted)
+            {
+                State.CompletedLoops++;
+            }
+            if (isOnceCompleted && Parameters.Loops >= 0 && State.CompletedLoops > Parameters.Loops - 1)
+            {
+                State.Status = MotionStatus.Completed;
+            }
+            else if (isDelayed || State.Time < 0)
+            {
+                State.Status = MotionStatus.Delayed;
+            }
+            else
+            {
+                State.Status = MotionStatus.Playing;
+            }
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Complete(out float progress)
         {
@@ -224,34 +260,99 @@ internal struct MotionData<TValue, TOptions>
         public TValue EndValue;
         public TOptions Options;
 
-        public void Update<TAdapter>(double time, out TValue result)
+        public void Update<TAdapter>(double time, double deltaTime, out TValue result)
             where TAdapter : unmanaged, IMotionAdapter<TValue, TOptions>
         {
-            Core.Update(time, out var progress);
-
-            result = default(TAdapter).Evaluate(ref StartValue, ref EndValue, ref Options, new MotionEvaluationContext()
+            bool isDurationBased = default(TAdapter).IsDurationBased;
+            if (isDurationBased)
             {
-                Progress = progress,
-                Time = time,
-            });
+                Core.UpdateDurationBasedState(time, out var progress);
+                result = default(TAdapter).Evaluate(ref StartValue, ref EndValue, ref Options, new MotionEvaluationContext()
+                {
+                    Progress = progress,
+                    Time = time,
+                    DeltaTime = deltaTime,
+                });
+            }
+            else
+            {
+                bool isOnceCompleted = false;
+                if (time <= 0 || Core.State.Status == MotionStatus.Scheduled)
+                    Core.UpdateIterationState(time, deltaTime, false);
+
+                if (Core.State.Status == MotionStatus.Delayed)
+                    result = StartValue;
+                else if (Core.State.Status == MotionStatus.Completed)
+                    result = EndValue;
+                else
+                {
+                    if (Core.Parameters.LoopType == LoopType.Restart)
+                    {
+                        result = default(TAdapter).Evaluate(ref StartValue, ref EndValue, ref Options, new MotionEvaluationContext()
+                        {
+                            Time = time,
+                            DeltaTime = deltaTime,
+                        });
+                        isOnceCompleted = default(TAdapter).IsCompleted(ref StartValue, ref EndValue, ref Options);
+                        if (isOnceCompleted && Core.State.Status == MotionStatus.Playing)
+                            Options.Restart();
+                    }
+                    else if (Core.Parameters.LoopType == LoopType.Flip || Core.Parameters.LoopType == LoopType.Yoyo)
+                    {
+                        var isOdd = Core.State.CompletedLoops % 2 == 1;
+                        result = isOdd
+                            ? default(TAdapter).Evaluate(ref EndValue, ref StartValue, ref Options, new MotionEvaluationContext()
+                            {
+                                Time = time,
+                                DeltaTime = deltaTime,
+                            })
+                            : default(TAdapter).Evaluate(ref StartValue, ref EndValue, ref Options, new MotionEvaluationContext()
+                            {
+                                Time = time,
+                                DeltaTime = deltaTime,
+                            });
+                        isOnceCompleted = isOdd
+                        ? default(TAdapter).IsCompleted(ref EndValue, ref StartValue, ref Options) 
+                        : default(TAdapter).IsCompleted(ref StartValue, ref EndValue, ref Options);
+                    }
+                    else
+                    {
+
+                        result = default(TAdapter).Evaluate(ref StartValue, ref EndValue, ref Options, new MotionEvaluationContext()
+                        {
+                            Time = time,
+                            DeltaTime = deltaTime,
+                        });
+                        isOnceCompleted = default(TAdapter).IsCompleted(ref StartValue, ref EndValue, ref Options);
+                    }
+                }
+                Core.UpdateIterationState(time, deltaTime, isOnceCompleted);
+            }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Complete<TAdapter>(out TValue result)
             where TAdapter : unmanaged, IMotionAdapter<TValue, TOptions>
         {
+            bool isDurationBased = default(TAdapter).IsDurationBased;
             Core.Complete(out var progress);
-
-            result = default(TAdapter).Evaluate(
-                ref StartValue,
-                ref EndValue,
-                ref Options,
-                new()
-                {
-                    Progress = progress,
-                    Time = Core.State.Time,
-                }
-            );
+            if (isDurationBased)
+            {
+                result = default(TAdapter).Evaluate(
+                    ref StartValue,
+                    ref EndValue,
+                    ref Options,
+                    new()
+                    {
+                        Progress = progress,
+                        Time = Core.State.Time,
+                    }
+                );
+            }
+            else
+            {
+                result = EndValue;
+            }
         }
     }
 }

src/LitMotion/Assets/LitMotion/Runtime/Internal/MotionManager.cs

@@ -25,6 +25,14 @@ public static ref MotionData GetDataRef(MotionHandle handle, bool checkIsInSeque
             CheckTypeId(handle);
             return ref list[handle.StorageId].GetDataRef(handle, checkIsInSequence);
         }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ref MotionData<TValue, TOptions> GetTypeDataRef<TValue, TOptions>(MotionHandle handle, bool checkIsInSequence = true)
+            where TValue : unmanaged
+            where TOptions : unmanaged, IMotionOptions
+        {
+            CheckTypeId(handle);
+            return ref list[handle.StorageId].GetTypeDataRef<TValue, TOptions>(handle, checkIsInSequence);
+        }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ref ManagedMotionData GetManagedDataRef(MotionHandle handle, bool checkIsInSequence = true)

src/LitMotion/Assets/LitMotion/Runtime/Internal/MotionStorage.cs

@@ -28,6 +28,9 @@ internal interface IMotionStorage
         void Complete(MotionHandle handle, bool checkIsInSequence = true);
         void SetTime(MotionHandle handle, double time, bool checkIsInSequence = true);
         ref MotionData GetDataRef(MotionHandle handle, bool checkIsInSequence = true);
+        ref MotionData<ValueType, OptionsType> GetTypeDataRef<ValueType, OptionsType>(MotionHandle handle, bool checkIsInSequence = true)
+            where ValueType : unmanaged
+            where OptionsType : unmanaged, IMotionOptions;
         ref ManagedMotionData GetManagedDataRef(MotionHandle handle, bool checkIsInSequence = true);
         void AddToSequence(MotionHandle handle, out double motionDuration);
         MotionDebugInfo GetDebugInfo(MotionHandle handle);
@@ -387,7 +390,7 @@ public unsafe void SetTime(MotionHandle handle, double time, bool checkIsInSeque
 
                 if (checkIsInSequence && state.IsInSequence) Error.MotionIsInSequence();
 
-                dataPtr->Update<TAdapter>(time, out var result);
+                dataPtr->Update<TAdapter>(time, time - state.Time, out var result);
 
                 var status = state.Status;
                 ref var managedData = ref managedDataArray[denseIndex];
@@ -454,6 +457,14 @@ public ref MotionData GetDataRef(MotionHandle handle, bool checkIsInSequence = t
             return ref UnsafeUtility.As<MotionData<TValue, TOptions>, MotionData>(ref unmanagedDataArray[slot.DenseIndex]);
         }
 
+        public ref MotionData<ValueType, OptionsType> GetTypeDataRef<ValueType, OptionsType>(MotionHandle handle, bool checkIsInSequence = true)
+            where ValueType : unmanaged
+            where OptionsType : unmanaged, IMotionOptions
+        {
+            ref var slot = ref GetSlotWithVarify(handle, checkIsInSequence);
+            return ref UnsafeUtility.As<MotionData<TValue, TOptions>, MotionData<ValueType, OptionsType>>(ref unmanagedDataArray[slot.DenseIndex]);
+        }
+
         public MotionDebugInfo GetDebugInfo(MotionHandle handle)
         {
             ref var slot = ref GetSlotWithVarify(handle, false);