public static Quaternion Lerp(Quaternion a, Quaternion b, float t, EASE i)
{
if (i == EASE.ElasticEaseIn || i == EASE.ElasticEaseInOut || i == EASE.ElasticEaseOut ||
i == EASE.BackEaseIn || i == EASE.BackEaseInOut || i == EASE.BackEaseOut)
{
return(LerpUnclamped(a, b, t, i));
}
return(Quaternion.Lerp(a, b, Interpolate(t, i)));
}
public static double Lerp(double a, double b, float t, EASE i)
{
if (i == EASE.ElasticEaseIn || i == EASE.ElasticEaseInOut || i == EASE.ElasticEaseOut ||
i == EASE.BackEaseIn || i == EASE.BackEaseInOut || i == EASE.BackEaseOut)
{
return(LerpUnclamped(a, b, t, i));
}
return(DoubleLerp(a, b, Mathf.Clamp01(Interpolate(t, i))));
}
public static Color Lerp(Color a, Color b, float t, EASE i)
{
if (i == EASE.ElasticEaseIn || i == EASE.ElasticEaseInOut || i == EASE.ElasticEaseOut ||
i == EASE.BackEaseIn || i == EASE.BackEaseInOut || i == EASE.BackEaseOut)
{
return(LerpUnclamped(a, b, t, i));
}
return(Color.Lerp(a, b, Interpolate(t, i)));
}
public static int Lerp(int a, int b, float t, EASE i)
{
if (i == EASE.ElasticEaseIn || i == EASE.ElasticEaseInOut || i == EASE.ElasticEaseOut ||
i == EASE.BackEaseIn || i == EASE.BackEaseInOut || i == EASE.BackEaseOut)
{
return(LerpUnclamped(a, b, t, i));
}
return(Mathf.FloorToInt(Mathf.Lerp(a, b, Interpolate(t, i))));
}
public static Vector4 Lerp(Vector4 a, Vector4 b, float t, EASE i)
{
if (i == EASE.ElasticEaseIn || i == EASE.ElasticEaseInOut || i == EASE.ElasticEaseOut ||
i == EASE.BackEaseIn || i == EASE.BackEaseInOut || i == EASE.BackEaseOut)
{
return(LerpUnclamped(a, b, t, i));
}
return(Vector4.Lerp(a, b, Interpolate(t, i)));
}
private static IEnumerator LerpCoroutine(Transform target, Vector3 a, Vector3 b, float speed, EASE e, Action startCall, Action EndCall)
{
float t = 0.0f;
startCall();
while (t < 1.0f)
{
t += Time.deltaTime * speed;
target.position = Lerp(a, b, t, e);
yield return(null);
}
EndCall();
}
public static void Lerp(Transform target, Vector3 a, Vector3 b, float speed, EASE e, Action startCall, Action endCall, MonoBehaviour m)
{
m.StartCoroutine(LerpCoroutine(target, a, b, speed, e, startCall, endCall));
}
private static float Interpolate(float t, EASE INTERPOLATION)
{
switch (INTERPOLATION)
{
default:
case EASE.Linear:
return(t);
case EASE.QuadraticEaseOut:
return(QuadraticEaseOut(t));
case EASE.QuadraticEaseIn:
return(QuadraticEaseIn(t));
case EASE.QuadraticEaseInOut:
return(QuadraticEaseInOut(t));
case EASE.CubicEaseIn:
return(CubicEaseIn(t));
case EASE.CubicEaseOut:
return(CubicEaseOut(t));
case EASE.CubicEaseInOut:
return(CubicEaseInOut(t));
case EASE.QuarticEaseIn:
return(QuarticEaseIn(t));
case EASE.QuarticEaseOut:
return(QuarticEaseOut(t));
case EASE.QuarticEaseInOut:
return(QuarticEaseInOut(t));
case EASE.QuinticEaseIn:
return(QuinticEaseIn(t));
case EASE.QuinticEaseOut:
return(QuinticEaseOut(t));
case EASE.QuinticEaseInOut:
return(QuinticEaseInOut(t));
case EASE.SineEaseIn:
return(SineEaseIn(t));
case EASE.SineEaseOut:
return(SineEaseOut(t));
case EASE.SineEaseInOut:
return(SineEaseInOut(t));
case EASE.CircularEaseIn:
return(CircularEaseIn(t));
case EASE.CircularEaseOut:
return(CircularEaseOut(t));
case EASE.CircularEaseInOut:
return(CircularEaseInOut(t));
case EASE.ExponentialEaseIn:
return(ExponentialEaseIn(t));
case EASE.ExponentialEaseOut:
return(ExponentialEaseOut(t));
case EASE.ExponentialEaseInOut:
return(ExponentialEaseInOut(t));
case EASE.ElasticEaseIn:
return(ElasticEaseIn(t));
case EASE.ElasticEaseOut:
return(ElasticEaseOut(t));
case EASE.ElasticEaseInOut:
return(ElasticEaseInOut(t));
case EASE.BackEaseIn:
return(BackEaseIn(t));
case EASE.BackEaseOut:
return(BackEaseOut(t));
case EASE.BackEaseInOut:
return(BackEaseInOut(t));
case EASE.BounceEaseIn:
return(BounceEaseIn(t));
case EASE.BounceEaseOut:
return(BounceEaseOut(t));
case EASE.BounceEaseInOut:
return(BounceEaseInOut(t));
}
}
public static Quaternion LerpUnclamped(Quaternion a, Quaternion b, float t, EASE i)
{
return(Quaternion.LerpUnclamped(a, b, Interpolate(t, i)));
}
public static Vector4 LerpUnclamped(Vector4 a, Vector4 b, float t, EASE i)
{
return(Vector4.LerpUnclamped(a, b, Interpolate(t, i)));
}
public static Color LerpUnclamped(Color a, Color b, float t, EASE i)
{
return(Color.LerpUnclamped(a, b, Interpolate(t, i)));
}
public static float InverseLerp(float a, float b, float value, EASE i)
{
return(Interpolate(Mathf.InverseLerp(a, b, value), i));
}
public static float LerpAngle(float a, float b, float t, EASE i)
{
return(Mathf.LerpAngle(a, b, Interpolate(t, i)));
}
public static float LerpUnclamped(float a, float b, float t, EASE i)
{
return(Mathf.LerpUnclamped(a, b, Interpolate(t, i)));
}
public static double InverseLerp(double a, double b, float value, EASE i)
{
return(InverseDoubleLerp(a, b, Interpolate(value, i)));
}
public static double LerpUnclamped(double a, double b, float t, EASE i)
{
return(DoubleLerp(a, b, Interpolate(t, i)));
}
public static int LerpUnclamped(int a, int b, float t, EASE i)
{
return(Mathf.FloorToInt(Mathf.LerpUnclamped(a, b, Interpolate(t, i))));
}
public static int InverseLerp(int a, int b, float value, EASE i)
{
return(Mathf.FloorToInt(Interpolate(Mathf.InverseLerp(a, b, value), i)));
}
