using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/**
* Interpolation utility functions: easing, bezier, and catmull-rom.
* Consider using Unity's Animation curve editor and AnimationCurve class
* before scripting the desired behaviour using this utility.
*
* Interpolation functionality available at different levels of abstraction.
* Low level access via individual easing functions (ex. EaseInOutCirc),
* Bezier(), and CatmullRom(). High level access using sequence generators,
* NewEase(), NewBezier(), and NewCatmullRom().
*
* Sequence generators are typically used as follows:
*
* IEnumerable<Vector3> sequence = Interpolate.New[Ease|Bezier|CatmulRom](configuration);
* foreach (Vector3 newPoint in sequence) {
* transform.position = newPoint;
* yield return WaitForSeconds(1.0f);
* }
*
* Or:
*
* IEnumerator<Vector3> sequence = Interpolate.New[Ease|Bezier|CatmulRom](configuration).GetEnumerator();
* function Update() {
* if (sequence.MoveNext()) {
* transform.position = sequence.Current;
* }
* }
*
* The low level functions work similarly to Unity's built in Lerp and it is
* up to you to track and pass in elapsedTime and duration on every call. The
* functions take this form (or the logical equivalent for Bezier() and CatmullRom()).
*
* transform.position = ease(start, distance, elapsedTime, duration);
*
* For convenience in configuration you can use the Ease(EaseType) function to
* look up a concrete easing function:
*
* [SerializeField]
* Interpolate.EaseType easeType; // set using Unity's property inspector
* Interpolate.Function ease; // easing of a particular EaseType
* function Awake() {
* ease = Interpolate.Ease(easeType);
* }
*
* @author Fernando Zapata (fernando@cpudreams.com)
* @Traduzione Andrea85cs (andrea85cs@dynematica.it)
*/
//实现老果
public class Interpolate {
/**
* Different methods of easing interpolation.
*/
public enum EaseType {
Linear,
EaseInQuad,
EaseOutQuad,
EaseInOutQuad,
EaseInCubic,
EaseOutCubic,
EaseInOutCubic,
EaseInQuart,
EaseOutQuart,
EaseInOutQuart,
EaseInQuint,
EaseOutQuint,
EaseInOutQuint,
EaseInSine,
EaseOutSine,
EaseInOutSine,
EaseInExpo,
EaseOutExpo,
EaseInOutExpo,
EaseInCirc,
EaseOutCirc,
EaseInOutCirc
}
/**
* Sequence of eleapsedTimes until elapsedTime is >= duration.
*
* Note: elapsedTimes are calculated using the value of Time.deltatTime each
* time a value is requested.
*/
static Vector3 Identity(Vector3 v) {
return v;
}
static Vector3 TransformDotPosition(Transform t) {
return t.position;
}
static IEnumerable<float> NewTimer(float duration) {
float elapsedTime = 0.0f;
while (elapsedTime < duration) {
yield return elapsedTime;
elapsedTime += Time.deltaTime;
// make sure last value is never skipped
if (elapsedTime >= duration) {
yield return elapsedTime;
}
}
}
public delegate Vector3 ToVector3<T>(T v);
public delegate float Function(float a, float b, float c, float d);
/**
* Generates sequence of integers from start to end (inclusive) one step
* at a time.
*/
static IEnumerable<float> NewCounter(int start, int end, int step) {
for (int i = start; i <= end; i += step) {
yield return i;
}
}
/**
* Returns sequence generator from start to end over duration using the
* given easing function. The sequence is generated as it is accessed
* using the Time.deltaTime to calculate the portion of duration that has
* elapsed.
*/
public static IEnumerator NewEase(Function ease, Vector3 start, Vector3 end, float duration) {
IEnumerable<float> timer = Interpolate.NewTimer(duration);
return NewEase(ease, start, end, duration, timer);
}
/**
* Instead of easing based on time, generate n interpolated points (slices)
* between the start and end positions.
*/
public static IEnumerator NewEase(Function ease, Vector3 start, Vector3 end, int slices) {
IEnumerable<float> counter = Interpolate.NewCounter(0, slices + 1, 1);
return NewEase(ease, start, end, slices + 1, counter);
}
/**
* Generic easing sequence generator used to implement the time and
* slice variants. Normally you would not use this function directly.
*/
static IEnumerator NewEase(Function ease, Vector3 start, Vector3 end, float total, IEnumerable<float> driver) {
Vector3 distance = end - start;
foreach (float i in driver) {
yield return Ease(ease, start, distance, i, total);
}
}
/**
* Vector3 interpolation using given easing method. Easing is done independently
* on all three vector axis.
*/
static Vector3 Ease(Function ease, Vector3 start, Vector3 distance, float elapsedTime, float duration) {
start.x = ease(start.x, distance.x, elapsedTime, duration);
start.y = ease(start.y, distance.y, elapsedTime, duration);
start.z = ease(start.z, distance.z, elapsedTime, duration);
return start;
}
/**
* Returns the static method that implements the given easing type for scalars.
* Use this method to easily switch between easing interpolation types.
*
* All easing methods clamp elapsedTime so that it is always <= duration.
*
* var ease = Interpolate.Ease(EaseType.EaseInQuad);
* i = ease(start, distance, elapsedTime, duration);
*/
public static Function Ease(EaseType type) {
// Source Flash easing functions:
// http://gizma.com/easing/
// http://www.robertpenner.com/easing/easing_demo.html
//
// Changed to use more friendly variable names, that follow my Lerp
// conventions:
// start = b (start value)
// distance = c (change in value)
// elapsedTime = t (current time)
// duration = d (time duration)
Function f = null;
switch (type) {
case EaseType.Linear: f = Interpolate.Linear; break;
case EaseType.EaseInQuad: f = Interpolate.EaseInQuad; break;
case EaseType.EaseOutQuad: f = Interpolate.EaseOutQuad; break;
case EaseType.EaseInOutQuad: f = Interpolate.EaseInOutQuad; break;
case EaseType.EaseInCubic: f = Interpolate.EaseInCubic; break;
case EaseType.EaseOutCubic: f = Interpolate.EaseOutCubic; break;
case EaseType.EaseInOutCubic: f = Interpolate.EaseInOutCubic; break;
case EaseType.EaseInQuart: f = Interpolate.EaseInQuart; break;
case EaseType.EaseOutQuart: f = Interpolate.EaseOutQuart; break;
case EaseType.EaseInOutQuart: f = Interpolate.EaseInOutQuart; break;
case EaseType.EaseInQuint: f = Interpolate.EaseInQuint; break;
case EaseType.EaseOutQuint: f = Interpolate.EaseOutQuint; break;
case EaseType.EaseInOutQuint: f = Interpolate.EaseInOutQuint; break;
case EaseType.EaseInSine: f = Interpolate.EaseInSine; break;
case EaseType.EaseOutSine: f = Interpolate.EaseOutSine; break;
case EaseType.EaseInOutSine: f = Interpolate.EaseInOutSine; break;
case EaseType.EaseInExpo: f = Interpolate.EaseInExpo; break;
case EaseType.EaseOutExpo: f = Interpolate.EaseOutExpo; break;
case EaseType.EaseInOutExpo: f = Interpolate.EaseInOutExpo; break;
case EaseType.EaseInCirc: f = Interpolate.EaseInCirc; break;
case EaseType.EaseOutCirc: f = Interpolate.EaseOutCirc; break;
case EaseType.EaseInOutCirc: f = Interpolate.EaseInOutCirc; break;
}
return f;
}
/**
* Returns sequence generator from the first node to the last node over
* duration time using the points in-between the first and last node
* as control points of a bezier curve used to generate the interpolated points
* in the sequence. If there are no control points (ie. only two nodes, first
* and last) then this behaves exactly the same as NewEase(). In other words
* a zero-degree bezier spline curve is just the easing method. The sequence
* is generated as it is accessed using the Time.deltaTime to calculate the
* portion of duration that has elapsed.
*/
public static IEnumerable<Vector3> NewBezier(Function ease, Transform[] nodes, float duration) {
IEnumerable<float> timer = Interpolate.NewTimer(duration);
return NewBezier<Transform>(ease, nodes, TransformDotPosition, duration, timer);
}
/**
* Instead of interpolating based on time, generate n interpolated points
* (slices) between the first and last node.
*/
public static IEnumerable<Vector3> NewBezier(Function ease, Transform[] nodes, int slices) {
IEnumerable<float> counter = NewCounter(0, slices + 1, 1);
return NewBezier<Transform>(ease, nodes, TransformDotPosition, slices + 1, counter);
}
/**
* A Vector3[] variation of the Transform[] NewBezier() function.
* Same functionality but using Vector3s to define bezier curve.
*/
public static IEnumerable<Vector3> NewBezier(Function ease, Vector3[] points, float duration) {
IEnumerable<float> timer = NewTimer(duration);
return NewBezier<Vector3>(ease, points, Identity, duration, timer);
}
/**
* A Vector3[] variation of the Transform[] NewBezier() function.
* Same functionality but using Vector3s to define bezier curve.
*/
public static IEnumerable<Vector3> NewBezier(Function ease, Vector3[] points, int slices) {
IEnumerable<float> counter = NewCounter(0, slices + 1, 1);
return NewBezier<Vector3>(ease, points, Identity, slices + 1, counter);
}
/**
* Generic bezier spline sequence generator used to implement the time and
* slice variants. Normally you would not use this function directly.
*/
static IEnumerable<Vector3> NewBezier<T>(Function ease, IList nodes, ToVector3<T> toVector3, float maxStep, IEnumerable<float> steps) {
// need at least two nodes to spline between
if (nodes.Count >= 2) {
// copy nodes array since Bezier is destructive
Vector3[] points = new Vector3[nodes.Count];
foreach (float step in steps) {
// re-initialize copy before each destructive call to Bezier
for (int i = 0; i < nodes.Count; i++) {
points[i] = toVector3((T)nodes[i]);
}
yield return Bezier(ease, points, step, maxStep);
// make sure last value is always generated
}
}
}
/**
* A Vector3 n-degree bezier spline.
*
* WARNING: The points array is modified by Bezier. See NewBezier() for a
* safe and user friendly alternative.
*
* You can pass zero control points, just the start and end points, for just
* plain easing. In other words a zero-degree bezier spline curve is just the
* easing method.
*
* @param points start point, n control points, end point
*/
static Vector3 Bezier(Function ease, Vector3[] points, float elapsedTime, float duration) {
// Reference: http://ibiblio.org/e-notes/Splines/Bezier.htm
// Interpolate the n starting points to generate the next j = (n - 1) points,
// then interpolate those n - 1 points to generate the next n - 2 points,
// continue this until we have generated the last point (n - (n - 1)), j = 1.
// We store the next set of output points in the same array as the
// input points used to generate them. This works because we store the
// result in the slot of the input point that is no longer used for this
// iteration.
for (int j = points.Length - 1; j > 0; j--) {
for (int i = 0; i < j; i++) {
points[i].x = ease(points[i].x, points[i + 1].x - points[i].x, elapsedTime, duration);
points[i].y = ease(points[i].y, points[i + 1].y - points[i].y, elapsedTime, duration);
points[i].z = ease(points[i].z, points[i + 1].z - points[i].z, elapsedTime, duration);
}
}
return points[0];
}
/**
* Returns sequence generator from the first node, through each control point,
* and to the last node. N points are generated between each node (slices)
* using Catmull-Rom.
*/
public static IEnumerable<Vector3> NewCatmullRom(Transform[] nodes, int slices, bool loop) {
return NewCatmullRom<Transform>(nodes, TransformDotPosition, slices, loop);
}
/**
* A Vector3[] variation of the Transform[] NewCatmullRom() function.
* Same functionality but using Vector3s to define curve.
*/
public static IEnumerable<Vector3> NewCatmullRom(Vector3[] points, int slices, bool loop) {
return NewCatmullRom<Vector3>(points, Identity, slices, loop);
}
/**
* Generic catmull-rom spline sequence generator used to implement the
* Vector3[] and Transform[] variants. Normally you would not use this
* function directly.
*/
static IEnumerable<Vector3> NewCatmullRom<T>(IList nodes, ToVector3<T> toVector3, int slices, bool loop) {
// need at least two nodes to spline between
if (nodes.Count >= 2) {
// yield the first point explicitly, if looping the first point
// will be generated again in the step for loop when interpolating
// from last point back to the first point
yield return toVector3((T)nodes[0]);
int last = nodes.Count - 1;
for (int current = 0; loop || current < last; current++) {
// wrap around when looping
if (loop && current > last) {
current = 0;
}
// handle edge cases for looping and non-looping scenarios
// when looping we wrap around, when not looping use start for previous
// and end for next when you at the ends of the nodes array
int previous = (current == 0) ? ((loop) ? last : current) : current - 1;
int start = current;
int end = (current == last) ? ((loop) ? 0 : current) : current + 1;
int next = (end == last) ? ((loop) ? 0 : end) : end + 1;
// adding one guarantees yielding at least the end point
int stepCount = slices + 1;
for (int step = 1; step <= stepCount; step++) {
yield return CatmullRom(toVector3((T)nodes[previous]),
toVector3((T)nodes[start]),
toVector3((T)nodes[end]),
toVector3((T)nodes[next]),
step, stepCount);
}
}
}
}
/**
* A Vector3 Catmull-Rom spline. Catmull-Rom splines are similar to bezier
* splines but have the useful property that the generated curve will go
* through each of the control points.
*
* NOTE: The NewCatmullRom() functions are an easier to use alternative to this
* raw Catmull-Rom implementation.
*
* @param previous the point just before the start point or the start point
* itself if no previous point is available
* @param start generated when elapsedTime == 0
* @param end generated when elapsedTime >= duration
* @param next the point just after the end point or the end point itself if no
* next point is available
*/
static Vector3 CatmullRom(Vector3 previous, Vector3 start, Vector3 end, Vector3 next,
float elapsedTime, float duration) {
// References used:
// p.266 GemsV1
//
// tension is often set to 0.5 but you can use any reasonable value:
// http://www.cs.cmu.edu/~462/projects/assn2/assn2/catmullRom.pdf
//
// bias and tension controls:
// http://local.wasp.uwa.edu.au/~pbourke/miscellaneous/interpolation/
float percentComplete = elapsedTime / duration;
float percentCompleteSquared = percentComplete * percentComplete;
float percentCompleteCubed = percentCompleteSquared * percentComplete;
return previous * (-0.5f * percentCompleteCubed +
percentCompleteSquared -
0.5f * percentComplete) +
start * ( 1.5f * percentCompleteCubed +
-2.5f * percentCompleteSquared + 1.0f) +
end * (-1.5f * percentCompleteCubed +
2.0f * percentCompleteSquared +
0.5f * percentComplete) +
next * ( 0.5f * percentCompleteCubed -
0.5f * percentCompleteSquared);
}
/**
* Linear interpolation (same as Mathf.Lerp)
*/
static float Linear(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime to be <= duration
if (elapsedTime > duration) { elapsedTime = duration; }
return distance * (elapsedTime / duration) + start;
}
/**
* quadratic easing in - accelerating from zero velocity
*/
static float EaseInQuad(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 1.0f : elapsedTime / duration;
return distance * elapsedTime * elapsedTime + start;
}
/**
* quadratic easing out - decelerating to zero velocity
*/
static float EaseOutQuad(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 1.0f : elapsedTime / duration;
return -distance * elapsedTime * (elapsedTime - 2) + start;
}
/**
* quadratic easing in/out - acceleration until halfway, then deceleration
*/
static float EaseInOutQuad(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 2.0f : elapsedTime / (duration / 2);
if (elapsedTime < 1) return distance / 2 * elapsedTime * elapsedTime + start;
elapsedTime--;
return -distance / 2 * (elapsedTime * (elapsedTime - 2) - 1) + start;
}
/**
* cubic easing in - accelerating from zero velocity
*/
static float EaseInCubic(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 1.0f : elapsedTime / duration;
return distance * elapsedTime * elapsedTime * elapsedTime + start;
}
/**
* cubic easing out - decelerating to zero velocity
*/
static float EaseOutCubic(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 1.0f : elapsedTime / duration;
elapsedTime--;
return distance * (elapsedTime * elapsedTime * elapsedTime + 1) + start;
}
/**
* cubic easing in/out - acceleration until halfway, then deceleration
*/
static float EaseInOutCubic(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 2.0f : elapsedTime / (duration / 2);
if (elapsedTime < 1) return distance / 2 * elapsedTime * elapsedTime * elapsedTime + start;
elapsedTime -= 2;
return distance / 2 * (elapsedTime * elapsedTime * elapsedTime + 2) + start;
}
/**
* quartic easing in - accelerating from zero velocity
*/
static float EaseInQuart(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 1.0f : elapsedTime / duration;
return distance * elapsedTime * elapsedTime * elapsedTime * elapsedTime + start;
}
/**
* quartic easing out - decelerating to zero velocity
*/
static float EaseOutQuart(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 1.0f : elapsedTime / duration;
elapsedTime--;
return -distance * (elapsedTime * elapsedTime * elapsedTime * elapsedTime - 1) + start;
}
/**
* quartic easing in/out - acceleration until halfway, then deceleration
*/
static float EaseInOutQuart(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 2.0f : elapsedTime / (duration / 2);
if (elapsedTime < 1) return distance / 2 * elapsedTime * elapsedTime * elapsedTime * elapsedTime + start;
elapsedTime -= 2;
return -distance / 2 * (elapsedTime * elapsedTime * elapsedTime * elapsedTime - 2) + start;
}
/**
* quintic easing in - accelerating from zero velocity
*/
static float EaseInQuint(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 1.0f : elapsedTime / duration;
return distance * elapsedTime * elapsedTime * elapsedTime * elapsedTime * elapsedTime + start;
}
/**
* quintic easing out - decelerating to zero velocity
*/
static float EaseOutQuint(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 1.0f : elapsedTime / duration;
elapsedTime--;
return distance * (elapsedTime * elapsedTime * elapsedTime * elapsedTime * elapsedTime + 1) + start;
}
/**
* quintic easing in/out - acceleration until halfway, then deceleration
*/
static float EaseInOutQuint(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 2.0f : elapsedTime / (duration / 2f);
if (elapsedTime < 1) return distance / 2 * elapsedTime * elapsedTime * elapsedTime * elapsedTime * elapsedTime + start;
elapsedTime -= 2;
return distance / 2 * (elapsedTime * elapsedTime * elapsedTime * elapsedTime * elapsedTime + 2) + start;
}
/**
* sinusoidal easing in - accelerating from zero velocity
*/
static float EaseInSine(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime to be <= duration
if (elapsedTime > duration) { elapsedTime = duration; }
return -distance * Mathf.Cos(elapsedTime / duration * (Mathf.PI / 2)) + distance + start;
}
/**
* sinusoidal easing out - decelerating to zero velocity
*/
static float EaseOutSine(float start, float distance, float elapsedTime, float duration) {
if (elapsedTime > duration) { elapsedTime = duration; }
return distance * Mathf.Sin(elapsedTime / duration * (Mathf.PI / 2)) + start;
}
/**
* sinusoidal easing in/out - accelerating until halfway, then decelerating
*/
static float EaseInOutSine(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime to be <= duration
if (elapsedTime > duration) { elapsedTime = duration; }
return -distance / 2 * (Mathf.Cos(Mathf.PI * elapsedTime / duration) - 1) + start;
}
/**
* exponential easing in - accelerating from zero velocity
*/
static float EaseInExpo(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime to be <= duration
if (elapsedTime > duration) { elapsedTime = duration; }
return distance * Mathf.Pow(2, 10 * (elapsedTime / duration - 1)) + start;
}
/**
* exponential easing out - decelerating to zero velocity
*/
static float EaseOutExpo(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime to be <= duration
if (elapsedTime > duration) { elapsedTime = duration; }
return distance * (-Mathf.Pow(2, -10 * elapsedTime / duration) + 1) + start;
}
/**
* exponential easing in/out - accelerating until halfway, then decelerating
*/
static float EaseInOutExpo(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 2.0f : elapsedTime / (duration / 2);
if (elapsedTime < 1) return distance / 2 * Mathf.Pow(2, 10 * (elapsedTime - 1)) + start;
elapsedTime--;
return distance / 2 * (-Mathf.Pow(2, -10 * elapsedTime) + 2) + start;
}
/**
* circular easing in - accelerating from zero velocity
*/
static float EaseInCirc(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 1.0f : elapsedTime / duration;
return -distance * (Mathf.Sqrt(1 - elapsedTime * elapsedTime) - 1) + start;
}
/**
* circular easing out - decelerating to zero velocity
*/
static float EaseOutCirc(float start, float distance, float elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 1.0f : elapsedTime / duration;
elapsedTime--;
return distance * Mathf.Sqrt(1 - elapsedTime * elapsedTime) + start;
}
/**
* circular easing in/out - acceleration until halfway, then deceleration
*/
static float EaseInOutCirc(float start, float distance, float
elapsedTime, float duration) {
// clamp elapsedTime so that it cannot be greater than duration
elapsedTime = (elapsedTime > duration) ? 2.0f : elapsedTime / (duration / 2);
if (elapsedTime < 1) return -distance / 2 * (Mathf.Sqrt(1 - elapsedTime * elapsedTime) - 1) + start;
elapsedTime -= 2;
return distance / 2 * (Mathf.Sqrt(1 - elapsedTime * elapsedTime) + 1) + start;
}
}