Spline rotations, edit-mode fixes, enum reverts

Author: breadnone

Assets/SlimTween/Scripts/STCurves.cs

@@ -9,15 +9,15 @@ namespace Breadnone.Extension
     public sealed class STSplines
     {
         public STFloat sfloat;
-        public STSplines(Transform transform, Vector3 start, Vector3 middle, Vector3 end, float time)
+        public STSplines(Transform transform, Vector3 start, Vector3 middle, Vector3 end, float time, bool lookAtDirection, bool is2d)
         {
             Vector3 from = transform.position;
             sfloat = STPool.GetInstance<STFloat>(transform.gameObject.GetInstanceID());
             (sfloat as ISlimRegister).GetSetDuration = time;
             sfloat.setEase(Ease.Linear);
-            Three(transform, start, middle, end, time, sfloat);
+            Three(transform, start, middle, end, time, sfloat, lookAtDirection, is2d);
         }
-        void Three(Transform transform, Vector3 start, Vector3 middle, Vector3 end, float time, STFloat sfloat)
+        void Three(Transform transform, Vector3 start, Vector3 middle, Vector3 end, float time, STFloat sfloat, bool lookAtDirection, bool is2d)
         {
             // Calculate control points for cubic Bezier curve
             Vector3 controlStart = start + 2f * (middle - start) / 3f;
@@ -39,7 +39,29 @@ void Three(Transform transform, Vector3 start, Vector3 middle, Vector3 end, floa
                     3f * oneMinusT * t2 * controlEnd +
                     t3 * end;
 
+                var dir = position;
+                var opos = transform.position;
                 transform.position = position;
+
+                // Calculate rotation to face the direction of movement
+                if(lookAtDirection)
+                {
+                        Vector3 direction = (dir - opos).normalized;
+
+                        if (direction != Vector3.zero)
+                        {
+                            if(is2d)
+                            {
+                                Quaternion targetRotation = Quaternion.LookRotation(Vector3.forward, direction);
+                                transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, tick);
+                            }
+                            else
+                            {
+                                Quaternion targetRotation = Quaternion.LookRotation(Vector3.forward, direction);
+                                transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, tick);
+                            }
+                        }
+                }
             });
         }
     }

Assets/SlimTween/Scripts/STween.cs

