public static float ConvertLinearToEased(EasingType easingType, EasingDirection easingDirection, float linear)
{
switch (easingType)
{
case EasingType.Linear: return(linear);
case EasingType.Sine when easingDirection == EasingDirection.InAndOut: return(EaseInOutSine(linear));
case EasingType.Sine when easingDirection == EasingDirection.In: return(EaseInSine(linear));
case EasingType.Sine when easingDirection == EasingDirection.Out: return(EaseOutSine(linear));
case EasingType.Cubic when easingDirection == EasingDirection.InAndOut: return(EaseInOutCubic(linear));
case EasingType.Cubic when easingDirection == EasingDirection.In: return(EaseInCubic(linear));
case EasingType.Cubic when easingDirection == EasingDirection.Out: return(EaseOutCubic(linear));
case EasingType.Expo when easingDirection == EasingDirection.InAndOut: return(EaseInOutExpo(linear));
case EasingType.Expo when easingDirection == EasingDirection.In: return(EaseInExpo(linear));
case EasingType.Expo when easingDirection == EasingDirection.Out: return(EaseOutExpo(linear));
case EasingType.Bounce: return(EaseBounce(linear));
case EasingType.Elastic: return(EaseElastic(linear));
default: throw new ArgumentException($"No case for easing type {easingType} and easing direction {easingDirection}");
}
}
/// <summary>
/// Smoothly moves a GUI to a new UDim2 position in the specified time using the specified EasingDirection and EasingStyle.
/// </summary>
/// <returns></returns>
public bool TweenPosition(UDim2 endPos, EasingDirection easingDirection = EasingDirection.Out, EasingStyle easingStyle = EasingStyle.Quad, float time = 1f, bool oride = false)
{
if (oride && _beingTweened)
{
_interrupt = true;
}
// TODO: add an actual tween in render loop
return(false);
}
private void StartEasingCoroutine(EasingDirection easingDirection, float duration)
{
if (_easingCoroutine != null)
{
SharedCoroutineStarter.instance.StopCoroutine(_easingCoroutine);
}
IsFading = true;
var speed = (int)easingDirection / (float)Math.Max(0.0001, duration);
_easingCoroutine = Ease(speed);
SharedCoroutineStarter.instance.StartCoroutine(_easingCoroutine);
}
public static float GetEasing(EasingStyle style, EasingDirection direction, float percent)
{
if (style == EasingStyle.Bounce)
{
if (direction == EasingDirection.Out)
{
return(1 - easeOut(percent, bounce));
}
else if (direction == EasingDirection.In)
{
return(1 - bounce(percent));
}
else
{
return(1 - easeInOut(percent, bounce));
}
}
else if (style == EasingStyle.Elastic)
{
double result;
if (direction == EasingDirection.InOut)
{
double t = ((double)percent * 2) - 1;
result = Math.Pow(2, 10 * t) * Math.Sin((t - 0.1125) * tau / 0.45);
if (t < 0)
{
result = 1 - (-.5 * result);
}
else
{
result = 1 - (1 + .5 * result);
}
}
else
{
double t = (double)percent;
result = (1 + Math.Pow(2, -10 * t) * Math.Sin((t - 0.925) * tau / 0.3));
if (direction == EasingDirection.In)
{
result = 1 - result;
}
}
return((float)result);
}
else if (style == EasingStyle.Cubic)
{
if (direction == EasingDirection.Out)
{
return(1 - easeOut(percent, cubic));
}
else if (direction == EasingDirection.In)
{
return(1 - cubic(percent));
}
else
{
return(1 - easeInOut(percent, cubic));
}
}
else if (style == EasingStyle.Linear)
{
return(1 - percent);
}
else // Constant
{
if (direction == EasingDirection.Out)
{
return(1);
}
else if (direction == EasingDirection.In)
{
return(0);
}
else
{
return(0.5f);
}
}
}
public static Easing FromType(EasingType type, EasingDirection direction)
{
return(new Easing(FunctionFromType(type), direction));
}
public Easing(Func <decimal, decimal> function, EasingDirection direction)
{
Function = function;
Direction = direction;
}
public static Easing FromType(EasingType type, EasingDirection direction)
{
return new Easing(FunctionFromType(type), direction);
}
public Easing(Func<decimal, decimal> function, EasingDirection direction)
{
Function = function;
Direction = direction;
}
///////////////////
// Type mapping
/// <summary>
/// Return the easing method for the given enum values. This allows
/// to e.g. choose the easing in the Unity editor using the provided enums.
/// </summary>
/// <param name='type'>
/// Easing type.
/// </param>
/// <param name='direction'>
/// Easing direction.
/// </param>
public static EasingMethod EasingForType(EasingType type, EasingDirection direction)
{
switch (type) {
case EasingType.Linear:
return Linear;
case EasingType.Quadratic:
switch (direction) {
case EasingDirection.In:
return QuadraticIn;
case EasingDirection.Out:
return QuadraticOut;
default:
return QuadraticInOut;
}
case EasingType.Cubic:
switch (direction) {
case EasingDirection.In:
return CubicIn;
case EasingDirection.Out:
return CubicOut;
default:
return CubicInOut;
}
case EasingType.Quartic:
switch (direction) {
case EasingDirection.In:
return QuarticIn;
case EasingDirection.Out:
return QuarticOut;
default:
return QuarticInOut;
}
case EasingType.Quintic:
switch (direction) {
case EasingDirection.In:
return QuinticIn;
case EasingDirection.Out:
return QuinticOut;
default:
return QuinticInOut;
}
case EasingType.Sinusoidal:
switch (direction) {
case EasingDirection.In:
return SinusoidalIn;
case EasingDirection.Out:
return SinusoidalOut;
default:
return SinusoidalInOut;
}
case EasingType.Exponential:
switch (direction) {
case EasingDirection.In:
return ExponentialIn;
case EasingDirection.Out:
return ExponentialOut;
default:
return ExponentialInOut;
}
case EasingType.Circular:
switch (direction) {
case EasingDirection.In:
return CircularIn;
case EasingDirection.Out:
return CircularOut;
default:
return CircularInOut;
}
case EasingType.Back:
switch (direction) {
case EasingDirection.In:
return BackIn;
case EasingDirection.Out:
return BackOut;
default:
return BackInOut;
}
case EasingType.Bounce:
switch (direction) {
case EasingDirection.In:
return BounceIn;
case EasingDirection.Out:
return BounceOut;
default:
return BounceInOut;
}
case EasingType.Elastic:
switch (direction) {
case EasingDirection.In:
return ElasticIn;
case EasingDirection.Out:
return ElasticOut;
default:
return ElasticInOut;
}
}
return null;
}
public static float GetEasing(EasingStyle style, EasingDirection direction, float percent)
{
if (style == EasingStyle.Bounce)
{
float result;
if (direction == EasingDirection.Out)
{
result = 1 - easeOut(percent, bounce);
}
else if (direction == EasingDirection.In)
{
result = 1 - bounce(percent);
}
else
{
result = 1 - easeInOut(percent, bounce);
}
return(result);
}
else if (style == EasingStyle.Elastic)
{
double result;
if (direction == EasingDirection.InOut)
{
double t = ((double)percent * 2) - 1;
double inOut = Math.Pow(2, 10 * t) * Math.Sin((t - 0.1125) * tau / 0.45);
if (t < 0)
{
inOut = 1 - (-.5 * inOut);
}
else
{
inOut = 1 - (1 + .5 * inOut);
}
result = inOut;
}
else
{
double t = percent;
double value = (1 + Math.Pow(2, -10 * t) * Math.Sin((t - 0.925) * tau / 0.3));
if (direction == EasingDirection.In)
{
value = 1 - value;
}
result = value;
}
return((float)result);
}
else if (style == EasingStyle.Cubic)
{
float result;
if (direction == EasingDirection.Out)
{
result = 1 - easeOut(percent, cubic);
}
else if (direction == EasingDirection.In)
{
result = 1 - cubic(percent);
}
else
{
result = 1 - easeInOut(percent, cubic);
}
return(result);
}
else if (style == EasingStyle.Linear)
{
return(1 - percent);
}
else // Constant
{
float result;
if (direction == EasingDirection.Out)
{
result = 1;
}
else if (direction == EasingDirection.In)
{
result = 0;
}
else
{
result = 0.5f;
}
return(result);
}
}
public Easing(Func <double, double> function, EasingDirection direction)
{
Function = function;
Direction = direction;
}
