You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1175 lines
27 KiB
1175 lines
27 KiB
using UnityEngine;
|
|
using System.Collections;
|
|
|
|
public static class Ease
|
|
{
|
|
[System.Serializable]
|
|
public enum Easing
|
|
{
|
|
Linear,
|
|
|
|
InQuad,
|
|
OutQuad,
|
|
InOutQuad,
|
|
OutInQuad,
|
|
|
|
InCubic,
|
|
OutCubic,
|
|
InOutCubic,
|
|
OutInCubic,
|
|
|
|
InQuart,
|
|
OutQuart,
|
|
InOutQuart,
|
|
OutInQuart,
|
|
|
|
InQuint,
|
|
OutQuint,
|
|
InOutQuint,
|
|
OutInQuint,
|
|
|
|
InSin,
|
|
OutSin,
|
|
InOutSin,
|
|
OutInSin,
|
|
|
|
InExp,
|
|
OutExp,
|
|
InOutExp,
|
|
OutInExp,
|
|
|
|
InCirc,
|
|
OutCirc,
|
|
InOutCirc,
|
|
OutInCirc,
|
|
|
|
InElastic,
|
|
OutElastic,
|
|
InOutElastic,
|
|
OutInElastic,
|
|
|
|
InBounce,
|
|
OutBounce,
|
|
InOutBounce,
|
|
OutInBounce,
|
|
|
|
InBack,
|
|
OutBack,
|
|
InOutBack,
|
|
OutInBack
|
|
}
|
|
|
|
public static float EaseByType(Easing e, float start, float end, float t)
|
|
{
|
|
switch(e)
|
|
{
|
|
case Easing.Linear: return Linear(start, end, t);
|
|
|
|
case Easing.InQuad: return InQuad(start, end, t);
|
|
case Easing.OutQuad: return OutQuad(start, end, t);
|
|
case Easing.InOutQuad: return InOutQuad(start, end, t);
|
|
case Easing.OutInQuad: return OutInQuad(start, end, t);
|
|
|
|
case Easing.InCubic: return InCubic(start, end, t);
|
|
case Easing.OutCubic: return OutCubic(start, end, t);
|
|
case Easing.InOutCubic: return InOutCubic(start, end, t);
|
|
case Easing.OutInCubic: return OutInCubic(start, end, t);
|
|
|
|
case Easing.InQuart: return InQuart(start, end, t);
|
|
case Easing.OutQuart: return OutQuart(start, end, t);
|
|
case Easing.InOutQuart: return InOutQuart(start, end, t);
|
|
case Easing.OutInQuart: return OutInQuart(start, end, t);
|
|
|
|
case Easing.InQuint: return InQuint(start, end, t);
|
|
case Easing.OutQuint: return OutQuint(start, end, t);
|
|
case Easing.InOutQuint: return InOutQuint(start, end, t);
|
|
case Easing.OutInQuint: return OutInQuint(start, end, t);
|
|
|
|
case Easing.InSin: return InSin(start, end, t);
|
|
case Easing.OutSin: return OutSin(start, end, t);
|
|
case Easing.InOutSin: return InOutSin(start, end, t);
|
|
case Easing.OutInSin: return OutInSin(start, end, t);
|
|
|
|
case Easing.InExp: return InExp(start, end, t);
|
|
case Easing.OutExp: return OutExp(start, end, t);
|
|
case Easing.InOutExp: return InOutExp(start, end, t);
|
|
case Easing.OutInExp: return OutInExp(start, end, t);
|
|
|
|
case Easing.InCirc: return InCirc(start, end, t);
|
|
case Easing.OutCirc: return OutCirc(start, end, t);
|
|
case Easing.InOutCirc: return InOutCirc(start, end, t);
|
|
case Easing.OutInCirc: return OutInCirc(start, end, t);
|
|
|
|
case Easing.InElastic: return InElastic(start, end, t);
|
|
case Easing.OutElastic: return OutElastic(start, end, t);
|
|
case Easing.InOutElastic: return InOutElastic(start, end, t);
|
|
case Easing.OutInElastic: return OutInElastic(start, end, t);
|
|
|
|
case Easing.InBounce: return InBounce(start, end, t);
|
|
case Easing.OutBounce: return OutBounce(start, end, t);
|
|
case Easing.InOutBounce: return InOutBounce(start, end, t);
|
|
case Easing.OutInBounce: return OutInBounce(start, end, t);
|
|
|
|
case Easing.InBack: return InBack(start, end, t);
|
|
case Easing.OutBack: return OutBack(start, end, t);
|
|
case Easing.InOutBack: return InOutBack(start, end, t);
|
|
case Easing.OutInBack: return OutInBack(start, end, t);
|
|
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
public static float Linear(float start, float end, float t)
|
|
{
|
|
return t * (end - start) + start;
|
|
}
|
|
|
|
public static float InQuad(float start, float end, float t)
|
|
{
|
|
return t * t * (end - start) + start;
|
|
}
|
|
|
|
public static float OutQuad(float start, float end, float t)
|
|
{
|
|
return - (t * (t - 2)) * (end - start) + start;
|
|
}
|
|
|
|
public static float InOutQuad(float start, float end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return 0.5f * t * t * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return -0.5f * (t * (t - 2) - 1) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float OutInQuad(float start, float end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return (-0.5f * (t * (t - 2) - 1) - 0.5f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (0.5f * t * t + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float InCubic(float start, float end, float t)
|
|
{
|
|
return t * t * t * (end - start) + start;
|
|
}
|
|
|
|
public static float OutCubic(float start, float end, float t)
|
|
{
|
|
--t;
|
|
return (t * t * t + 1) * (end - start) + start;
|
|
}
|
|
|
|
public static float InOutCubic(float start, float end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return 0.5f * t * t * t * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t-= 2;
|
|
return 0.5f * (t * t * t + 2) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float OutInCubic(float start, float end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
--t;
|
|
return (0.5f * (t * t * t + 2) - 0.5f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (0.5f * t * t * t + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float InQuart(float start, float end, float t)
|
|
{
|
|
return t * t * t * t * (end - start) + start;
|
|
}
|
|
|
|
public static float OutQuart(float start, float end, float t)
|
|
{
|
|
--t;
|
|
return -(t * t * t * t - 1) * (end - start) + start;
|
|
}
|
|
|
|
public static float InOutQuart(float start, float end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return 0.5f * t * t * t * t * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2;
|
|
return -0.5f * (t * t * t * t - 2) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float OutInQuart(float start, float end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
--t;
|
|
return (-0.5f * t * t * t * t + 0.5f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (0.5f * t * t * t * t + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float InQuint(float start, float end, float t)
|
|
{
|
|
return t * t * t * t * t * (end - start) + start;
|
|
}
|
|
|
|
public static float OutQuint(float start, float end, float t)
|
|
{
|
|
--t;
|
|
return (t * t * t * t * t + 1) * (end - start) + start;
|
|
}
|
|
|
|
public static float InOutQuint(float start, float end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return (0.5f * t * t * t * t * t) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2;
|
|
return (0.5f * t * t * t * t * t + 1) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float OutInQuint(float start, float end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
--t;
|
|
return (0.5f * (t * t * t * t * t) + 0.5f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (0.5f * t * t * t * t * t + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float InSin(float start, float end, float t)
|
|
{
|
|
return -Mathf.Cos(t * Mathf.PI * 0.5f) * (end - start) + end;
|
|
}
|
|
|
|
public static float OutSin(float start, float end, float t)
|
|
{
|
|
return Mathf.Sin(t * Mathf.PI * 0.5f) * (end - start) + start;
|
|
}
|
|
|
|
public static float InOutSin(float start, float end, float t)
|
|
{
|
|
return (-0.5f * Mathf.Cos(t * Mathf.PI) + 0.5f) * (end - start) + start;
|
|
}
|
|
|
|
public static float OutInSin(float start, float end, float t)
|
|
{
|
|
return (t - (-0.5f * Mathf.Cos(t * Mathf.PI) + 0.5f - t)) * (end - start) + start;
|
|
}
|
|
|
|
public static float InExp(float start, float end, float t)
|
|
{
|
|
return Mathf.Pow(2, 10 * (t - 1)) * (end - start) + start;
|
|
}
|
|
|
|
public static float OutExp(float start, float end, float t)
|
|
{
|
|
return (1 - Mathf.Pow(2, -10 * t)) * (end - start) + start;
|
|
}
|
|
|
|
public static float InOutExp(float start, float end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return 0.5f * Mathf.Pow(2, 10 * (t - 1)) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return 0.5f * (2 - Mathf.Pow(2, -10 * t)) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float OutInExp(float start, float end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return (0.5f * (2 - Mathf.Pow(2, -10 * t)) - 0.5f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (0.5f * Mathf.Pow(2, 10 * (t - 1)) + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float InCirc(float start, float end, float t)
|
|
{
|
|
return -(Mathf.Sqrt(1 - t * t) - 1) * (end - start) + start;
|
|
}
|
|
|
|
public static float OutCirc(float start, float end, float t)
|
|
{
|
|
--t;
|
|
return Mathf.Sqrt(1 - t * t) * (end - start) + start;
|
|
}
|
|
|
|
public static float InOutCirc(float start, float end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return (-0.5f * (Mathf.Sqrt(1 - t * t) - 1)) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2;
|
|
return (0.5f * (Mathf.Sqrt(1 - t * t) + 1)) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float OutInCirc(float start, float end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
--t;
|
|
return (0.5f * Mathf.Sqrt(1 - t * t)) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (-0.5f * Mathf.Sqrt(1 - t * t) + 1) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float InElastic(float start, float end, float t)
|
|
{
|
|
float p = 0.3f, s = 0.075f;
|
|
--t;
|
|
return (-Mathf.Pow(2, 10 * t) * Mathf.Sin((t - s) * (2 * Mathf.PI) / p)) * (end - start) + start;
|
|
}
|
|
|
|
public static float OutElastic(float start, float end, float t)
|
|
{
|
|
float p = 0.3f, s = 0.075f;
|
|
return (Mathf.Pow(2, -10 * t) * Mathf.Sin((t - s) * (2 * Mathf.PI) / p)) * (end - start) + end;
|
|
}
|
|
|
|
public static float InOutElastic(float start, float end, float t)
|
|
{
|
|
float p = 0.3f, s = 0.075f;
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
--t;
|
|
return (-0.5f * Mathf.Pow(2, 10 * t) * Mathf.Sin((t - s) * (2 * Mathf.PI) / p)) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (0.5f * Mathf.Pow(2, -10 * t) * Mathf.Sin((t - s) * (2 * Mathf.PI) / p)) * (end - start) + end;
|
|
}
|
|
}
|
|
|
|
public static float OutInElastic(float start, float end, float t)
|
|
{
|
|
float p = 0.3f, s = 0.075f;
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return (0.5f * Mathf.Pow(2, -10 * t) * Mathf.Sin((t - s) * (2 * Mathf.PI) / p) - 0.5f) * (end - start) + end;
|
|
}
|
|
else
|
|
{
|
|
t -= 2;
|
|
return (-0.5f *Mathf.Pow(2, 10 * t) * Mathf.Sin((t - s) * (2 * Mathf.PI) / p) + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float InBounce(float start, float end, float t)
|
|
{
|
|
|
|
t = 1 - t;
|
|
if(t < 1 / 2.75f)
|
|
{
|
|
return (-7.5625f * t * t + 1) * (end - start) + start;
|
|
}
|
|
else if(t < 2.0f / 2.75f)
|
|
{
|
|
t -= 1.5f / 2.75f;
|
|
return (-7.5625f * t * t - 0.75f + 1) * (end - start) + start;
|
|
}
|
|
else if (t < 2.5f / 2.75f)
|
|
{
|
|
t -= 2.25f / 2.75f;
|
|
return (-7.5625f * t * t - 0.9375f + 1) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2.625f / 2.75f;
|
|
return (-7.5625f * t * t - 0.984375f + 1) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float OutBounce(float start, float end, float t)
|
|
{
|
|
|
|
if(t < 1 / 2.75f)
|
|
{
|
|
return (7.5625f * t * t) * (end - start) + start;
|
|
}
|
|
else if(t < 2.0f / 2.75f)
|
|
{
|
|
t -= 1.5f / 2.75f;
|
|
return (7.5625f * t * t + 0.75f) * (end - start) + start;
|
|
}
|
|
else if (t < 2.5f / 2.75f)
|
|
{
|
|
t -= 2.25f / 2.75f;
|
|
return (7.5625f * t * t + 0.9375f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2.625f / 2.75f;
|
|
return (7.5625f * t * t + 0.984375f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float InOutBounce(float start, float end, float t)
|
|
{
|
|
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
t = 1 - t;
|
|
if(t < 1 / 2.75f)
|
|
{
|
|
return (-0.5f * 7.5625f * t * t + 0.5f) * (end - start) + start;
|
|
}
|
|
else if(t < 2.0f / 2.75f)
|
|
{
|
|
t -= 1.5f / 2.75f;
|
|
return (-0.5f * (7.5625f * t * t + 0.75f) + 0.5f) * (end - start) + start;
|
|
}
|
|
else if (t < 2.5f / 2.75f)
|
|
{
|
|
t -= 2.25f / 2.75f;
|
|
return (-0.5f * (7.5625f * t * t + 0.9375f) + 0.5f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2.625f / 2.75f;
|
|
return (-0.5f * (7.5625f * t * t + 0.984375f) + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
if(t < 1 / 2.75f)
|
|
{
|
|
return (0.5f * 7.5625f * t * t + 0.5f) * (end - start) + start;
|
|
}
|
|
else if(t < 2.0f / 2.75f)
|
|
{
|
|
t -= 1.5f / 2.75f;
|
|
return (0.5f * (7.5625f * t * t + 0.75f) + 0.5f) * (end - start) + start;
|
|
}
|
|
else if (t < 2.5f / 2.75f)
|
|
{
|
|
t -= 2.25f / 2.75f;
|
|
return (0.5f * (7.5625f * t * t + 0.9375f) + 0.5f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2.625f / 2.75f;
|
|
return (0.5f * (7.5625f * t * t + 0.984375f) + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static float OutInBounce(float start, float end, float t)
|
|
{
|
|
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
if(t < 1 / 2.75f)
|
|
{
|
|
return (0.5f * 7.5625f * t * t ) * (end - start) + start;
|
|
}
|
|
else if(t < 2.0f / 2.75f)
|
|
{
|
|
t -= 1.5f / 2.75f;
|
|
return (0.5f * (7.5625f * t * t + 0.75f)) * (end - start) + start;
|
|
}
|
|
else if (t < 2.5f / 2.75f)
|
|
{
|
|
t -= 2.25f / 2.75f;
|
|
return (0.5f * (7.5625f * t * t + 0.9375f)) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2.625f / 2.75f;
|
|
return (0.5f * (7.5625f * t * t + 0.984375f)) * (end - start) + start;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
t = 2 - t;
|
|
if(t < 1 / 2.75f)
|
|
{
|
|
return (-0.5f * 7.5625f * t * t + 1) * (end - start) + start;
|
|
}
|
|
else if(t < 2.0f / 2.75f)
|
|
{
|
|
t -= 1.5f / 2.75f;
|
|
return (-0.5f * (7.5625f * t * t + 0.75f) + 1) * (end - start) + start;
|
|
}
|
|
else if (t < 2.5f / 2.75f)
|
|
{
|
|
t -= 2.25f / 2.75f;
|
|
return (-0.5f * (7.5625f * t * t + 0.9375f) + 1) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2.625f / 2.75f;
|
|
return (-0.5f * (7.5625f * t * t + 0.984375f) + 1) * (end - start) + start;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static float InBack(float start, float end, float t)
|
|
{
|
|
return t * t * (2.70158f * t - 1.70158f) * (end - start) + start;
|
|
}
|
|
|
|
public static float OutBack(float start, float end, float t)
|
|
{
|
|
--t;
|
|
return (1 - t * t * (-2.70158f * t - 1.70158f)) * (end - start) + start;
|
|
}
|
|
|
|
public static float InOutBack(float start, float end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return (0.5f * t * t * (2.70158f * t - 1.70158f)) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2;
|
|
return (1 - 0.5f * t * t * (-2.70158f * t - 1.70158f)) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static float OutInBack(float start, float end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
--t;
|
|
return (0.5f -0.5f * t * t * (-2.70158f * t - 1.70158f)) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (0.5f * t * t * (2.70158f * t - 1.70158f) + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 EaseByType(Easing e, Vector3 start, Vector3 end, float t)
|
|
{
|
|
switch(e)
|
|
{
|
|
case Easing.Linear: return Linear(start, end, t);
|
|
|
|
case Easing.InQuad: return InQuad(start, end, t);
|
|
case Easing.OutQuad: return OutQuad(start, end, t);
|
|
case Easing.InOutQuad: return InOutQuad(start, end, t);
|
|
case Easing.OutInQuad: return OutInQuad(start, end, t);
|
|
|
|
case Easing.InCubic: return InCubic(start, end, t);
|
|
case Easing.OutCubic: return OutCubic(start, end, t);
|
|
case Easing.InOutCubic: return InOutCubic(start, end, t);
|
|
case Easing.OutInCubic: return OutInCubic(start, end, t);
|
|
|
|
case Easing.InQuart: return InQuart(start, end, t);
|
|
case Easing.OutQuart: return OutQuart(start, end, t);
|
|
case Easing.InOutQuart: return InOutQuart(start, end, t);
|
|
case Easing.OutInQuart: return OutInQuart(start, end, t);
|
|
|
|
case Easing.InQuint: return InQuint(start, end, t);
|
|
case Easing.OutQuint: return OutQuint(start, end, t);
|
|
case Easing.InOutQuint: return InOutQuint(start, end, t);
|
|
case Easing.OutInQuint: return OutInQuint(start, end, t);
|
|
|
|
case Easing.InSin: return InSin(start, end, t);
|
|
case Easing.OutSin: return OutSin(start, end, t);
|
|
case Easing.InOutSin: return InOutSin(start, end, t);
|
|
case Easing.OutInSin: return OutInSin(start, end, t);
|
|
|
|
case Easing.InExp: return InExp(start, end, t);
|
|
case Easing.OutExp: return OutExp(start, end, t);
|
|
case Easing.InOutExp: return InOutExp(start, end, t);
|
|
case Easing.OutInExp: return OutInExp(start, end, t);
|
|
|
|
case Easing.InCirc: return InCirc(start, end, t);
|
|
case Easing.OutCirc: return OutCirc(start, end, t);
|
|
case Easing.InOutCirc: return InOutCirc(start, end, t);
|
|
case Easing.OutInCirc: return OutInCirc(start, end, t);
|
|
|
|
case Easing.InElastic: return InElastic(start, end, t);
|
|
case Easing.OutElastic: return OutElastic(start, end, t);
|
|
case Easing.InOutElastic: return InOutElastic(start, end, t);
|
|
case Easing.OutInElastic: return OutInElastic(start, end, t);
|
|
|
|
case Easing.InBounce: return InBounce(start, end, t);
|
|
case Easing.OutBounce: return OutBounce(start, end, t);
|
|
case Easing.InOutBounce: return InOutBounce(start, end, t);
|
|
case Easing.OutInBounce: return OutInBounce(start, end, t);
|
|
|
|
case Easing.InBack: return InBack(start, end, t);
|
|
case Easing.OutBack: return OutBack(start, end, t);
|
|
case Easing.InOutBack: return InOutBack(start, end, t);
|
|
case Easing.OutInBack: return OutInBack(start, end, t);
|
|
|
|
default: return Vector3.zero;
|
|
}
|
|
}
|
|
|
|
public static Vector3 Linear(Vector3 start, Vector3 end, float t)
|
|
{
|
|
return t * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 InQuad(Vector3 start, Vector3 end, float t)
|
|
{
|
|
return t * t * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 OutQuad(Vector3 start, Vector3 end, float t)
|
|
{
|
|
return - (t * (t - 2)) * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 InOutQuad(Vector3 start, Vector3 end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return 0.5f * t * t * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return -0.5f * (t * (t - 2) - 1) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 OutInQuad(Vector3 start, Vector3 end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return (-0.5f * (t * (t - 2) - 1) - 0.5f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (0.5f * t * t + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 InCubic(Vector3 start, Vector3 end, float t)
|
|
{
|
|
return t * t * t * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 OutCubic(Vector3 start, Vector3 end, float t)
|
|
{
|
|
--t;
|
|
return (t * t * t + 1) * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 InOutCubic(Vector3 start, Vector3 end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return 0.5f * t * t * t * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t-= 2;
|
|
return 0.5f * (t * t * t + 2) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 OutInCubic(Vector3 start, Vector3 end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
--t;
|
|
return (0.5f * (t * t * t + 2) - 0.5f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (0.5f * t * t * t + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 InQuart(Vector3 start, Vector3 end, float t)
|
|
{
|
|
return t * t * t * t * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 OutQuart(Vector3 start, Vector3 end, float t)
|
|
{
|
|
--t;
|
|
return -(t * t * t * t - 1) * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 InOutQuart(Vector3 start, Vector3 end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return 0.5f * t * t * t * t * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2;
|
|
return -0.5f * (t * t * t * t - 2) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 OutInQuart(Vector3 start, Vector3 end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
--t;
|
|
return (-0.5f * t * t * t * t + 0.5f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (0.5f * t * t * t * t + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 InQuint(Vector3 start, Vector3 end, float t)
|
|
{
|
|
return t * t * t * t * t * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 OutQuint(Vector3 start, Vector3 end, float t)
|
|
{
|
|
--t;
|
|
return (t * t * t * t * t + 1) * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 InOutQuint(Vector3 start, Vector3 end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return (0.5f * t * t * t * t * t) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2;
|
|
return (0.5f * t * t * t * t * t + 1) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 OutInQuint(Vector3 start, Vector3 end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
--t;
|
|
return (0.5f * (t * t * t * t * t) + 0.5f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (0.5f * t * t * t * t * t + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 InSin(Vector3 start, Vector3 end, float t)
|
|
{
|
|
return -Mathf.Cos(t * Mathf.PI * 0.5f) * (end - start) + end;
|
|
}
|
|
|
|
public static Vector3 OutSin(Vector3 start, Vector3 end, float t)
|
|
{
|
|
return Mathf.Sin(t * Mathf.PI * 0.5f) * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 InOutSin(Vector3 start, Vector3 end, float t)
|
|
{
|
|
return (-0.5f * Mathf.Cos(t * Mathf.PI) + 0.5f) * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 OutInSin(Vector3 start, Vector3 end, float t)
|
|
{
|
|
return (t - (-0.5f * Mathf.Cos(t * Mathf.PI) + 0.5f - t)) * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 InExp(Vector3 start, Vector3 end, float t)
|
|
{
|
|
return Mathf.Pow(2, 10 * (t - 1)) * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 OutExp(Vector3 start, Vector3 end, float t)
|
|
{
|
|
return (1 - Mathf.Pow(2, -10 * t)) * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 InOutExp(Vector3 start, Vector3 end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return 0.5f * Mathf.Pow(2, 10 * (t - 1)) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return 0.5f * (2 - Mathf.Pow(2, -10 * t)) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 OutInExp(Vector3 start, Vector3 end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return (0.5f * (2 - Mathf.Pow(2, -10 * t)) - 0.5f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (0.5f * Mathf.Pow(2, 10 * (t - 1)) + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 InCirc(Vector3 start, Vector3 end, float t)
|
|
{
|
|
return -(Mathf.Sqrt(1 - t * t) - 1) * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 OutCirc(Vector3 start, Vector3 end, float t)
|
|
{
|
|
--t;
|
|
return Mathf.Sqrt(1 - t * t) * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 InOutCirc(Vector3 start, Vector3 end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return (-0.5f * (Mathf.Sqrt(1 - t * t) - 1)) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2;
|
|
return (0.5f * (Mathf.Sqrt(1 - t * t) + 1)) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 OutInCirc(Vector3 start, Vector3 end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
--t;
|
|
return (0.5f * Mathf.Sqrt(1 - t * t)) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (-0.5f * Mathf.Sqrt(1 - t * t) + 1) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 InElastic(Vector3 start, Vector3 end, float t)
|
|
{
|
|
float p = 0.3f, s = 0.075f;
|
|
--t;
|
|
return (-Mathf.Pow(2, 10 * t) * Mathf.Sin((t - s) * (2 * Mathf.PI) / p)) * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 OutElastic(Vector3 start, Vector3 end, float t)
|
|
{
|
|
float p = 0.3f, s = 0.075f;
|
|
return (Mathf.Pow(2, -10 * t) * Mathf.Sin((t - s) * (2 * Mathf.PI) / p)) * (end - start) + end;
|
|
}
|
|
|
|
public static Vector3 InOutElastic(Vector3 start, Vector3 end, float t)
|
|
{
|
|
float p = 0.3f, s = 0.075f;
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
--t;
|
|
return (-0.5f * Mathf.Pow(2, 10 * t) * Mathf.Sin((t - s) * (2 * Mathf.PI) / p)) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (0.5f * Mathf.Pow(2, -10 * t) * Mathf.Sin((t - s) * (2 * Mathf.PI) / p)) * (end - start) + end;
|
|
}
|
|
}
|
|
|
|
public static Vector3 OutInElastic(Vector3 start, Vector3 end, float t)
|
|
{
|
|
float p = 0.3f, s = 0.075f;
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return (0.5f * Mathf.Pow(2, -10 * t) * Mathf.Sin((t - s) * (2 * Mathf.PI) / p) - 0.5f) * (end - start) + end;
|
|
}
|
|
else
|
|
{
|
|
t -= 2;
|
|
return (-0.5f *Mathf.Pow(2, 10 * t) * Mathf.Sin((t - s) * (2 * Mathf.PI) / p) + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 InBounce(Vector3 start, Vector3 end, float t)
|
|
{
|
|
|
|
t = 1 - t;
|
|
if(t < 1 / 2.75f)
|
|
{
|
|
return (-7.5625f * t * t + 1) * (end - start) + start;
|
|
}
|
|
else if(t < 2.0f / 2.75f)
|
|
{
|
|
t -= 1.5f / 2.75f;
|
|
return (-7.5625f * t * t - 0.75f + 1) * (end - start) + start;
|
|
}
|
|
else if (t < 2.5f / 2.75f)
|
|
{
|
|
t -= 2.25f / 2.75f;
|
|
return (-7.5625f * t * t - 0.9375f + 1) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2.625f / 2.75f;
|
|
return (-7.5625f * t * t - 0.984375f + 1) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 OutBounce(Vector3 start, Vector3 end, float t)
|
|
{
|
|
|
|
if(t < 1 / 2.75f)
|
|
{
|
|
return (7.5625f * t * t) * (end - start) + start;
|
|
}
|
|
else if(t < 2.0f / 2.75f)
|
|
{
|
|
t -= 1.5f / 2.75f;
|
|
return (7.5625f * t * t + 0.75f) * (end - start) + start;
|
|
}
|
|
else if (t < 2.5f / 2.75f)
|
|
{
|
|
t -= 2.25f / 2.75f;
|
|
return (7.5625f * t * t + 0.9375f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2.625f / 2.75f;
|
|
return (7.5625f * t * t + 0.984375f) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 InOutBounce(Vector3 start, Vector3 end, float t)
|
|
{
|
|
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
t = 1 - t;
|
|
if(t < 1 / 2.75f)
|
|
{
|
|
return (-0.5f * 7.5625f * t * t + 0.5f) * (end - start) + start;
|
|
}
|
|
else if(t < 2.0f / 2.75f)
|
|
{
|
|
t -= 1.5f / 2.75f;
|
|
return (-0.5f * (7.5625f * t * t + 0.75f) + 0.5f) * (end - start) + start;
|
|
}
|
|
else if (t < 2.5f / 2.75f)
|
|
{
|
|
t -= 2.25f / 2.75f;
|
|
return (-0.5f * (7.5625f * t * t + 0.9375f) + 0.5f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2.625f / 2.75f;
|
|
return (-0.5f * (7.5625f * t * t + 0.984375f) + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
if(t < 1 / 2.75f)
|
|
{
|
|
return (0.5f * 7.5625f * t * t + 0.5f) * (end - start) + start;
|
|
}
|
|
else if(t < 2.0f / 2.75f)
|
|
{
|
|
t -= 1.5f / 2.75f;
|
|
return (0.5f * (7.5625f * t * t + 0.75f) + 0.5f) * (end - start) + start;
|
|
}
|
|
else if (t < 2.5f / 2.75f)
|
|
{
|
|
t -= 2.25f / 2.75f;
|
|
return (0.5f * (7.5625f * t * t + 0.9375f) + 0.5f) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2.625f / 2.75f;
|
|
return (0.5f * (7.5625f * t * t + 0.984375f) + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static Vector3 OutInBounce(Vector3 start, Vector3 end, float t)
|
|
{
|
|
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
if(t < 1 / 2.75f)
|
|
{
|
|
return (0.5f * 7.5625f * t * t ) * (end - start) + start;
|
|
}
|
|
else if(t < 2.0f / 2.75f)
|
|
{
|
|
t -= 1.5f / 2.75f;
|
|
return (0.5f * (7.5625f * t * t + 0.75f)) * (end - start) + start;
|
|
}
|
|
else if (t < 2.5f / 2.75f)
|
|
{
|
|
t -= 2.25f / 2.75f;
|
|
return (0.5f * (7.5625f * t * t + 0.9375f)) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2.625f / 2.75f;
|
|
return (0.5f * (7.5625f * t * t + 0.984375f)) * (end - start) + start;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
t = 2 - t;
|
|
if(t < 1 / 2.75f)
|
|
{
|
|
return (-0.5f * 7.5625f * t * t + 1) * (end - start) + start;
|
|
}
|
|
else if(t < 2.0f / 2.75f)
|
|
{
|
|
t -= 1.5f / 2.75f;
|
|
return (-0.5f * (7.5625f * t * t + 0.75f) + 1) * (end - start) + start;
|
|
}
|
|
else if (t < 2.5f / 2.75f)
|
|
{
|
|
t -= 2.25f / 2.75f;
|
|
return (-0.5f * (7.5625f * t * t + 0.9375f) + 1) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2.625f / 2.75f;
|
|
return (-0.5f * (7.5625f * t * t + 0.984375f) + 1) * (end - start) + start;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static Vector3 InBack(Vector3 start, Vector3 end, float t)
|
|
{
|
|
return t * t * (2.70158f * t - 1.70158f) * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 OutBack(Vector3 start, Vector3 end, float t)
|
|
{
|
|
--t;
|
|
return (1 - t * t * (-2.70158f * t - 1.70158f)) * (end - start) + start;
|
|
}
|
|
|
|
public static Vector3 InOutBack(Vector3 start, Vector3 end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
return (0.5f * t * t * (2.70158f * t - 1.70158f)) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
t -= 2;
|
|
return (1 - 0.5f * t * t * (-2.70158f * t - 1.70158f)) * (end - start) + start;
|
|
}
|
|
}
|
|
|
|
public static Vector3 OutInBack(Vector3 start, Vector3 end, float t)
|
|
{
|
|
t *= 2;
|
|
if(t < 1)
|
|
{
|
|
--t;
|
|
return (0.5f -0.5f * t * t * (-2.70158f * t - 1.70158f)) * (end - start) + start;
|
|
}
|
|
else
|
|
{
|
|
--t;
|
|
return (0.5f * t * t * (2.70158f * t - 1.70158f) + 0.5f) * (end - start) + start;
|
|
}
|
|
}
|
|
} |