Add smooth damping data structures

Author: adamgraham

Runtime/DataStructures/SmoothDamp.cs

@@ -0,0 +1,65 @@
+using UnityEngine;
+
+namespace Zigurous.Animation
+{
+    /// <summary>
+    /// Gradually changes a value over time using a spring-damper function,
+    /// which will never overshoot.
+    /// </summary>
+    /// <typeparam name="T">The type of value to be animated.</typeparam>
+    [System.Serializable]
+    public abstract class SmoothDamp<T>
+    {
+        protected T _value;
+        protected T _velocity;
+
+        /// <summary>
+        /// The current value.
+        /// </summary>
+        public T value
+        {
+            get { return _value; }
+            protected set { _value = value; }
+        }
+
+        /// <summary>
+        /// The current velocity, this value is modified by the function every
+        /// time you call it.
+        /// </summary>
+        public T velocity
+        {
+            get { return _velocity; }
+            protected set { _velocity = value; }
+        }
+
+        /// <summary>
+        /// Approximately the time it will take to reach the target. A smaller
+        /// value will reach the target faster.
+        /// </summary>
+        [Tooltip("Approximately the time it will take to reach the target. A smaller value will reach the target faster.")]
+        public float smoothTime = 0.1f;
+
+        /// <summary>
+        /// Optionally allows you to clamp the maximum speed.
+        /// </summary>
+        [Tooltip("Optionally allows you to clamp the maximum speed.")]
+        public float maxSpeed = Mathf.Infinity;
+
+        /// <summary>
+        /// Smoothes the current value to the <paramref name="target"/> value.
+        /// </summary>
+        /// <param name="target">The target value.</param>
+        /// <returns>The new current value.</returns>
+        public abstract T Update(T target);
+
+        /// <summary>
+        /// Smoothes the current value to the <paramref name="target"/> value.
+        /// </summary>
+        /// <param name="target">The target value.</param>
+        /// <param name="deltaTime">The time since the last call to this function.</param>
+        /// <returns>The new current value.</returns>
+        public abstract T Update(T target, float deltaTime);
+
+    }
+
+}

Runtime/DataStructures/SmoothDamp.cs.meta

@@ -0,0 +1,39 @@
+using UnityEngine;
+
+namespace Zigurous.Animation
+{
+    /// <summary>
+    /// Gradually changes a float over time using a spring-damper function,
+    /// which will never overshoot.
+    /// </summary>
+    [System.Serializable]
+    public class SmoothDampFloat : SmoothDamp<float>
+    {
+        /// <inheritdoc />
+        /// <param name="target">The target value.</param>
+        public override float Update(float target)
+        {
+            this.value = Mathf.SmoothDamp(this.value, target,
+                ref _velocity,
+                this.smoothTime,
+                this.maxSpeed);
+
+            return this.value;
+        }
+
+        /// <inheritdoc />
+        /// <param name="target">The target value.</param>
+        public override float Update(float target, float deltaTime)
+        {
+            this.value = Mathf.SmoothDamp(this.value, target,
+                ref _velocity,
+                this.smoothTime,
+                this.maxSpeed,
+                deltaTime);
+
+            return this.value;
+        }
+
+    }
+
+}

Runtime/DataStructures/SmoothDampFloat.cs

@@ -0,0 +1,39 @@
+using UnityEngine;
+
+namespace Zigurous.Animation
+{
+    /// <summary>
+    /// Gradually changes a Vector2 over time using a spring-damper function,
+    /// which will never overshoot.
+    /// </summary>
+    [System.Serializable]
+    public class SmoothDampVector2 : SmoothDamp<Vector2>
+    {
+        /// <inheritdoc />
+        /// <param name="target">The target value.</param>
+        public override Vector2 Update(Vector2 target)
+        {
+            this.value = Vector2.SmoothDamp(this.value, target,
+                ref _velocity,
+                this.smoothTime,
+                this.maxSpeed);
+
+            return this.value;
+        }
+
+        /// <inheritdoc />
+        /// <param name="target">The target value.</param>
+        public override Vector2 Update(Vector2 target, float deltaTime)
+        {
+            this.value = Vector2.SmoothDamp(this.value, target,
+                ref _velocity,
+                this.smoothTime,
+                this.maxSpeed,
+                deltaTime);
+
+            return this.value;
+        }
+
+    }
+
+}

Runtime/DataStructures/SmoothDampFloat.cs.meta

@@ -0,0 +1,39 @@
+using UnityEngine;
+
+namespace Zigurous.Animation
+{
+    /// <summary>
+    /// Gradually changes a Vector3 over time using a spring-damper function,
+    /// which will never overshoot.
+    /// </summary>
+    [System.Serializable]
+    public class SmoothDampVector3 : SmoothDamp<Vector3>
+    {
+        /// <inheritdoc />
+        /// <param name="target">The target value.</param>
+        public override Vector3 Update(Vector3 target)
+        {
+            this.value = Vector3.SmoothDamp(this.value, target,
+                ref _velocity,
+                this.smoothTime,
+                this.maxSpeed);
+
+            return this.value;
+        }
+
+        /// <inheritdoc />
+        /// <param name="target">The target value.</param>
+        public override Vector3 Update(Vector3 target, float deltaTime)
+        {
+            this.value = Vector3.SmoothDamp(this.value, target,
+                ref _velocity,
+                this.smoothTime,
+                this.maxSpeed,
+                deltaTime);
+
+            return this.value;
+        }
+
+    }
+
+}