@@ -1238,9 +1238,9 @@ public static SlimTransform translateLocal(GameObject gameObject, Vector3 direct
         /// <param name="middle">Middle point.</param>
         /// <param name="end">End point.</param>
         /// <param name="duration">Duration.</param>
-        public static STFloat spline(Transform transform, Vector3 middle, Vector3 end, float duration)
+        public static STFloat spline(Transform transform, Vector3 middle, Vector3 end, float duration, bool lookAtDirection, bool is2d)
         {
-            var instance = new STSplines(transform, transform.position, middle, end, duration);
+            var instance = new STSplines(transform, transform.position, middle, end, duration, lookAtDirection, is2d);
             return instance.sfloat;
         }
         /// <summary>
@@ -1252,9 +1252,9 @@ public static STFloat spline(Transform transform, Vector3 middle, Vector3 end, f
         /// <param name="end">End point.</param>
         /// <param name="duration"></param>
         /// <returns></returns>/
-        public static STFloat splineFrom(Transform transform, Vector3 start, Vector3 middle, Vector3 end, float duration)
+        public static STFloat splineFrom(Transform transform, Vector3 start, Vector3 middle, Vector3 end, float duration, bool lookAtDirection, bool is2d)
         {
-            var instance = new STSplines(transform, start, middle, end, duration);
+            var instance = new STSplines(transform, start, middle, end, duration, lookAtDirection, is2d);
             return instance.sfloat;
         }
         /// <summary>

Assets/SlimTween/Scripts/TweenClasses.cs

@@ -25,9 +25,6 @@ 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;
@@ -43,7 +40,7 @@ public class TweenClass : ISlimRegister
         /// <summary>Internal use only.</summary>
         public TProps tprops;
         /// <summary>The tween state of this instance.</summary>
-        protected int state;
+        protected TweenState state = TweenState.None;
         /// <summary>The on update function.</summary>
         protected Action<bool> update;
         /// <summary>The total duration of this instance when tweening.</summary>
@@ -61,21 +58,11 @@ public class TweenClass : ISlimRegister
         /// <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.SetState(TweenState stateType) => state = stateType;
         void ISlimRegister.SetEstimationTime()=> EstimateDuration(0, 1f, tprops.speed);
         /// <summary>Flips the delta ticks</summary>
         protected void FlipTick()
         {
-                if (flipTick)
-                {
-                    tprops.runningFloat = 1f;
-                }
-                else
-                {
-                    tprops.runningFloat = 0f;
-                }
-            
-
             flipTick = !flipTick;
 
             //2 = speed based here
@@ -140,6 +127,7 @@ protected virtual void InternalOnUpdate()
                 return;
             }
 #endif
+
             if (!unscaledTime)
             {
                 if (!flipTick)
@@ -170,7 +158,7 @@ protected virtual void ResetLoop() { }
         public void RunUpdate()
         {
             //if Paused or or None. Stop!
-            if (state < 2)
+            if ((int)state < 2)
                 return;
 
             if (tprops.updatecondition == 3)
@@ -182,7 +170,7 @@ public void RunUpdate()
             }
             else if (tprops.updatecondition == 4)
             {
-                if (runningTime < 0.0001f && CheckIfFinished())
+                if (runningTime < 0.001f && CheckIfFinished())
                 {
                     return;
                 }
@@ -292,7 +280,6 @@ protected bool InvokeRepeat()
 
                 ResetLoop();
                 runningTime = 0.00013f;
-                tprops.runningFloat = 0.00013f;
 
                 if (tprops.oncompleteRepeat)
                 {
@@ -320,7 +307,6 @@ bool checkInfiniteClamp()
             {
                 ResetLoop();
                 runningTime = 0.00013f;
-                tprops.runningFloat = 0.00013f;
                 return true;
             }
 
@@ -337,30 +323,35 @@ protected void Clear()
             ease = 0;
             TweenManager.RemoveFromActiveTween(this);
         }
-        public float EstimateDuration(float current, float target, float speed)
+        /// <summary>Estimation based interpolation</summary>
+        /// <param name="current"></param>
+        /// <param name="target"></param>
+        /// <param name="speed"></param>
+        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);
+            float duration = distance / (speed / 3f);
             return duration;
         }
         ///<summary>Checks if tweening. Paused tween will also mean tweening.</summary>
-        public bool IsTweening => state != 0;
+        public bool IsTweening => state != TweenState.None;
         ///<summary>Checks if paused.</summary>
-        public bool IsPaused => state == 1;
+        public bool IsPaused => state == TweenState.Paused;
         /// <summary>This can mean it's completed or not doing anything. Use IsTweening and IsPaused to check the states instead.</summary>
-        public bool IsNone => state == 0;
+        public bool IsNone => state == TweenState.None;
         ///<summary>Pauses the tweening.</summary>
         public void Pause()
         {
             if (!IsTweening || IsPaused)
                 return;
 
-            state = 1;
+            //1 = paused
+            state = TweenState.Paused;
         }
         ///<summary>Resumes paused tween instances, if any.</summary>
         //The parameter updaterTransform this should be useful for re-scheduling purposes. e.g : Tween chaining.
@@ -379,7 +370,8 @@ public void Resume(bool updateTransform = false)
                 UpdateFrame();
             }
 
-            state = 2;
+            //2 = resume
+            state = TweenState.Tweening;
         }
         /// <summary>
         /// Registers onComplete that will be executed at the very last of the tween (if successfully tweened). 
@@ -465,8 +457,6 @@ public void Dispose()
     public sealed class TProps
     {
         public float runningSpeed;
-        /// <summary>The running underlying tick value;</summary>
-        public float runningFloat = 0.00012f;
         /// <summary>Instance id</summary>
         public int id = -1;
         /// <summary>Instance unique id based on the hashcode.</summary>
@@ -499,7 +489,8 @@ public void SetDefault()
             animationCurve = null;
             delayedTime = -1;
             lerptype = 0;
-            runningFloat = 0.00012f;
+            runningSpeed = 0;
+            updatecondition = 0;
         }
         public void ResetLoopProperties()
         {
@@ -655,7 +646,7 @@ void ISlimTween.UpdateTransform()
                 interp.SetFrom(transform.localScale);
             }
         }
-        (Vector3 from, Vector3 to) ISlimTween.FromTo { get { return (interp.from(), interp.to()); } set { interp.SetFrom(value.from); interp.SetTo(value.to); } }
+        (Vector3 from, Vector3 to) ISlimTween.FromTo { get { return (interp.from, interp.to); } set { interp.SetFrom(value.from); interp.SetTo(value.to); } }
         /// <summary>Initialize transform base value.</summary>
         /// <param name="objectTransform">The transform.</param>
         /// <param name="from">Starting value</param>
