Speed fixes, simplify update logic

Author: breadnone

Assets/SlimTween/Scripts/TweenClasses.cs

@@ -25,6 +25,9 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 using UnityEngine;
 using System;
 using System.Runtime.CompilerServices;
+using System.Collections.Specialized;
+using System.Collections;
+using System.Collections.Generic;
 
 #if UNITY_EDITOR
 using UnityEditor;
@@ -50,30 +53,36 @@ public class TweenClass : ISlimRegister
         protected bool unscaledTime;
         /// <summary>The frameCount when it 1st initialized.</summary>
         protected int frameIn;
-        public int ease {get; private set;}
+        public int ease { get; private set; }
         /// <summary>Gets and sets the duration.</summary>
         float ISlimRegister.GetSetDuration { get => duration; set => duration = value; }
         /// <summary>Gets and sets the runningTime.</summary>
         float ISlimRegister.GetSetRunningTime { get => runningTime; set => runningTime = value; }
         /// <summary>Unscaled or scaled Time.delta.</summary>
         bool ISlimRegister.UnscaledTimeIs { get => unscaledTime; set => unscaledTime = value; }
-        void ISlimRegister.SetEase(Ease easeType)=> ease = (int)easeType;
-        void ISlimRegister.SetState(TweenState stateType)=> state = (int)stateType;
+        void ISlimRegister.SetEase(Ease easeType) => ease = (int)easeType;
+        void ISlimRegister.SetState(TweenState stateType) => state = (int)stateType;
+        void ISlimRegister.SetEstimationTime()=> EstimateDuration(0, 1f, tprops.speed);
         /// <summary>Flips the delta ticks</summary>
         protected void FlipTick()
         {
-            if (flipTick)
-            {
-                tprops.runningFloat = 1f;
-                tprops.runningFloat -= 0.00013f;
-            }
-            else
-            {
-                tprops.runningFloat = 0f;
-                tprops.runningFloat += 0.00013f;
-            }
+                if (flipTick)
+                {
+                    tprops.runningFloat = 1f;
+                }
+                else
+                {
+                    tprops.runningFloat = 0f;
+                }
+            
 
             flipTick = !flipTick;
+            
+            //2 = speed based here
+            if(tprops.lerptype != 2)
+            {
+                tprops.updatecondition += flipTick ? 1 : -1;
+            }
         }
         protected bool flipTick = false;
         bool ISlimRegister.FlipTickIs => flipTick;
@@ -164,28 +173,25 @@ public void RunUpdate()
             if (state < 2)
                 return;
 
