EasedLerp functions and CalculateCentroid

Author: TobiasWehrum

Examples/MathHelperExamples.cs

@@ -13,6 +13,14 @@ void Awake()
         {
             MappingExamples();
             AnglesExamples();
+
+            // Checks what calling the same EasedLerp from 0 to 1 and a factor of 75%
+            // with 1, 10, 100, 1000 or 10000 FPS would return after one second.
+            CheckEasedLerp(1);      // => 0.75
+            CheckEasedLerp(10);     // => 0.7499999
+            CheckEasedLerp(100);    // => 0.7499999
+            CheckEasedLerp(1000);   // => 0.7499995
+            CheckEasedLerp(10000);  // => 0.7500508
         }
 
         void Update()
@@ -70,9 +78,24 @@ private void EasedLerpFactorExample()
             // Set the runner position to the mouse pointer
             runner.position = mousePositionWorld;
 
-            // Each second, move the follower 75% of the remaining distance to the runner
-            float t = MathHelper.EasedLerpFactor(0.75f);
-            follower.position = Vector3.Lerp(follower.position, mousePositionWorld, t);
+            // Move the follower 75% of the remaining distance to the runner per second
+            follower.position = UnityHelper.EasedLerpVector3(follower.position, runner.position, 0.75f);
+
+            // ...which is the same as:
+
+            //float t = MathHelper.EasedLerpFactor(0.75f);
+            //follower.position = Vector3.Lerp(follower.position, mousePositionWorld, t);
+        }
+
+        void CheckEasedLerp(int steps)
+        {
+            var dt = 1f / steps;
+
+            var currentValue = 0f;
+            for (var i = 0; i < steps; i++)
+                currentValue = MathHelper.EasedLerp(currentValue, 1f, 0.75f, dt);
+
+            Debug.LogFormat("CheckEasedLerp({0}): {1}", steps, currentValue);
         }
     }
 }

Examples/UnityHelperExamples.cs

@@ -14,13 +14,16 @@ public class UnityHelperExamples : MonoBehaviour
         void Awake()
         {
             TransformVectorColorExamples();
+            CentroidExample();
             Vector2RotationExamples();
             GameObjectExamples();
             RectExamples();
             PlayerPrefsExample();
             CapsuleCastExample();
             RandomExamples();
             OtherExamples();
+
+            // You can find an example for eased lerping in MathHelperExamples.EasedLerpFactorExample()
         }
 
         void TransformVectorColorExamples()
@@ -49,6 +52,18 @@ void TransformVectorColorExamples()
             enemyIndicator.CopyPositionAndRotatationFrom(someEnemyTransform);
         }
 
+        private void CentroidExample()
+        {
+            Vector3[] list = {
+                                new Vector3(-5, 10, 12),
+                                new Vector3(55, 32, 10),
+                                new Vector3(85, -40, 80)
+                             };
+
+            // Calculates the geometric center (the average) of the input list.
+            Debug.Log("Centroid: " + list.CalculateCentroid()); // => Centroid: (45.0, 0.7, 34.0)
+        }
+
         void Vector2RotationExamples()
         {
             // Create a length 1 Vector2 pointing 40 degrees away from (1.0, 0.0)

MathHelper/MathHelper.cs

@@ -125,7 +125,7 @@ public static float NormalizeAngleDeg180(float angle)
 
         #endregion
 
-        #region Miscellaneous
+        #region Framerate-Independent Lerping
 
         /// <summary>
         /// Provides a framerate-independent t for lerping towards a target.
@@ -147,8 +147,8 @@ public static float NormalizeAngleDeg180(float angle)
         ///     currentValue = Mathf.Lerp(currentValue, 1f, 0.95f);
         /// 
         /// every frame provides an easy way of eased lerping without tracking elapsed time or the
-        /// starting value, but since it's called every frame, the actual speed changes the higher
-        /// the framerate is.
+        /// starting value, but since it's called every frame, the actual traversed distance per
+        /// second changes the higher the framerate is.
         /// 
         /// This function replaces the lerp T to make it framerate-independent and easier to estimate.
         /// 
@@ -165,6 +165,29 @@ public static float EasedLerpFactor(float factor, float deltaTime = 0f)
             return 1 - Mathf.Pow(1 - factor, deltaTime);
         }
 
