Move settings to main Tweening class

Author: adamgraham

Runtime/EaseFunction.cs

@@ -63,12 +63,6 @@ public static class EaseFunction
             { Ease.BounceInOut, BounceInOut },
         };
 
-        private static float c1 = Settings.overshoot;
-        private static float c2 = c1 * 1.525f;
-        private static float c3 = c1 + 1.0f;
-        private static float c4 = (2.0f * Mathf.PI) / 3.0f;
-        private static float c5 = (2.0f * Mathf.PI) / 4.5f;
-
         public static float Linear(float x)
         {
             return x;
@@ -193,16 +187,17 @@ public static float CircInOut(float x)
 
         public static float BackIn(float x)
         {
-            return c3 * x * x * x - c1 * x * x;
+            return (Tweening.overshoot + 1.0f) * x * x * x - Tweening.overshoot * x * x;
         }
 
         public static float BackOut(float x)
         {
-            return 1.0f + c3 * Mathf.Pow(x - 1.0f, 3.0f) + c1 * Mathf.Pow(x - 1.0f, 2.0f);
+            return 1.0f + (Tweening.overshoot + 1.0f) * Mathf.Pow(x - 1.0f, 3.0f) + Tweening.overshoot * Mathf.Pow(x - 1.0f, 2.0f);
         }
 
         public static float BackInOut(float x)
         {
+            float c2 = Tweening.overshoot * 1.525f;
             return x < 0.5f ?
                 (Mathf.Pow(2.0f * x, 2.0f) * ((c2 + 1.0f) * 2.0f * x - c2)) / 2.0f :
                 (Mathf.Pow(2.0f * x - 2.0f, 2.0f) * ((c2 + 1.0f) * (x * 2.0f - 2.0f) + c2) + 2.0f) / 2.0f;
@@ -211,20 +206,20 @@ public static float BackInOut(float x)
         public static float ElasticIn(float x)
         {
             return x <= 0.0f ? 0.0f : x >= 1.0f ? 1.0f :
-                -Mathf.Pow(2.0f, 10.0f * x - 10.0f) * Mathf.Sin((x * 10.0f - 10.75f) * c4);
+                -Mathf.Pow(2.0f, 10.0f * x - 10.0f) * Mathf.Sin((x * 10.0f - 10.75f) * ((2.0f * Mathf.PI) / 3.0f));
         }
 
         public static float ElasticOut(float x)
         {
             return x <= 0.0f ? 0.0f : x >= 1.0f ? 1.0f :
-                Mathf.Pow(2.0f, -10.0f * x) * Mathf.Sin((x * 10.0f - 0.75f) * c4) + 1.0f;
+                Mathf.Pow(2.0f, -10.0f * x) * Mathf.Sin((x * 10.0f - 0.75f) * ((2.0f * Mathf.PI) / 3.0f)) + 1.0f;
         }
 
         public static float ElasticInOut(float x)
         {
             return x <= 0.0f ? 0.0f : x >= 1.0f ? 1.0f : x < 0.5f ?
-                -(Mathf.Pow(2.0f, 20.0f * x - 10.0f) * Mathf.Sin((20.0f * x - 11.125f) * c5)) / 2.0f :
-                Mathf.Pow(2.0f, -20.0f * x + 10.0f) * Mathf.Sin((20.0f * x - 11.125f) * c5) / 2.0f + 1.0f;
+                -(Mathf.Pow(2.0f, 20.0f * x - 10.0f) * Mathf.Sin((20.0f * x - 11.125f) * ((2.0f * Mathf.PI) / 4.5f))) / 2.0f :
+                Mathf.Pow(2.0f, -20.0f * x + 10.0f) * Mathf.Sin((20.0f * x - 11.125f) * ((2.0f * Mathf.PI) / 4.5f)) / 2.0f + 1.0f;
         }
 
         public static float BounceIn(float x)

Runtime/Settings.cs

@@ -59,12 +59,12 @@ public abstract class Tween
         /// <summary>
         /// The easing function type used by the tween to animate values.
         /// </summary>
-        public Ease ease = Settings.defaultEase;
+        public Ease ease = Tweening.defaultEase;
 
         /// <summary>
         /// The amount of seconds the tween takes to complete.
         /// </summary>
-        public float duration = Settings.defaultDuration;
+        public float duration = Tweening.defaultDuration;
 
         /// <summary>
         /// The amount of seconds that have elapsed since the tween started.
@@ -80,7 +80,7 @@ public abstract class Tween
         /// The amount of seconds the tween waits before playing after being
         /// started.
         /// </summary>
-        public float delay = Settings.defaultDelay;
+        public float delay = Tweening.defaultDelay;
 
         /// <summary>
         /// The amount of seconds that have elapsed during the tween's delayed
@@ -104,17 +104,17 @@ public abstract class Tween
         /// <summary>
         /// Keeps the tween in memory to be re-used after being killed.
         /// </summary>
-        public bool recyclable = Settings.defaultRecyclable;
+        public bool recyclable = Tweening.defaultRecyclable;
 
         /// <summary>
         /// Automatically starts the tween after being created.
         /// </summary>
-        public bool autoStart = Settings.defaultAutoStart;
+        public bool autoStart = Tweening.defaultAutoStart;
 
         /// <summary>
         /// Automatically kills the tween after being completed.
         /// </summary>
-        public bool autoKill = Settings.defaultAutoKill;
+        public bool autoKill = Tweening.defaultAutoKill;
 
         /// <summary>
         /// The callback invoked every time the tween is updated, i.e., any time
@@ -308,15 +308,15 @@ internal void Reset()
             this.id = -1;
             this.state = TweenState.Ready;
             this.internalState = InternalTweenState.Queued;
-            this.ease = Settings.defaultEase;
-            this.duration = Settings.defaultDuration;
+            this.ease = Tweening.defaultEase;
+            this.duration = Tweening.defaultDuration;
             this.elapsed = 0.0f;
-            this.delay = Settings.defaultDelay;
+            this.delay = Tweening.defaultDelay;
             this.delayElapsed = 0.0f;
             this.reversed = false;
-            this.autoStart = Settings.defaultAutoStart;
-            this.autoKill = Settings.defaultAutoKill;
-            this.recyclable = Settings.defaultRecyclable;
+            this.autoStart = Tweening.defaultAutoStart;
+            this.autoKill = Tweening.defaultAutoKill;
+            this.recyclable = Tweening.defaultRecyclable;
 
             this.onUpdate = null;
             this.onStart = null;

Runtime/Settings.cs.meta

@@ -12,7 +12,7 @@ internal sealed class TweenManager : MonoBehaviour
         /// <summary>
         /// A list of all alive tween objects.
         /// </summary>
-        internal List<Tween> tweens = new List<Tween>(Settings.initialCapacity);
+        internal List<Tween> tweens = new List<Tween>(Tweening.initialCapacity);
 
         private static bool _isUnloading = false;
         private static object _lock = new object();

Runtime/Tween.cs

@@ -8,6 +8,47 @@ namespace Zigurous.Tweening
     /// </summary>
     public static class Tweening
     {
+        /// <summary>
+        /// The default Ease assigned to every tween.
+        /// </summary>
+        public static Ease defaultEase = Ease.QuadOut;
+
+        /// <summary>
+        /// Automatically starts tweens after being created, by default.
+        /// </summary>
+        public static bool defaultAutoStart = true;
+
+        /// <summary>
+        /// Automatically kills tweens after being completed, by default.
+        /// </summary>
+        public static bool defaultAutoKill = true;
+
+        /// <summary>
+        /// Keeps tweens in memory to be re-used after being killed, by default.
+        /// </summary>
+        public static bool defaultRecyclable = true;
+
+        /// <summary>
+        /// The default amount of seconds a tween takes to complete.
+        /// </summary>
+        public static float defaultDuration = 0.3f;
+
+        /// <summary>
+        /// The default amount of seconds before every tween starts.
+        /// </summary>
+        public static float defaultDelay = 0.0f;
+
+        /// <summary>
+        /// The default overshoot value used in easing functions.
+        /// </summary>
+        public static float overshoot = 1.70158f;
+
+        /// <summary>
+        /// The initial amount of tweens that memory is allocated for when the
+        /// system starts. Additional memory will be allocated as needed.
+        /// </summary>
+        public static int initialCapacity = 16;
+
         /// <summary>
         /// The number of tweens currently alive (not necessarily active).
         /// </summary>