-            if(tprops.lerptype > 2)
+            if (tprops.updatecondition == 3)
             {
-                if (!flipTick)
+                if (runningTime > duration && CheckIfFinished())
                 {
-                    if (runningTime > duration && CheckIfFinished())
-                    {
-                        return;
-                    }
+                    return;
                 }
-                else
+            }
+            else if (tprops.updatecondition == 4)
+            {
+                if (runningTime < 0.0001f && CheckIfFinished())
                 {
-                    if (runningTime < 0.0001f && CheckIfFinished())
-                    {
-                        return;
-                    }
+                    return;
                 }
             }
             else
             {
-                if ((tprops.loopCounter & 1) == 0)
+                if (!flipTick)
                 {
-                    if (!flipTick && tprops.runningFloat + 0.00013 > 1f || (!flipTick && tprops.runningFloat - 0.00015 < 0f && Mathf.Approximately(runningTime, duration)))
+                    if (tprops.runningSpeed + 0.0001f > 1f)
                     {
                         if (CheckIfFinished())
                         {
@@ -195,7 +201,7 @@ public void RunUpdate()
                 }
                 else
                 {
-                    if (flipTick && tprops.runningFloat - 0.00015f < 0f)
+                    if (tprops.runningSpeed < 0.0001f)
                     {
                         if (CheckIfFinished())
                         {
@@ -250,25 +256,6 @@ protected bool CheckIfFinished()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         protected bool InvokeRepeat()
         {
-            /*
-            if (tprops.loopCounter < 0)
-            {
-                ResetLoop();
-
-                if (tprops.pingpong)
-                {
-                    FlipTick();
-                }
-                else
-                {
-                    runningTime = 0.00013f;
-                    tprops.runningFloat = 0.00013f;
-                }
-
-                return true;
-            }
-            */
-
             if (tprops.pingpong)
             {
                 if (checkInfinitePingPong())
@@ -350,6 +337,17 @@ protected void Clear()
             ease = 0;
             TweenManager.RemoveFromActiveTween(this);
         }
+        public float EstimateDuration(float current, float target, float speed)
+        {
+            float deltaTime = !unscaledTime ? Time.deltaTime : Time.unscaledDeltaTime;
+            
+            // Calculate the distance between current and target value
+            float distance = Mathf.Abs(target - current);
+            
+            // Calculate the time duration to reach the target value
+            float duration = distance / (speed / 3f * deltaTime);
+            return duration;
+        }
         ///<summary>Checks if tweening. Paused tween will also mean tweening.</summary>
         public bool IsTweening => state != 0;
         ///<summary>Checks if paused.</summary>
@@ -466,6 +464,7 @@ public void Dispose()
     [Serializable]
     public sealed class TProps
     {
+        public float runningSpeed;
         /// <summary>The running underlying tick value;</summary>
         public float runningFloat = 0.00012f;
         /// <summary>Instance id</summary>
@@ -486,8 +485,9 @@ public sealed class TProps
         public float speed = -1f;
         /// <summary>AnimationCurves</summary>
         public AnimationCurve animationCurve;
-        /// <summary>1 speed, 2 curve, 3 regular.</summary>
+        /// <summary>1 curve, 2 speed, 3 regular.</summary>
         public int lerptype = 0;
+        public int updatecondition;
         ///<summary>Sets to default value to be reused in a pool. If not then will be normally disposed.</summary>
         public void SetDefault()
         {
@@ -508,20 +508,23 @@ public void ResetLoopProperties()
         /// <summary>Sets the lerptype.</summary>
         public void SetLerpType()
         {
-            if(speed < 0)
+            if (speed < 0)
             {
-                if(animationCurve == null)
+                if (animationCurve == null)
                 {
                     lerptype = 3;
+                    updatecondition = 3;
                 }
                 else
                 {
                     lerptype = 1;
+                    updatecondition = 1;
                 }
             }
             else
             {
                 lerptype = 2;
+                updatecondition = 2;
             }
         }
     }
@@ -553,6 +556,7 @@ public interface ISlimRegister
         public bool UnscaledTimeIs { get; set; }
         public void SetEase(Ease easeType);
         public void SetState(TweenState stateType);
+        public void SetEstimationTime();
     }
     /// <summary>STTransform class to handle all Transforms.</summary>
     public sealed class SlimTransform : TweenClass, ISlimTween
@@ -562,7 +566,7 @@ public SlimTransform()
             interp = new InterpolatorStruct();
         }
         /// <summary>Previous assigned type.</summary>
-        TransformType ISlimTween.GetTransformType { get => type; set => type = value; }
+        TransformType ISlimTween.GetTransformType { get => (TransformType)type; set => type = value; }
         /// <summary>The transform.</summary>
         Transform transform;
         /// <summary>Starting value.</summary>
@@ -601,19 +605,19 @@ protected override void InternalOnUpdate()
 
             switch (type)
             {
-                case TransformType.Move:
+                case TransformType.Move: //Move
                     LerpPosition(this.FloatInterp(tick));
                     break;
-                case TransformType.Scale:
+                case TransformType.Scale: //Scale
                     LerpScale(this.FloatInterp(tick));
                     break;
-                case TransformType.Rotate:
+                case TransformType.Rotate: //Rotate
                     LerpEuler(this.FloatInterp(tick));
                     break;
-                case TransformType.RotateAround:
+                case TransformType.RotateAround: //RotateAround
                     LerpRotateAround(this.FloatInterp(tick));
                     break;
-                case TransformType.Translate:
+                case TransformType.Translate: //Translate
                     LerpTranslate(this.FloatInterp(tick));
                     break;
             }
@@ -622,19 +626,19 @@ void InvokeLerps(float tick)
         {
             switch (type)
             {
-                case TransformType.Move:
+                case TransformType.Move: //Move
                     LerpPosition(this.FloatInterp(tick));
                     break;
-                case TransformType.Scale:
+                case TransformType.Scale: //Scale
                     LerpScale(this.FloatInterp(tick));
                     break;
-                case TransformType.Rotate:
+                case TransformType.Rotate: //Rotate
                     LerpEuler(this.FloatInterp(tick));
                     break;
-                case TransformType.RotateAround:
+                case TransformType.RotateAround: //RotateAround
                     LerpRotateAround(this.FloatInterp(tick));
                     break;
-                case TransformType.Translate:
+                case TransformType.Translate: //Translate
                     LerpTranslate(this.FloatInterp(tick));
                     break;
             }
@@ -774,7 +778,7 @@ public SlimRect()
         (Vector3 from, Vector3 to) ISlimTween.FromTo { get { return (interp.from(), interp.to()); } set { interp.SetFrom(value.from); interp.SetTo(value.to); } }
         bool ISlimTween.Locality { get => isLocal; set => isLocal = value; }
         /// <summary>Previous assigned type.</summary>
-        TransformType ISlimTween.GetTransformType { get => type; set => type = value; }
+        TransformType ISlimTween.GetTransformType { get => (TransformType)type; set => type = value; }
         /// <summary>Initialize transform base value.</summary>
         /// <param name="objectTransform">The transform.</param>
         /// <param name="from">Starting value</param>
@@ -863,22 +867,22 @@ void InvokeLerps(float tick)
         {
             switch (type)
             {
-                case TransformType.Move:
+                case TransformType.Move: //Move
                     LerpPosition(this.FloatInterp(tick));
                     break;
-                case TransformType.Scale:
+                case TransformType.Scale: //Scale
                     LerpScale(this.FloatInterp(tick));
                     break;
-                case TransformType.Rotate:
+                case TransformType.Rotate: //Rotate
                     LerpEuler(this.FloatInterp(tick));
                     break;
-                case TransformType.RotateAround:
+                case TransformType.RotateAround: //RotateAround
                     LerpRotateAround(this.FloatInterp(tick));
                     break;
-                case TransformType.SizeDelta:
+                case TransformType.SizeDelta: //SizeDelta
                     LerpSizeDelta(this.FloatInterp(tick));
                     break;
-                case TransformType.SizeAnchored:
+                case TransformType.SizeAnchored: //SizeAnchored
                     LerpSizeAnchored(this.FloatInterp(tick));
                     break;
             }
@@ -964,17 +968,16 @@ public interface ISlimTween
     /// <param name="start"></param>
     /// <param name="end"></param>
     /// <param name="time"></param>
-    public enum TransformType : byte
+    public enum TransformType
     {
         None = 0,
         Move = 1,
         Scale = 2,
         Rotate = 3,
         RotateAround = 4,
-        Follow = 5,
-        SizeDelta = 6,
-        SizeAnchored = 7,
-        Translate = 8
+        SizeDelta = 5,
+        SizeAnchored = 6,
+        Translate = 7
     }
 
     [Serializable]
@@ -997,15 +1000,15 @@ public ref Vector3 to()
             vec.Set(x, y, z);
             return ref vec;
         }
-        public ref Vector3 GetRef(float tick)
+        public ref Vector3 UpdateRef(float tick)
         {
             vec.Set(
             a + (x - a) * tick,
             b + (y - b) * tick,
             c + (z - c) * tick);
             return ref vec;
         }
-        public ref Vector3 GetVector()=> ref vec;
+        public ref Vector3 GetVector() => ref vec;
 
         public void Set(Vector3 from, Vector3 to)
         {

Assets/SlimTween/Scripts/TweenManager.cs

@@ -90,6 +90,11 @@ public static void TweenBagCache()
                     activeTweens.Add(tmp);
                     temporary.Remove(tmp);
                     tmp.tprops.SetLerpType();
+
+                    if(tmp.tprops.speed > 0)
+                    {
+                        (tmp as ISlimRegister).GetSetDuration = float.PositiveInfinity;
+                    }
                 }
             }
         }

Assets/SlimTween/Scripts/TweenUtility.cs

@@ -59,6 +59,20 @@ public static float FloatInterp(this TweenClass tclass, float time)
                 return STEasing.Easing(tclass.ease, time); //disable easepower for now, change time param to : (tclass.tprops.easePower + time)
             }
             else if(tclass.tprops.lerptype > 1)
+            {
+                ISlimRegister islim = tclass;
+                
+                var to = 1f;
+
+                if(islim.FlipTickIs)
+                {
+                    to = 0f;
+                }
+
+                tclass.tprops.runningSpeed = Mathf.MoveTowards(tclass.tprops.runningSpeed, to, tclass.tprops.speed / 3f * (!islim.UnscaledTimeIs ? Time.deltaTime : Time.unscaledDeltaTime));
+                return tclass.tprops.runningSpeed; //TODO: if tprops.runningFloat won't work, rever it back to runningTime
+            }
+            else
             {
                 ISlimRegister islim = tclass;
                 var zero = 0f;
@@ -72,12 +86,6 @@ public static float FloatInterp(this TweenClass tclass, float time)
 
                 return Mathf.LerpUnclamped(zero, one, tclass.tprops.animationCurve.Evaluate(time));
             }
-            else
-            {
-                ISlimRegister islim = tclass;
-                tclass.tprops.runningFloat = Mathf.MoveTowards(tclass.tprops.runningFloat, !islim.FlipTickIs ? 1f : 0f, tclass.tprops.speed / 3f * (!islim.UnscaledTimeIs ? Time.deltaTime : Time.unscaledDeltaTime));
-                return tclass.tprops.runningFloat; //TODO: if tprops.runningFloat won't work, rever it back to runningTime
-            }
         }
         public static float LerpRefs(this TweenClass tclass, float time, ref Vector3 refs)
         {