public static float EaseInOut(float time, float duration, float unusedOvershootOrAmplitude, float unusedPeriod) { if (time < duration * 0.5f) { return(Bounce.EaseIn(time * 2f, duration, -1f, -1f) * 0.5f); } return(Bounce.EaseOut(time * 2f - duration, duration, -1f, -1f) * 0.5f + 0.5f); }
public static EaseFunction ToEaseFunction(Ease ease) { switch (ease) { case Ease.Linear: return((float time, float duration, float overshootOrAmplitude, float period) => time / duration); case Ease.InSine: return((float time, float duration, float overshootOrAmplitude, float period) => - (float)Math.Cos((double)(time / duration * 1.57079637f)) + 1f); case Ease.OutSine: return((float time, float duration, float overshootOrAmplitude, float period) => (float)Math.Sin((double)(time / duration * 1.57079637f))); case Ease.InOutSine: return((float time, float duration, float overshootOrAmplitude, float period) => - 0.5f * ((float)Math.Cos((double)(3.14159274f * time / duration)) - 1f)); case Ease.InQuad: return((float time, float duration, float overshootOrAmplitude, float period) => (time /= duration) * time); case Ease.OutQuad: return((float time, float duration, float overshootOrAmplitude, float period) => - (time /= duration) * (time - 2f)); case Ease.InOutQuad: return(delegate(float time, float duration, float overshootOrAmplitude, float period) { if ((time /= duration * 0.5f) < 1f) { return 0.5f * time * time; } return -0.5f * ((time -= 1f) * (time - 2f) - 1f); }); case Ease.InCubic: return((float time, float duration, float overshootOrAmplitude, float period) => (time /= duration) * time * time); case Ease.OutCubic: return((float time, float duration, float overshootOrAmplitude, float period) => (time = time / duration - 1f) * time * time + 1f); case Ease.InOutCubic: return(delegate(float time, float duration, float overshootOrAmplitude, float period) { if ((time /= duration * 0.5f) < 1f) { return 0.5f * time * time * time; } return 0.5f * ((time -= 2f) * time * time + 2f); }); case Ease.InQuart: return((float time, float duration, float overshootOrAmplitude, float period) => (time /= duration) * time * time * time); case Ease.OutQuart: return((float time, float duration, float overshootOrAmplitude, float period) => - ((time = time / duration - 1f) * time * time * time - 1f)); case Ease.InOutQuart: return(delegate(float time, float duration, float overshootOrAmplitude, float period) { if ((time /= duration * 0.5f) < 1f) { return 0.5f * time * time * time * time; } return -0.5f * ((time -= 2f) * time * time * time - 2f); }); case Ease.InQuint: return((float time, float duration, float overshootOrAmplitude, float period) => (time /= duration) * time * time * time * time); case Ease.OutQuint: return((float time, float duration, float overshootOrAmplitude, float period) => (time = time / duration - 1f) * time * time * time * time + 1f); case Ease.InOutQuint: return(delegate(float time, float duration, float overshootOrAmplitude, float period) { if ((time /= duration * 0.5f) < 1f) { return 0.5f * time * time * time * time * time; } return 0.5f * ((time -= 2f) * time * time * time * time + 2f); }); case Ease.InExpo: return(delegate(float time, float duration, float overshootOrAmplitude, float period) { if (time != 0f) { return (float)Math.Pow(2.0, (double)(10f * (time / duration - 1f))); } return 0f; }); case Ease.OutExpo: return(delegate(float time, float duration, float overshootOrAmplitude, float period) { if (time == duration) { return 1f; } return -(float)Math.Pow(2.0, (double)(-10f * time / duration)) + 1f; }); case Ease.InOutExpo: return(delegate(float time, float duration, float overshootOrAmplitude, float period) { if (time == 0f) { return 0f; } if (time == duration) { return 1f; } if ((time /= duration * 0.5f) < 1f) { return 0.5f * (float)Math.Pow(2.0, (double)(10f * (time - 1f))); } return 0.5f * (-(float)Math.Pow(2.0, (double)(-10f * (time -= 1f))) + 2f); }); case Ease.InCirc: return((float time, float duration, float overshootOrAmplitude, float period) => - ((float)Math.Sqrt((double)(1f - (time /= duration) * time)) - 1f)); case Ease.OutCirc: return((float time, float duration, float overshootOrAmplitude, float period) => (float)Math.Sqrt((double)(1f - (time = time / duration - 1f) * time))); case Ease.InOutCirc: return(delegate(float time, float duration, float overshootOrAmplitude, float period) { if ((time /= duration * 0.5f) < 1f) { return -0.5f * ((float)Math.Sqrt((double)(1f - time * time)) - 1f); } return 0.5f * ((float)Math.Sqrt((double)(1f - (time -= 2f) * time)) + 1f); }); case Ease.InElastic: return(delegate(float time, float duration, float overshootOrAmplitude, float period) { if (time == 0f) { return 0f; } if ((time /= duration) == 1f) { return 1f; } if (period == 0f) { period = duration * 0.3f; } float num; if (overshootOrAmplitude < 1f) { overshootOrAmplitude = 1f; num = period / 4f; } else { num = period / 6.28318548f * (float)Math.Asin((double)(1f / overshootOrAmplitude)); } return -(overshootOrAmplitude * (float)Math.Pow(2.0, (double)(10f * (time -= 1f))) * (float)Math.Sin((double)((time * duration - num) * 6.28318548f / period))); }); case Ease.OutElastic: return(delegate(float time, float duration, float overshootOrAmplitude, float period) { if (time == 0f) { return 0f; } if ((time /= duration) == 1f) { return 1f; } if (period == 0f) { period = duration * 0.3f; } float num; if (overshootOrAmplitude < 1f) { overshootOrAmplitude = 1f; num = period / 4f; } else { num = period / 6.28318548f * (float)Math.Asin((double)(1f / overshootOrAmplitude)); } return overshootOrAmplitude * (float)Math.Pow(2.0, (double)(-10f * time)) * (float)Math.Sin((double)((time * duration - num) * 6.28318548f / period)) + 1f; }); case Ease.InOutElastic: return(delegate(float time, float duration, float overshootOrAmplitude, float period) { if (time == 0f) { return 0f; } if ((time /= duration * 0.5f) == 2f) { return 1f; } if (period == 0f) { period = duration * 0.450000018f; } float num; if (overshootOrAmplitude < 1f) { overshootOrAmplitude = 1f; num = period / 4f; } else { num = period / 6.28318548f * (float)Math.Asin((double)(1f / overshootOrAmplitude)); } if (time < 1f) { return -0.5f * (overshootOrAmplitude * (float)Math.Pow(2.0, (double)(10f * (time -= 1f))) * (float)Math.Sin((double)((time * duration - num) * 6.28318548f / period))); } return overshootOrAmplitude * (float)Math.Pow(2.0, (double)(-10f * (time -= 1f))) * (float)Math.Sin((double)((time * duration - num) * 6.28318548f / period)) * 0.5f + 1f; }); case Ease.InBack: return((float time, float duration, float overshootOrAmplitude, float period) => (time /= duration) * time * ((overshootOrAmplitude + 1f) * time - overshootOrAmplitude)); case Ease.OutBack: return((float time, float duration, float overshootOrAmplitude, float period) => (time = time / duration - 1f) * time * ((overshootOrAmplitude + 1f) * time + overshootOrAmplitude) + 1f); case Ease.InOutBack: return(delegate(float time, float duration, float overshootOrAmplitude, float period) { if ((time /= duration * 0.5f) < 1f) { return 0.5f * (time * time * (((overshootOrAmplitude *= 1.525f) + 1f) * time - overshootOrAmplitude)); } return 0.5f * ((time -= 2f) * time * (((overshootOrAmplitude *= 1.525f) + 1f) * time + overshootOrAmplitude) + 2f); }); case Ease.InBounce: return((float time, float duration, float overshootOrAmplitude, float period) => Bounce.EaseIn(time, duration, overshootOrAmplitude, period)); case Ease.OutBounce: return((float time, float duration, float overshootOrAmplitude, float period) => Bounce.EaseOut(time, duration, overshootOrAmplitude, period)); case Ease.InOutBounce: return((float time, float duration, float overshootOrAmplitude, float period) => Bounce.EaseInOut(time, duration, overshootOrAmplitude, period)); default: return((float time, float duration, float overshootOrAmplitude, float period) => - (time /= duration) * (time - 2f)); } }
public static float Evaluate(Ease easeType, EaseFunction customEase, float time, float duration, float overshootOrAmplitude, float period) { switch (easeType) { case Ease.Linear: return(time / duration); case Ease.InSine: return(-(float)Math.Cos((double)(time / duration * 1.57079637f)) + 1f); case Ease.OutSine: return((float)Math.Sin((double)(time / duration * 1.57079637f))); case Ease.InOutSine: return(-0.5f * ((float)Math.Cos((double)(3.14159274f * time / duration)) - 1f)); case Ease.InQuad: return((time /= duration) * time); case Ease.OutQuad: return(-(time /= duration) * (time - 2f)); case Ease.InOutQuad: if ((time /= duration * 0.5f) < 1f) { return(0.5f * time * time); } return(-0.5f * ((time -= 1f) * (time - 2f) - 1f)); case Ease.InCubic: return((time /= duration) * time * time); case Ease.OutCubic: return((time = time / duration - 1f) * time * time + 1f); case Ease.InOutCubic: if ((time /= duration * 0.5f) < 1f) { return(0.5f * time * time * time); } return(0.5f * ((time -= 2f) * time * time + 2f)); case Ease.InQuart: return((time /= duration) * time * time * time); case Ease.OutQuart: return(-((time = time / duration - 1f) * time * time * time - 1f)); case Ease.InOutQuart: if ((time /= duration * 0.5f) < 1f) { return(0.5f * time * time * time * time); } return(-0.5f * ((time -= 2f) * time * time * time - 2f)); case Ease.InQuint: return((time /= duration) * time * time * time * time); case Ease.OutQuint: return((time = time / duration - 1f) * time * time * time * time + 1f); case Ease.InOutQuint: if ((time /= duration * 0.5f) < 1f) { return(0.5f * time * time * time * time * time); } return(0.5f * ((time -= 2f) * time * time * time * time + 2f)); case Ease.InExpo: if (time != 0f) { return((float)Math.Pow(2.0, (double)(10f * (time / duration - 1f)))); } return(0f); case Ease.OutExpo: if (time == duration) { return(1f); } return(-(float)Math.Pow(2.0, (double)(-10f * time / duration)) + 1f); case Ease.InOutExpo: if (time == 0f) { return(0f); } if (time == duration) { return(1f); } if ((time /= duration * 0.5f) < 1f) { return(0.5f * (float)Math.Pow(2.0, (double)(10f * (time - 1f)))); } return(0.5f * (-(float)Math.Pow(2.0, (double)(-10f * (time -= 1f))) + 2f)); case Ease.InCirc: return(-((float)Math.Sqrt((double)(1f - (time /= duration) * time)) - 1f)); case Ease.OutCirc: return((float)Math.Sqrt((double)(1f - (time = time / duration - 1f) * time))); case Ease.InOutCirc: if ((time /= duration * 0.5f) < 1f) { return(-0.5f * ((float)Math.Sqrt((double)(1f - time * time)) - 1f)); } return(0.5f * ((float)Math.Sqrt((double)(1f - (time -= 2f) * time)) + 1f)); case Ease.InElastic: { if (time == 0f) { return(0f); } if ((time /= duration) == 1f) { return(1f); } if (period == 0f) { period = duration * 0.3f; } float num; if (overshootOrAmplitude < 1f) { overshootOrAmplitude = 1f; num = period / 4f; } else { num = period / 6.28318548f * (float)Math.Asin((double)(1f / overshootOrAmplitude)); } return(-(overshootOrAmplitude * (float)Math.Pow(2.0, (double)(10f * (time -= 1f))) * (float)Math.Sin((double)((time * duration - num) * 6.28318548f / period)))); } case Ease.OutElastic: { if (time == 0f) { return(0f); } if ((time /= duration) == 1f) { return(1f); } if (period == 0f) { period = duration * 0.3f; } float num2; if (overshootOrAmplitude < 1f) { overshootOrAmplitude = 1f; num2 = period / 4f; } else { num2 = period / 6.28318548f * (float)Math.Asin((double)(1f / overshootOrAmplitude)); } return(overshootOrAmplitude * (float)Math.Pow(2.0, (double)(-10f * time)) * (float)Math.Sin((double)((time * duration - num2) * 6.28318548f / period)) + 1f); } case Ease.InOutElastic: { if (time == 0f) { return(0f); } if ((time /= duration * 0.5f) == 2f) { return(1f); } if (period == 0f) { period = duration * 0.450000018f; } float num3; if (overshootOrAmplitude < 1f) { overshootOrAmplitude = 1f; num3 = period / 4f; } else { num3 = period / 6.28318548f * (float)Math.Asin((double)(1f / overshootOrAmplitude)); } if (time < 1f) { return(-0.5f * (overshootOrAmplitude * (float)Math.Pow(2.0, (double)(10f * (time -= 1f))) * (float)Math.Sin((double)((time * duration - num3) * 6.28318548f / period)))); } return(overshootOrAmplitude * (float)Math.Pow(2.0, (double)(-10f * (time -= 1f))) * (float)Math.Sin((double)((time * duration - num3) * 6.28318548f / period)) * 0.5f + 1f); } case Ease.InBack: return((time /= duration) * time * ((overshootOrAmplitude + 1f) * time - overshootOrAmplitude)); case Ease.OutBack: return((time = time / duration - 1f) * time * ((overshootOrAmplitude + 1f) * time + overshootOrAmplitude) + 1f); case Ease.InOutBack: if ((time /= duration * 0.5f) < 1f) { return(0.5f * (time * time * (((overshootOrAmplitude *= 1.525f) + 1f) * time - overshootOrAmplitude))); } return(0.5f * ((time -= 2f) * time * (((overshootOrAmplitude *= 1.525f) + 1f) * time + overshootOrAmplitude) + 2f)); case Ease.InBounce: return(Bounce.EaseIn(time, duration, overshootOrAmplitude, period)); case Ease.OutBounce: return(Bounce.EaseOut(time, duration, overshootOrAmplitude, period)); case Ease.InOutBounce: return(Bounce.EaseInOut(time, duration, overshootOrAmplitude, period)); case Ease.INTERNAL_Zero: return(1f); case Ease.INTERNAL_Custom: return(customEase(time, duration, overshootOrAmplitude, period)); default: return(-(time /= duration) * (time - 2f)); } }
/// <summary> /// Returns a value between 0 and 1 (inclusive) based on the elapsed time and ease selected /// </summary> public static float Evaluate(Ease easeType, EaseFunction customEase, float time, float duration, float overshootOrAmplitude, float period) { switch (easeType) { case Ease.Linear: return(time / duration); case Ease.InSine: return(-(float)Math.Cos(time / duration * _PiOver2) + 1); case Ease.OutSine: return((float)Math.Sin(time / duration * _PiOver2)); case Ease.InOutSine: return(-0.5f * ((float)Math.Cos(Mathf.PI * time / duration) - 1)); case Ease.InQuad: return((time /= duration) * time); case Ease.OutQuad: return(-(time /= duration) * (time - 2)); case Ease.InOutQuad: if ((time /= duration * 0.5f) < 1) { return(0.5f * time * time); } return(-0.5f * ((--time) * (time - 2) - 1)); case Ease.InCubic: return((time /= duration) * time * time); case Ease.OutCubic: return((time = time / duration - 1) * time * time + 1); case Ease.InOutCubic: if ((time /= duration * 0.5f) < 1) { return(0.5f * time * time * time); } return(0.5f * ((time -= 2) * time * time + 2)); case Ease.InQuart: return((time /= duration) * time * time * time); case Ease.OutQuart: return(-((time = time / duration - 1) * time * time * time - 1)); case Ease.InOutQuart: if ((time /= duration * 0.5f) < 1) { return(0.5f * time * time * time * time); } return(-0.5f * ((time -= 2) * time * time * time - 2)); case Ease.InQuint: return((time /= duration) * time * time * time * time); case Ease.OutQuint: return((time = time / duration - 1) * time * time * time * time + 1); case Ease.InOutQuint: if ((time /= duration * 0.5f) < 1) { return(0.5f * time * time * time * time * time); } return(0.5f * ((time -= 2) * time * time * time * time + 2)); case Ease.InExpo: return((time == 0) ? 0 : (float)Math.Pow(2, 10 * (time / duration - 1))); case Ease.OutExpo: if (time == duration) { return(1); } return(-(float)Math.Pow(2, -10 * time / duration) + 1); case Ease.InOutExpo: if (time == 0) { return(0); } if (time == duration) { return(1); } if ((time /= duration * 0.5f) < 1) { return(0.5f * (float)Math.Pow(2, 10 * (time - 1))); } return(0.5f * (-(float)Math.Pow(2, -10 * --time) + 2)); case Ease.InCirc: return(-((float)Math.Sqrt(1 - (time /= duration) * time) - 1)); case Ease.OutCirc: return((float)Math.Sqrt(1 - (time = time / duration - 1) * time)); case Ease.InOutCirc: if ((time /= duration * 0.5f) < 1) { return(-0.5f * ((float)Math.Sqrt(1 - time * time) - 1)); } return(0.5f * ((float)Math.Sqrt(1 - (time -= 2) * time) + 1)); case Ease.InElastic: float s0; if (time == 0) { return(0); } if ((time /= duration) == 1) { return(1); } if (period == 0) { period = duration * 0.3f; } if (overshootOrAmplitude < 1) { overshootOrAmplitude = 1; s0 = period / 4; } else { s0 = period / _TwoPi * (float)Math.Asin(1 / overshootOrAmplitude); } return(-(overshootOrAmplitude * (float)Math.Pow(2, 10 * (time -= 1)) * (float)Math.Sin((time * duration - s0) * _TwoPi / period))); case Ease.OutElastic: float s1; if (time == 0) { return(0); } if ((time /= duration) == 1) { return(1); } if (period == 0) { period = duration * 0.3f; } if (overshootOrAmplitude < 1) { overshootOrAmplitude = 1; s1 = period / 4; } else { s1 = period / _TwoPi * (float)Math.Asin(1 / overshootOrAmplitude); } return(overshootOrAmplitude * (float)Math.Pow(2, -10 * time) * (float)Math.Sin((time * duration - s1) * _TwoPi / period) + 1); case Ease.InOutElastic: float s; if (time == 0) { return(0); } if ((time /= duration * 0.5f) == 2) { return(1); } if (period == 0) { period = duration * (0.3f * 1.5f); } if (overshootOrAmplitude < 1) { overshootOrAmplitude = 1; s = period / 4; } else { s = period / _TwoPi * (float)Math.Asin(1 / overshootOrAmplitude); } if (time < 1) { return(-0.5f * (overshootOrAmplitude * (float)Math.Pow(2, 10 * (time -= 1)) * (float)Math.Sin((time * duration - s) * _TwoPi / period))); } return(overshootOrAmplitude * (float)Math.Pow(2, -10 * (time -= 1)) * (float)Math.Sin((time * duration - s) * _TwoPi / period) * 0.5f + 1); case Ease.InBack: return((time /= duration) * time * ((overshootOrAmplitude + 1) * time - overshootOrAmplitude)); case Ease.OutBack: return((time = time / duration - 1) * time * ((overshootOrAmplitude + 1) * time + overshootOrAmplitude) + 1); case Ease.InOutBack: if ((time /= duration * 0.5f) < 1) { return(0.5f * (time * time * (((overshootOrAmplitude *= (1.525f)) + 1) * time - overshootOrAmplitude))); } return(0.5f * ((time -= 2) * time * (((overshootOrAmplitude *= (1.525f)) + 1) * time + overshootOrAmplitude) + 2)); case Ease.InBounce: return(Bounce.EaseIn(time, duration, overshootOrAmplitude, period)); case Ease.OutBounce: return(Bounce.EaseOut(time, duration, overshootOrAmplitude, period)); case Ease.InOutBounce: return(Bounce.EaseInOut(time, duration, overshootOrAmplitude, period)); case Ease.INTERNAL_Custom: return(customEase(time, duration, overshootOrAmplitude, period)); case Ease.INTERNAL_Zero: // 0 duration tween return(1); // Extra custom eases //////////////////////////////////////////////////// case Ease.Flash: return(Flash.Ease(time, duration, overshootOrAmplitude, period)); case Ease.InFlash: return(Flash.EaseIn(time, duration, overshootOrAmplitude, period)); case Ease.OutFlash: return(Flash.EaseOut(time, duration, overshootOrAmplitude, period)); case Ease.InOutFlash: return(Flash.EaseInOut(time, duration, overshootOrAmplitude, period)); // Default default: // OutQuad return(-(time /= duration) * (time - 2)); } }
public static float EaseIn(float time, float duration, float unusedOvershootOrAmplitude, float unusedPeriod) { return(1f - Bounce.EaseOut(duration - time, duration, -1f, -1f)); }
public static float Evaluate(Tween t, float time, float startValue, float changeValue, float duration, float overshootOrAmplitude, float period) { switch (t.easeType) { case Ease.Linear: return(changeValue * time / duration + startValue); case Ease.InSine: return(-changeValue * (float)Math.Cos(time / duration * _PiOver2) + changeValue + startValue); case Ease.OutSine: return(changeValue * (float)Math.Sin(time / duration * _PiOver2) + startValue); case Ease.InOutSine: return(-changeValue * 0.5f * ((float)Math.Cos(Mathf.PI * time / duration) - 1) + startValue); case Ease.InQuad: return(changeValue * (time /= duration) * time + startValue); case Ease.OutQuad: return(-changeValue * (time /= duration) * (time - 2) + startValue); case Ease.InOutQuad: if ((time /= duration * 0.5f) < 1) { return(changeValue * 0.5f * time * time + startValue); } return(-changeValue * 0.5f * ((--time) * (time - 2) - 1) + startValue); case Ease.InCubic: return(changeValue * (time /= duration) * time * time + startValue); case Ease.OutCubic: return(changeValue * ((time = time / duration - 1) * time * time + 1) + startValue); case Ease.InOutCubic: if ((time /= duration * 0.5f) < 1) { return(changeValue * 0.5f * time * time * time + startValue); } return(changeValue * 0.5f * ((time -= 2) * time * time + 2) + startValue); case Ease.InQuart: return(changeValue * (time /= duration) * time * time * time + startValue); case Ease.OutQuart: return(-changeValue * ((time = time / duration - 1) * time * time * time - 1) + startValue); case Ease.InOutQuart: if ((time /= duration * 0.5f) < 1) { return(changeValue * 0.5f * time * time * time * time + startValue); } return(-changeValue * 0.5f * ((time -= 2) * time * time * time - 2) + startValue); case Ease.InQuint: return(changeValue * (time /= duration) * time * time * time * time + startValue); case Ease.OutQuint: return(changeValue * ((time = time / duration - 1) * time * time * time * time + 1) + startValue); case Ease.InOutQuint: if ((time /= duration * 0.5f) < 1) { return(changeValue * 0.5f * time * time * time * time * time + startValue); } return(changeValue * 0.5f * ((time -= 2) * time * time * time * time + 2) + startValue); case Ease.InExpo: return((time == 0) ? startValue : changeValue *(float)Math.Pow(2, 10 * (time / duration - 1)) + startValue); case Ease.OutExpo: if (time == duration) { return(startValue + changeValue); } return(changeValue * (-(float)Math.Pow(2, -10 * time / duration) + 1) + startValue); case Ease.InOutExpo: if (time == 0) { return(startValue); } if (time == duration) { return(startValue + changeValue); } if ((time /= duration * 0.5f) < 1) { return(changeValue * 0.5f * (float)Math.Pow(2, 10 * (time - 1)) + startValue); } return(changeValue * 0.5f * (-(float)Math.Pow(2, -10 * --time) + 2) + startValue); case Ease.InCirc: return(-changeValue * ((float)Math.Sqrt(1 - (time /= duration) * time) - 1) + startValue); case Ease.OutCirc: return(changeValue * (float)Math.Sqrt(1 - (time = time / duration - 1) * time) + startValue); case Ease.InOutCirc: if ((time /= duration * 0.5f) < 1) { return(-changeValue * 0.5f * ((float)Math.Sqrt(1 - time * time) - 1) + startValue); } return(changeValue * 0.5f * ((float)Math.Sqrt(1 - (time -= 2) * time) + 1) + startValue); case Ease.InElastic: float s0; if (time == 0) { return(startValue); } if ((time /= duration) == 1) { return(startValue + changeValue); } if (period == 0) { period = duration * 0.3f; } if (overshootOrAmplitude == 0 || (changeValue > 0 && overshootOrAmplitude < changeValue) || (changeValue < 0 && overshootOrAmplitude < -changeValue)) { overshootOrAmplitude = changeValue; s0 = period / 4; } else { s0 = period / _TwoPi * (float)Math.Asin(changeValue / overshootOrAmplitude); } return(-(overshootOrAmplitude * (float)Math.Pow(2, 10 * (time -= 1)) * (float)Math.Sin((time * duration - s0) * _TwoPi / period)) + startValue); case Ease.OutElastic: float s1; if (time == 0) { return(startValue); } if ((time /= duration) == 1) { return(startValue + changeValue); } if (period == 0) { period = duration * 0.3f; } if (overshootOrAmplitude == 0 || (changeValue > 0 && overshootOrAmplitude < changeValue) || (changeValue < 0 && overshootOrAmplitude < -changeValue)) { overshootOrAmplitude = changeValue; s1 = period / 4; } else { s1 = period / _TwoPi * (float)Math.Asin(changeValue / overshootOrAmplitude); } return(overshootOrAmplitude * (float)Math.Pow(2, -10 * time) * (float)Math.Sin((time * duration - s1) * _TwoPi / period) + changeValue + startValue); case Ease.InOutElastic: float s; if (time == 0) { return(startValue); } if ((time /= duration * 0.5f) == 2) { return(startValue + changeValue); } if (period == 0) { period = duration * (0.3f * 1.5f); } if (overshootOrAmplitude == 0 || (changeValue > 0 && overshootOrAmplitude < changeValue) || (changeValue < 0 && overshootOrAmplitude < -changeValue)) { overshootOrAmplitude = changeValue; s = period / 4; } else { s = period / _TwoPi * (float)Math.Asin(changeValue / overshootOrAmplitude); } if (time < 1) { return(-0.5f * (overshootOrAmplitude * (float)Math.Pow(2, 10 * (time -= 1)) * (float)Math.Sin((time * duration - s) * _TwoPi / period)) + startValue); } return(overshootOrAmplitude * (float)Math.Pow(2, -10 * (time -= 1)) * (float)Math.Sin((time * duration - s) * _TwoPi / period) * 0.5f + changeValue + startValue); case Ease.InBack: return(changeValue * (time /= duration) * time * ((overshootOrAmplitude + 1) * time - overshootOrAmplitude) + startValue); case Ease.OutBack: return(changeValue * ((time = time / duration - 1) * time * ((overshootOrAmplitude + 1) * time + overshootOrAmplitude) + 1) + startValue); case Ease.InOutBack: if ((time /= duration * 0.5f) < 1) { return(changeValue * 0.5f * (time * time * (((overshootOrAmplitude *= (1.525f)) + 1) * time - overshootOrAmplitude)) + startValue); } return(changeValue / 2 * ((time -= 2) * time * (((overshootOrAmplitude *= (1.525f)) + 1) * time + overshootOrAmplitude) + 2) + startValue); case Ease.InBounce: return(Bounce.EaseIn(time, startValue, changeValue, duration, overshootOrAmplitude, period)); case Ease.OutBounce: return(Bounce.EaseOut(time, startValue, changeValue, duration, overshootOrAmplitude, period)); case Ease.InOutBounce: return(Bounce.EaseInOut(time, startValue, changeValue, duration, overshootOrAmplitude, period)); case Ease.INTERNAL_Custom: return(t.customEase(time, startValue, changeValue, duration, overshootOrAmplitude, period)); case Ease.INTERNAL_Zero: // 0 duration tween return(startValue + changeValue); default: // OutQuad return(-changeValue * (time /= duration) * (time - 2) + startValue); } }
public static float InOutBounce(float time, float duration, float overshootOrAmplitude, float period) { return(Bounce.EaseInOut(time, duration, overshootOrAmplitude, period)); }
public static EaseFunction ToEaseFunction(Ease ease) { switch (ease) { case Ease.Linear: return((float time, float duration, float overshootOrAmplitude, float period) => time / duration); case Ease.InSine: return((float time, float duration, float overshootOrAmplitude, float period) => - (float)Math.Cos(time / duration * _PiOver2) + 1); case Ease.OutSine: return((float time, float duration, float overshootOrAmplitude, float period) => (float)Math.Sin(time / duration * _PiOver2)); case Ease.InOutSine: return((float time, float duration, float overshootOrAmplitude, float period) => - 0.5f * ((float)Math.Cos(Mathf.PI * time / duration) - 1)); case Ease.InQuad: return((float time, float duration, float overshootOrAmplitude, float period) => (time /= duration) * time); case Ease.OutQuad: return((float time, float duration, float overshootOrAmplitude, float period) => - (time /= duration) * (time - 2)); case Ease.InOutQuad: return((float time, float duration, float overshootOrAmplitude, float period) => { if ((time /= duration * 0.5f) < 1) { return 0.5f * time * time; } return -0.5f * ((--time) * (time - 2) - 1); }); case Ease.InCubic: return((float time, float duration, float overshootOrAmplitude, float period) => (time /= duration) * time * time); case Ease.OutCubic: return((float time, float duration, float overshootOrAmplitude, float period) => ((time = time / duration - 1) * time * time + 1)); case Ease.InOutCubic: return((float time, float duration, float overshootOrAmplitude, float period) => { if ((time /= duration * 0.5f) < 1) { return 0.5f * time * time * time; } return 0.5f * ((time -= 2) * time * time + 2); }); case Ease.InQuart: return((float time, float duration, float overshootOrAmplitude, float period) => (time /= duration) * time * time * time); case Ease.OutQuart: return((float time, float duration, float overshootOrAmplitude, float period) => - ((time = time / duration - 1) * time * time * time - 1)); case Ease.InOutQuart: return((float time, float duration, float overshootOrAmplitude, float period) => { if ((time /= duration * 0.5f) < 1) { return 0.5f * time * time * time * time; } return -0.5f * ((time -= 2) * time * time * time - 2); }); case Ease.InQuint: return((float time, float duration, float overshootOrAmplitude, float period) => (time /= duration) * time * time * time * time); case Ease.OutQuint: return((float time, float duration, float overshootOrAmplitude, float period) => ((time = time / duration - 1) * time * time * time * time + 1)); case Ease.InOutQuint: return((float time, float duration, float overshootOrAmplitude, float period) => { if ((time /= duration * 0.5f) < 1) { return 0.5f * time * time * time * time * time; } return 0.5f * ((time -= 2) * time * time * time * time + 2); }); case Ease.InExpo: return((float time, float duration, float overshootOrAmplitude, float period) => (time == 0) ? 0 : (float)Math.Pow(2, 10 * (time / duration - 1))); case Ease.OutExpo: return((float time, float duration, float overshootOrAmplitude, float period) => { if (time == duration) { return 1; } return (-(float)Math.Pow(2, -10 * time / duration) + 1); }); case Ease.InOutExpo: return((float time, float duration, float overshootOrAmplitude, float period) => { if (time == 0) { return 0; } if (time == duration) { return 1; } if ((time /= duration * 0.5f) < 1) { return 0.5f * (float)Math.Pow(2, 10 * (time - 1)); } return 0.5f * (-(float)Math.Pow(2, -10 * --time) + 2); }); case Ease.InCirc: return((float time, float duration, float overshootOrAmplitude, float period) => - ((float)Math.Sqrt(1 - (time /= duration) * time) - 1)); case Ease.OutCirc: return((float time, float duration, float overshootOrAmplitude, float period) => (float)Math.Sqrt(1 - (time = time / duration - 1) * time)); case Ease.InOutCirc: return((float time, float duration, float overshootOrAmplitude, float period) => { if ((time /= duration * 0.5f) < 1) { return -0.5f * ((float)Math.Sqrt(1 - time * time) - 1); } return 0.5f * ((float)Math.Sqrt(1 - (time -= 2) * time) + 1); }); case Ease.InElastic: return((float time, float duration, float overshootOrAmplitude, float period) => { float s0; if (time == 0) { return 0; } if ((time /= duration) == 1) { return 1; } if (period == 0) { period = duration * 0.3f; } if (overshootOrAmplitude < 1) { overshootOrAmplitude = 1; s0 = period / 4; } else { s0 = period / _TwoPi * (float)Math.Asin(1 / overshootOrAmplitude); } return -(overshootOrAmplitude * (float)Math.Pow(2, 10 * (time -= 1)) * (float)Math.Sin((time * duration - s0) * _TwoPi / period)); }); case Ease.OutElastic: return((float time, float duration, float overshootOrAmplitude, float period) => { float s1; if (time == 0) { return 0; } if ((time /= duration) == 1) { return 1; } if (period == 0) { period = duration * 0.3f; } if (overshootOrAmplitude < 1) { overshootOrAmplitude = 1; s1 = period / 4; } else { s1 = period / _TwoPi * (float)Math.Asin(1 / overshootOrAmplitude); } return (overshootOrAmplitude * (float)Math.Pow(2, -10 * time) * (float)Math.Sin((time * duration - s1) * _TwoPi / period) + 1); }); case Ease.InOutElastic: return((float time, float duration, float overshootOrAmplitude, float period) => { float s; if (time == 0) { return 0; } if ((time /= duration * 0.5f) == 2) { return 1; } if (period == 0) { period = duration * (0.3f * 1.5f); } if (overshootOrAmplitude < 1) { overshootOrAmplitude = 1; s = period / 4; } else { s = period / _TwoPi * (float)Math.Asin(1 / overshootOrAmplitude); } if (time < 1) { return -0.5f * (overshootOrAmplitude * (float)Math.Pow(2, 10 * (time -= 1)) * (float)Math.Sin((time * duration - s) * _TwoPi / period)); } return overshootOrAmplitude * (float)Math.Pow(2, -10 * (time -= 1)) * (float)Math.Sin((time * duration - s) * _TwoPi / period) * 0.5f + 1; }); case Ease.InBack: return((float time, float duration, float overshootOrAmplitude, float period) => (time /= duration) * time * ((overshootOrAmplitude + 1) * time - overshootOrAmplitude)); case Ease.OutBack: return((float time, float duration, float overshootOrAmplitude, float period) => ((time = time / duration - 1) * time * ((overshootOrAmplitude + 1) * time + overshootOrAmplitude) + 1)); case Ease.InOutBack: return((float time, float duration, float overshootOrAmplitude, float period) => { if ((time /= duration * 0.5f) < 1) { return 0.5f * (time * time * (((overshootOrAmplitude *= (1.525f)) + 1) * time - overshootOrAmplitude)); } return 0.5f * ((time -= 2) * time * (((overshootOrAmplitude *= (1.525f)) + 1) * time + overshootOrAmplitude) + 2); }); case Ease.InBounce: return((float time, float duration, float overshootOrAmplitude, float period) => Bounce.EaseIn(time, duration, overshootOrAmplitude, period)); case Ease.OutBounce: return((float time, float duration, float overshootOrAmplitude, float period) => Bounce.EaseOut(time, duration, overshootOrAmplitude, period)); case Ease.InOutBounce: return((float time, float duration, float overshootOrAmplitude, float period) => Bounce.EaseInOut(time, duration, overshootOrAmplitude, period)); default: // OutQuad return((float time, float duration, float overshootOrAmplitude, float period) => - (time /= duration) * (time - 2)); } }