@@ -737,22 +728,22 @@ void LerpEuler(float value)
         {
             if (!isLocal)
             {
-                transform.rotation = Quaternion.Euler(interp.to() * value);
+                transform.rotation = Quaternion.Euler(interp.to * value);
             }
             else
             {
-                transform.localRotation = Quaternion.Euler(interp.to() * value);
+                transform.localRotation = Quaternion.Euler(interp.to * value);
             }
         }
         /// <summary>Rotates based on target point.</summary>
         void LerpRotateAround(float value)
         {
-            transform.RotateAround(interp.from(), interp.to(), angle * value);
+            transform.RotateAround(interp.from, interp.to, angle * value);
         }
         /// <summary>Rotates based on target point.</summary>
         void LerpTranslate(float value)
         {
-            transform.Translate(interp.to() * value, !isLocal ? Space.World : Space.Self);
+            transform.Translate(interp.to * value, !isLocal ? Space.World : Space.Self);
         }
     }
     /// <summary>The sub base class.</summary>
@@ -775,7 +766,7 @@ public SlimRect()
         bool disableLerps;
         float angle;
         void ISlimTween.DisableLerps(bool state) { disableLerps = state; }
-        (Vector3 from, Vector3 to) ISlimTween.FromTo { get { return (interp.from(), interp.to()); } set { interp.SetFrom(value.from); interp.SetTo(value.to); } }
+        (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 => (TransformType)type; set => type = value; }
@@ -924,17 +915,17 @@ void LerpEuler(float value)
         {
             if (!isLocal)
             {
-                transform.rotation = Quaternion.Euler(interp.to() * value);
+                transform.rotation = Quaternion.Euler(interp.to * value);
             }
             else
             {
-                transform.localRotation = Quaternion.Euler(interp.to() * value);
+                transform.localRotation = Quaternion.Euler(interp.to * value);
             }
         }
         /// <summary>Rotates based on target point.</summary>
         void LerpRotateAround(float value)
         {
-            transform.RotateAround(interp.from(), interp.to(), angle * value);
+            transform.RotateAround(interp.from, interp.to, angle * value);
         }
         /// <summary>Interpolate delta value.</summary>
         void LerpSizeDelta(float value)
@@ -944,7 +935,7 @@ void LerpSizeDelta(float value)
         void LerpSizeAnchored(float value)
         {
             Vector2 myPrevPivot = transform.pivot;
-            var to = interp.to();
+            var to = interp.to;
             transform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, Mathf.Lerp(transform.rect.width, to.x, value));
             transform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, Mathf.Lerp(transform.rect.height, to.y, value));
             transform.pivot = myPrevPivot;
@@ -989,27 +980,10 @@ public struct InterpolatorStruct
         float b;
         float z;
         float c;
-        static Vector3 vec;
-        public ref Vector3 from()
-        {
-            vec.Set(a, b, c);
-            return ref vec;
-        }
-        public ref Vector3 to()
-        {
-            vec.Set(x, y, z);
-            return ref vec;
-        }
-        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;
-
+        /// <summary>Starting value</summary>
+        public Vector3 from => new Vector3(a, b, c);
+        /// <summary>Target value</summary>
+        public Vector3 to => new Vector3(x, y, z);
         public void Set(Vector3 from, Vector3 to)
         {
             SetFrom(from);
@@ -1030,13 +1004,12 @@ public void SetTo(Vector3 to)
             z = to.z;
         }
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public ref Vector3 Interpolate(float tick)
+        public Vector3 Interpolate(float tick)
         {
-            vec.Set(
+            return new Vector3(
             a + (x - a) * tick,
             b + (y - b) * tick,
             c + (z - c) * tick);
-            return ref vec;
         }
     }
     public struct TFloat6
@@ -1091,7 +1064,6 @@ public void Init(Transform transform, Transform[] followers, float closeDistance
         protected override void InternalOnUpdate()
         {
             base.InternalOnUpdate();
-
             isMoving = Vector3.Distance(lastpos, transform.position) > 0.001f;
 
             for (int i = 0; i < followers.Length; i++)

Assets/SlimTween/Scripts/TweenManager.cs

@@ -166,7 +166,7 @@ public static void ClearRemoveList()
             {
                 var tmp = removeList[i];
 
-                activeTweens.Remove(tmp);
+                activeTweens?.Remove(tmp);
                 removeList[i] = null;
                 ISlimRegister ievent = tmp;