// These are for the convience of allowing the Unity Editor to select any built in EaseMethod:
public static EaseMethod EaseFromEnum(EaseEnum ease)
{
switch (ease)
{
case EaseEnum.LINEAR: { return(EASE_LINEAR); }
case EaseEnum.QUAD_IN: { return(EASE_QUAD_IN); }
case EaseEnum.QUAD_OUT: { return(EASE_QUAD_OUT); }
case EaseEnum.QUAD_IN_OUT: { return(EASE_QUAD_IN_OUT); }
case EaseEnum.CUBIC_IN: { return(EASE_CUBIC_IN); }
case EaseEnum.CUBIC_OUT: { return(EASE_CUBIC_OUT); }
case EaseEnum.CUBIC_IN_OUT: { return(EASE_CUBIC_IN_OUT); }
case EaseEnum.SIN_IN: { return(EASE_SIN_IN); }
case EaseEnum.SIN_OUT: { return(EASE_SIN_OUT); }
case EaseEnum.SIN_IN_OUT: { return(EASE_SIN_IN_OUT); }
case EaseEnum.EXP_IN: { return(EASE_EXP_IN); }
case EaseEnum.EXP_OUT: { return(EASE_EXP_OUT); }
case EaseEnum.EXP_IN_OUT: { return(EASE_EXP_IN_OUT); }
case EaseEnum.CIRC_IN: { return(EASE_CIRC_IN); }
case EaseEnum.CIRC_OUT: { return(EASE_CIRC_OUT); }
case EaseEnum.CIRC_IN_OUT: { return(EASE_CIRC_IN_OUT); }
case EaseEnum.ELASTIC_OUT: { return(EASE_ELASTIC_OUT); }
case EaseEnum.BOUNCE_OUT: { return(EASE_BOUNCE_OUT); }
}
return(EASE_LINEAR);
}
/// <summary>
/// 设置缓冲动作
/// </summary>
/// <param name="tween"></param>
/// <param name="ease"></param>
/// <returns></returns>
public static ActionTween SetEase(this ActionTween tween, EaseEnum ease)
{
tween.mEaseEnum = ease;
return(tween);
}
/// <summary>
/// Returns a value between 0 and 1 (inclusive) based on the elapsed time and EaseEnum selected
/// </summary>
public static float Evaluate(EaseEnum easeType, EaseFunction customEase, float time, float duration, float overshootOrAmplitude, float period)
{
switch (easeType)
{
case EaseEnum.Linear:
return(time / duration);
case EaseEnum.InSine:
return(-(float)Math.Cos(time / duration * _PiOver2) + 1);
case EaseEnum.OutSine:
return((float)Math.Sin(time / duration * _PiOver2));
case EaseEnum.InOutSine:
return(-0.5f * ((float)Math.Cos(Mathf.PI * time / duration) - 1));
case EaseEnum.InQuad:
return((time /= duration) * time);
case EaseEnum.OutQuad:
return(-(time /= duration) * (time - 2));
case EaseEnum.InOutQuad:
if ((time /= duration * 0.5f) < 1)
{
return(0.5f * time * time);
}
return(-0.5f * ((--time) * (time - 2) - 1));
case EaseEnum.InCubic:
return((time /= duration) * time * time);
case EaseEnum.OutCubic:
return((time = time / duration - 1) * time * time + 1);
case EaseEnum.InOutCubic:
if ((time /= duration * 0.5f) < 1)
{
return(0.5f * time * time * time);
}
return(0.5f * ((time -= 2) * time * time + 2));
case EaseEnum.InQuart:
return((time /= duration) * time * time * time);
case EaseEnum.OutQuart:
return(-((time = time / duration - 1) * time * time * time - 1));
case EaseEnum.InOutQuart:
if ((time /= duration * 0.5f) < 1)
{
return(0.5f * time * time * time * time);
}
return(-0.5f * ((time -= 2) * time * time * time - 2));
case EaseEnum.InQuint:
return((time /= duration) * time * time * time * time);
case EaseEnum.OutQuint:
return((time = time / duration - 1) * time * time * time * time + 1);
case EaseEnum.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 EaseEnum.InExpo:
return((time == 0) ? 0 : (float)Math.Pow(2, 10 * (time / duration - 1)));
case EaseEnum.OutExpo:
if (time == duration)
{
return(1);
}
return(-(float)Math.Pow(2, -10 * time / duration) + 1);
case EaseEnum.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 EaseEnum.InCirc:
return(-((float)Math.Sqrt(1 - (time /= duration) * time) - 1));
case EaseEnum.OutCirc:
return((float)Math.Sqrt(1 - (time = time / duration - 1) * time));
case EaseEnum.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 EaseEnum.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 EaseEnum.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 EaseEnum.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 EaseEnum.InBack:
return((time /= duration) * time * ((overshootOrAmplitude + 1) * time - overshootOrAmplitude));
case EaseEnum.OutBack:
return((time = time / duration - 1) * time * ((overshootOrAmplitude + 1) * time + overshootOrAmplitude) + 1);
case EaseEnum.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 EaseEnum.InBounce:
return(Bounce.EaseIn(time, duration, overshootOrAmplitude, period));
case EaseEnum.OutBounce:
return(Bounce.EaseOut(time, duration, overshootOrAmplitude, period));
case EaseEnum.InOutBounce:
return(Bounce.EaseInOut(time, duration, overshootOrAmplitude, period));
case EaseEnum.INTERNAL_Custom:
return(customEase(time, duration, overshootOrAmplitude, period));
// Default
default:
// OutQuad
return(-(time /= duration) * (time - 2));
}
}
/// <summary>
/// Gets the easing function
/// </summary>
/// <param name="type">ease type</param>
/// <returns>easing function</returns>
public static Func <float, float> Get(EaseEnum type)
{
switch (type)
{
case EaseEnum.Linear: return(Linear);
case EaseEnum.InBack: return(InBack);
case EaseEnum.InBounce: return(InBounce);
case EaseEnum.InCirc: return(InCirc);
case EaseEnum.InCubic: return(InCubic);
case EaseEnum.InElastic: return(InElastic);
case EaseEnum.InExpo: return(InExpo);
case EaseEnum.InQuad: return(InQuad);
case EaseEnum.InQuart: return(InQuart);
case EaseEnum.InQuint: return(InQuint);
case EaseEnum.InSine: return(InSine);
case EaseEnum.OutBack: return(OutBack);
case EaseEnum.OutBounce: return(OutBounce);
case EaseEnum.OutCirc: return(OutCirc);
case EaseEnum.OutCubic: return(OutCubic);
case EaseEnum.OutElastic: return(OutElastic);
case EaseEnum.OutExpo: return(OutExpo);
case EaseEnum.OutQuad: return(OutQuad);
case EaseEnum.OutQuart: return(OutQuart);
case EaseEnum.OutQuint: return(OutQuint);
case EaseEnum.OutSine: return(OutSine);
case EaseEnum.InOutBack: return(InOutBack);
case EaseEnum.InOutBounce: return(InOutBounce);
case EaseEnum.InOutCirc: return(InOutCirc);
case EaseEnum.InOutCubic: return(InOutCubic);
case EaseEnum.InOutElastic: return(InOutElastic);
case EaseEnum.InOutExpo: return(InOutExpo);
case EaseEnum.InOutQuad: return(InOutQuad);
case EaseEnum.InOutQuart: return(InOutQuart);
case EaseEnum.InOutQuint: return(InOutQuint);
case EaseEnum.InOutSine: return(InOutSine);
default: return(Linear);
}
}