+        /// <summary>
+        /// Framerate-independent eased lerping to a target value, slowing down the closer it is.
+        /// 
+        /// If you call
+        /// 
+        ///     currentValue = MathHelper.EasedLerp(currentValue, 1f, 0.75f);
+        /// 
+        /// each frame (e.g. in Update()), starting with a currentValue of 0, then after 1 second
+        /// it will be approximately 0.75 - which is 75% of the way between 0 and 1.
+        /// 
+        /// Adjusting the target or the percentPerSecond between calls is also possible.
+        /// </summary>
+        /// <param name="current">The current value.</param>
+        /// <param name="target">The target value.</param>
+        /// <param name="percentPerSecond">How much of the distance between current and target should be covered per second?</param>
+        /// <param name="deltaTime">How much time passed since the last call.</param>
+        /// <returns>The interpolated value from current to target.</returns>
+        public static float EasedLerp(float current, float target, float percentPerSecond, float deltaTime = 0f)
+        {
+            var t = EasedLerpFactor(percentPerSecond, deltaTime);
+            return Mathf.Lerp(current, target, t);
+        }
+
         #endregion
     }
 }

MathHelper/README.md

@@ -10,25 +10,34 @@ There are essentially two ways of lerping a value over time: linear (constant sp
 
 For linear lerping (and most of the easing functions), you need to track the start and end positions and the time that elapsed.
 
-Calling something like `currentValue = Mathf.Lerp(currentValue, 1f, 0.95f);` every frame provides an easy way of eased lerping without tracking elapsed time or the starting value, but since it's called every frame, the actual speed changes the higher the framerate is.
+Calling something like `currentValue = Mathf.Lerp(currentValue, 1f, 0.95f);` every frame provides an easy way of eased lerping without tracking elapsed time or the starting value, but since it's called every frame, the actual traversed distance per second changes the higher the framerate is.
 
 EasedLerpFactor replaces the lerp parameter t to make it framerate-independent and easier to estimate.
 
 You can find more information about the formula used [here](https://www.scirra.com/blog/ashley/17/using-lerp-with-delta-time).
 
+You can use `MathHelper.EasedLerpFactor` to get the t used for a lerp or call `MathHelper.EasedLerp`, `UnityHelper.EasedLerpVector2`, `UnityHelper.EasedLerpVector3`, `UnityHelper.EasedLerpVector4` or `UnityHelper.EasedLerpColor` directly.
+
 ![EasedLerpFactorExample Editor Screenshot](https://raw.githubusercontent.com/TobiasWehrum/unity-utilities/master/_Images/EasedLerpFactorExample.gif)
 
 ```C#
-// Get the world position of the mouse pointer
-Vector3 mousePositionWorld = Camera.main.ScreenToWorldPoint(Input.mousePosition);
-mousePositionWorld.z = 0f;
+void Update()
+{
+	// Get the world position of the mouse pointer
+	Vector3 mousePositionWorld = Camera.main.ScreenToWorldPoint(Input.mousePosition);
+	mousePositionWorld.z = 0f;
+
+	// Set the runner position to the mouse pointer
+	runner.position = mousePositionWorld;
+
+	// Move the follower 75% of the remaining distance to the runner per second
+	follower.position = UnityHelper.EasedLerpVector3(follower.position, runner.position, 0.75f);
 
-// Set the runner position to the mouse pointer
-runner.position = mousePositionWorld;
+	// ...which is the same as:
 
-// Each second, move the follower 75% of the remaining distance to the runner
-float t = MathHelper.EasedLerpFactor(0.75f);
-follower.position = Vector3.Lerp(follower.position, mousePositionWorld, t);
+	//float t = MathHelper.EasedLerpFactor(0.75f);
+	//follower.position = Vector3.Lerp(follower.position, mousePositionWorld, t);
+}
 ```
 
 ### Mapping

README.md

@@ -31,7 +31,8 @@ You can also just use selected scripts, but you should check the "Dependencies"
 The class documentation is available [here](http://tobiaswehrum.github.io/UnityUtilities/html/annotated.html).
 
 ## Changelog
-* 2016-10-20: Added [MathHelper](https://github.com/TobiasWehrum/unity-utilities/tree/master/MathHelper). Added randomization helper methods to [UnityHelper](https://github.com/TobiasWehrum/unity-utilities/tree/master/UnityHelper).
+* 2016-10-23: Fixed bugs/improved [Singleton](https://github.com/TobiasWehrum/unity-utilities/tree/master/Singleton). Added EasedLerp methods for float in [MathHelper](https://github.com/TobiasWehrum/unity-utilities/tree/master/MathHelper) and Vector2, Vector3 and Color in [UnityHelper](https://github.com/TobiasWehrum/unity-utilities/tree/master/UnityHelper).
+* 2016-10-22: Added [MathHelper](https://github.com/TobiasWehrum/unity-utilities/tree/master/MathHelper). Added randomization helper methods to [UnityHelper](https://github.com/TobiasWehrum/unity-utilities/tree/master/UnityHelper).
 * 2016-07-03: Added [MeshCreator](https://github.com/TobiasWehrum/unity-utilities/tree/master/MeshCreator).
 * 2016-06-19: Added [XmlHelper](https://github.com/TobiasWehrum/unity-utilities/tree/master/XmlHelper).
 * 2016-06-08: Added [UnityHelper](https://github.com/TobiasWehrum/unity-utilities/tree/master/UnityHelper).

UnityHelper/README.md

@@ -31,6 +31,55 @@ Color halfTransparentColor = GetComponent<Renderer>().sharedMaterial.color.Chang
 enemyIndicator.CopyPositionAndRotatationFrom(someEnemyTransform);
 ```
 
+### Framerate-Independent Eased Lerping
+
+There are essentially two ways of lerping a value over time: linear (constant speed) or eased (e.g. getting slower the closer you are to the target, see http://easings.net.)
+
+For linear lerping (and most of the easing functions), you need to track the start and end positions and the time that elapsed.
+
+Calling something like `currentValue = Mathf.Lerp(currentValue, 1f, 0.95f);` every frame provides an easy way of eased lerping without tracking elapsed time or the starting value, but since it's called every frame, the actual traversed distance per second changes the higher the framerate is.
+
+EasedLerpFactor replaces the lerp parameter t to make it framerate-independent and easier to estimate.
+
+You can find more information about the formula used [here](https://www.scirra.com/blog/ashley/17/using-lerp-with-delta-time).
+
+You can use `MathHelper.EasedLerpFactor` to get the t used for a lerp or call `MathHelper.EasedLerp`, `UnityHelper.EasedLerpVector2`, `UnityHelper.EasedLerpVector3`, `UnityHelper.EasedLerpVector4` or `UnityHelper.EasedLerpColor` directly.
+
+![EasedLerpFactorExample Editor Screenshot](https://raw.githubusercontent.com/TobiasWehrum/unity-utilities/master/_Images/EasedLerpFactorExample.gif)
+
+```C#
+void Update()
+{
+	// Get the world position of the mouse pointer
+	Vector3 mousePositionWorld = Camera.main.ScreenToWorldPoint(Input.mousePosition);
+	mousePositionWorld.z = 0f;
+
+	// Set the runner position to the mouse pointer
+	runner.position = mousePositionWorld;
+
+	// Move the follower 75% of the remaining distance to the runner per second
+	follower.position = UnityHelper.EasedLerpVector3(follower.position, runner.position, 0.75f);
+
+	// ...which is the same as:
+
+	//float t = MathHelper.EasedLerpFactor(0.75f);
+	//follower.position = Vector3.Lerp(follower.position, mousePositionWorld, t);
+}
+```
+
+### Get the centroid from an array/list of Vector2/3/4
+
+```C#
+Vector3[] list = {
+					new Vector3(-5, 10, 12),
+					new Vector3(55, 32, 10),
+					new Vector3(85, -40, 80)
+				 };
+
+// Calculates the geometric center (the average) of the input list.
+Debug.Log("Centroid: " + list.CalculateCentroid()); // => Centroid: (45.0, 0.7, 34.0)
+```
+
 ### Vector2 Rotation
 
 ```C#
@@ -150,4 +199,4 @@ bool hitSomething = Physics.CapsuleCast(point1, point2, radius, Vector3.forward,
 
 ## Dependencies
 
-None.
+* [MathHelper](https://github.com/TobiasWehrum/unity-utilities/tree/master/MathHelper)