/// <summary> /// Provides an easing factor for the given animation progress. /// </summary> /// <param name="progress"> The fractional progress of the animation (from 0 to 1). </param> /// <param name="type"> The type of easing to perform. </param> /// <param name="direction"> The direction of the animation. </param> /// <returns> The factor to use in the animation. </returns> public static double Factor(double progress, EaseType type, EaseDirection direction) { if (direction == EaseDirection.In) return InFactor(progress, type); else if (direction == EaseDirection.Out) return OutFactor(progress, type); else return InOutFactor(progress, type); }
/* * A map() replacement that allows for specifying Easing curves * with arbitrary exponents. * * value : The value to map * start1 : The lower limit of the input range * stop1 : The upper limit of the input range * start2 : The lower limit of the output range * stop2 : The upper limit of the output range * type : The type of easing (see above) * direction : One of EASE_IN, EASE_OUT, or EASE_IN_OUT */ public static float Map2(float value, float start1, float stop1, float start2, float stop2, EaseFunc type, EaseDirection direction) { float b = start2; float c = stop2 - start2; float t = value - start1; float d = stop1 - start1; float p = 0.5f; switch (type) { case EaseFunc.LINEAR: return(c * t / d + b); case EaseFunc.SQRT: switch (direction) { case EaseDirection.EASE_IN: t /= d; return(c * Mathf.Pow(t, p) + b); case EaseDirection.EASE_OUT: t /= d; return(c * (1 - Mathf.Pow(1 - t, p)) + b); case EaseDirection.EASE_IN_OUT: t /= d / 2; if (t < 1) { return(c / 2 * Mathf.Pow(t, p) + b); } return(c / 2 * (2 - Mathf.Pow(2 - t, p)) + b); } break; case EaseFunc.QUADRATIC: switch (direction) { case EaseDirection.EASE_IN: t /= d; return(c * t * t + b); case EaseDirection.EASE_OUT: t /= d; return(-c * t * (t - 2) + b); case EaseDirection.EASE_IN_OUT: t /= d / 2; if (t < 1) { return(c / 2 * t * t + b); } t--; return(-c / 2 * (t * (t - 2) - 1) + b); } break; case EaseFunc.CUBIC: switch (direction) { case EaseDirection.EASE_IN: t /= d; return(c * t * t * t + b); case EaseDirection.EASE_OUT: t /= d; t--; return(c * (t * t * t + 1) + b); case EaseDirection.EASE_IN_OUT: t /= d / 2; if (t < 1) { return(c / 2 * t * t * t + b); } t -= 2; return(c / 2 * (t * t * t + 2) + b); } break; case EaseFunc.QUARTIC: switch (direction) { case EaseDirection.EASE_IN: t /= d; return(c * t * t * t * t + b); case EaseDirection.EASE_OUT: t /= d; t--; return(-c * (t * t * t * t - 1) + b); case EaseDirection.EASE_IN_OUT: t /= d / 2; if (t < 1) { return(c / 2 * t * t * t * t + b); } t -= 2; return(-c / 2 * (t * t * t * t - 2) + b); } break; case EaseFunc.QUINTIC: switch (direction) { case EaseDirection.EASE_IN: t /= d; return(c * t * t * t * t * t + b); case EaseDirection.EASE_OUT: t /= d; t--; return(c * (t * t * t * t * t + 1) + b); case EaseDirection.EASE_IN_OUT: t /= d / 2; if (t < 1) { return(c / 2 * t * t * t * t * t + b); } t -= 2; return(c / 2 * (t * t * t * t * t + 2) + b); } break; case EaseFunc.SINUSOIDAL: switch (direction) { case EaseDirection.EASE_IN: return(-c *Mathf.Cos(t / d *(Mathf.PI / 2)) + c + b); case EaseDirection.EASE_OUT: return(c * Mathf.Sin(t / d * (Mathf.PI / 2)) + b); case EaseDirection.EASE_IN_OUT: return(-c / 2 * (Mathf.Cos(Mathf.PI * t / d) - 1) + b); } break; case EaseFunc.EXPONENTIAL: switch (direction) { case EaseDirection.EASE_IN: return(c * Mathf.Pow(2, 10 * (t / d - 1)) + b); case EaseDirection.EASE_OUT: return(c * (-Mathf.Pow(2, -10 * t / d) + 1) + b); case EaseDirection.EASE_IN_OUT: t /= d / 2; if (t < 1) { return(c / 2 * Mathf.Pow(2, 10 * (t - 1)) + b); } t--; return(c / 2 * (-Mathf.Pow(2, -10 * t) + 2) + b); } break; case EaseFunc.CIRCULAR: switch (direction) { case EaseDirection.EASE_IN: t /= d; return(-c * (Mathf.Sqrt(1 - t * t) - 1) + b); case EaseDirection.EASE_OUT: t /= d; t--; return(c * Mathf.Sqrt(1 - t * t) + b); case EaseDirection.EASE_IN_OUT: t /= d / 2; if (t < 1) { return(-c / 2 * (Mathf.Sqrt(1 - t * t) - 1) + b); } t -= 2; return(c / 2 * (Mathf.Sqrt(1 - t * t) + 1) + b); } break; } ; return(0); }
/* * A map() replacement that allows for specifying eaMathf.Sing curves * with arbitrary exponents. * * Default to EaseFunc.SQRT * * value : The value to map * start1 : The lower limit of the input range * stop1 : The upper limit of the input range * start2 : The lower limit of the output range * stop2 : The upper limit of the output range * v : The exponent value (e.g., 0.5, 0.1, 0.3) * direction : One of EASE_IN, EASE_OUT, or EASE_IN_OUT */ public static float Map3(float value, float start1, float stop1, float start2, float stop2, float v, EaseDirection direction) { float b = start2; float c = stop2 - start2; float t = value - start1; float d = stop1 - start1; float p = v; float val = 0; switch (direction) { case EaseDirection.EASE_IN: t /= d; val = c * Mathf.Pow(t, p) + b; break; case EaseDirection.EASE_OUT: t /= d; val = c * (1 - Mathf.Pow(1 - t, p)) + b; break; case EaseDirection.EASE_IN_OUT: t /= d / 2; if (t < 1) { return(c / 2 * Mathf.Pow(t, p) + b); } val = c / 2 * (2 - Mathf.Pow(2 - t, p)) + b; break; } return(val); }