// Adapted from source : http://www.robertpenner.com/easing/ public static float Ease(double linearStep, float acceleration, EasingType type) { float easedStep = acceleration > 0 ? EaseIn(linearStep, type) : acceleration < 0 ? EaseOut(linearStep, type) : (float) linearStep; return MathHelper.Lerp(linearStep, easedStep, Math.Abs(acceleration)); }
public static Vector3 Interp(Spline.Path pts, float t, EasingType ease, bool easeIn, bool easeOut) { t = Spline.Ease(t, ease, easeIn, easeOut); if (pts.Length == 0) { return Vector3.zero; } if (pts.Length == 1) { return pts[0]; } if (pts.Length == 2) { return Vector3.Lerp(pts[0], pts[1], t); } if (pts.Length == 3) { return QuadBez.Interp(pts[0], pts[2], pts[1], t); } if (pts.Length == 4) { return CubicBez.Interp(pts[0], pts[3], pts[1], pts[2], t); } return CRSpline.Interp(Spline.Wrap(pts), t); }
public Ease(EasingType type, float duration, object toEase, string mask) { _type = type; _startTime = Time.time; _value = toEase; _mask = mask; }
private static Func<decimal, decimal> FunctionFromType(EasingType easing) { switch (easing) { case EasingType.Constant: return x => 1; case EasingType.Linear: return x => x; case EasingType.Quadratic: return x => DMath.Pow(x, 2); case EasingType.Cubic: return x => DMath.Pow(x, 3); case EasingType.Quartic: return x => DMath.Pow(x, 4); case EasingType.Quintic: return x => DMath.Pow(x, 5); case EasingType.Sinusoidal: return x => 1 - DMath.Cos(x * DMath.PI / 2); // Wait... That's not Sine! case EasingType.Exponential: return x => DMath.Pow(x, 5); case EasingType.Circular: return x => 1 - DMath.Sqrt(1 - x * x); default: throw new ArgumentOutOfRangeException(); } }
public static float EaseOut(double linearStep, EasingType type) { switch (type) { case EasingType.None: return 1f; case EasingType.Linear: return (float) linearStep; case EasingType.Sine: return Easing.Sine.EaseOut(linearStep); case EasingType.Quadratic: return Easing.Power.EaseOut(linearStep, 2); case EasingType.Cubic: return Easing.Power.EaseOut(linearStep, 3); case EasingType.Quartic: return Easing.Power.EaseOut(linearStep, 4); case EasingType.Quintic: return Easing.Power.EaseOut(linearStep, 5); case EasingType.Sextic: return Easing.Power.EaseOut(linearStep, 6); case EasingType.Septic: return Easing.Power.EaseOut(linearStep, 7); case EasingType.Octic: return Easing.Power.EaseOut(linearStep, 8); case EasingType.Nonic: return Easing.Power.EaseOut(linearStep, 9); case EasingType.Decic: return Easing.Power.EaseOut(linearStep, 10); case EasingType.Circular: return Easing.Circular.EaseOut(linearStep); default: throw new NotImplementedException(); } }
public static float EaseOut(double linearStep, EasingType type) { switch (type) { case EasingType.Step: return linearStep < 0.5 ? 0 : 1; case EasingType.Linear: return (float)linearStep; case EasingType.Sine: return Sine.EaseOut(linearStep); case EasingType.Quadratic: return Power.EaseOut(linearStep, 2); case EasingType.Circular: return Circular.EaseOut(linearStep); } throw new NotImplementedException(); }
public static float EaseInOut(double linearStep, EasingType type) { linearStep = Mathf.Clamp01((float)linearStep); switch (type) { case EasingType.Step: return linearStep < 0.5 ? 0 : 1; case EasingType.Linear: return (float)linearStep; case EasingType.Sine: return Sine.EaseInOut(linearStep); case EasingType.Quadratic: return Power.EaseInOut(linearStep, 2); case EasingType.Cubic: return Power.EaseInOut(linearStep, 3); case EasingType.Quartic: return Power.EaseInOut(linearStep, 4); case EasingType.Quintic: return Power.EaseInOut(linearStep, 5); } throw new NotImplementedException(); }
public static void GizmoDraw(Vector3[] pts, float t, EasingType ease, bool easeIn, bool easeOut) { Gizmos.color = Color.white; Vector3 to = Spline.Interp(pts, 0f); for (int i = 1; i <= 20; i++) { float t2 = (float)i / 20f; Vector3 vector = Spline.Interp(pts, t2, ease, easeIn, easeOut); Gizmos.DrawLine(vector, to); to = vector; } Gizmos.color = Color.blue; Vector3 vector2 = Spline.Interp(pts, t, ease, easeIn, easeOut); Gizmos.DrawLine(vector2, vector2 + Spline.Velocity(pts, t, ease, easeIn, easeOut)); }
/// <summary> /// Returns the output of an easing function for a specific time. /// </summary> /// <param name="t">The normalized time</param> /// <param name="easingType">The easing function to use</param> /// <returns>The eased output</returns> public static float Ease(float t, EasingType easingType) { switch (easingType) { case EasingType.ExponentialIn: return Functions.ExponentialIn(t); case EasingType.ExponentialOut: return Functions.ExponentialOut(t); case EasingType.ExponentialInOut: return Functions.ExponentialInOut(t); case EasingType.ExponentialOutIn: return Functions.ExponentialOutIn(t); case EasingType.SineIn: return Functions.SineIn(t); case EasingType.SineOut: return Functions.SineOut(t); case EasingType.SineInOut: return Functions.SineInOut(t); case EasingType.SineOutIn: return Functions.SineOutIn(t); case EasingType.CubicIn: return Functions.CubicIn(t); case EasingType.CubicOut: return Functions.CubicOut(t); case EasingType.CubicInOut: return Functions.CubicInOut(t); case EasingType.CubicOutIn: return Functions.CubicOutIn(t); case EasingType.QuinticIn: return Functions.QuinticIn(t); case EasingType.QuinticOut: return Functions.QuinticOut(t); case EasingType.QuinticInOut: return Functions.QuinticInOut(t); case EasingType.QuinticOutIn: return Functions.QuinticOutIn(t); case EasingType.CircularIn: return Functions.CircularIn(t); case EasingType.CircularOut: return Functions.CircularOut(t); case EasingType.CircularInOut: return Functions.CircularInOut(t); case EasingType.CircularOutIn: return Functions.CircularOutIn(t); case EasingType.ElasticIn: return Functions.ElasticIn(t); case EasingType.ElasticOut: return Functions.ElasticOut(t); case EasingType.ElasticInOut: return Functions.ElasticInOut(t); case EasingType.ElasticOutIn: return Functions.ElasticOutIn(t); case EasingType.QuadraticIn: return Functions.QuadraticIn(t); case EasingType.QuadraticOut: return Functions.QuadraticOut(t); case EasingType.QuadraticInOut: return Functions.QuadraticInOut(t); case EasingType.QuadraticOutIn: return Functions.QuadraticOutIn(t); case EasingType.QuarticIn: return Functions.QuarticIn(t); case EasingType.QuarticOut: return Functions.QuarticOut(t); case EasingType.QuarticInOut: return Functions.QuarticInOut(t); case EasingType.QuarticOutIn: return Functions.QuarticOutIn(t); case EasingType.BackIn: return Functions.BackIn(t); case EasingType.BackOut: return Functions.BackOut(t); case EasingType.BackInOut: return Functions.BackInOut(t); case EasingType.BackOutIn: return Functions.BackOutIn(t); case EasingType.BounceIn: return Functions.BounceIn(t); case EasingType.BounceOut: return Functions.BounceOut(t); case EasingType.BounceInOut: return Functions.BounceInOut(t); case EasingType.BounceOutIn: return Functions.BounceOutIn(t); default: return Functions.Linear(t); } }
// Set this object up to fade-out public void MakeInvisible(float t = -1.0f, float alpha = 0.0f, EasingType easingType=EasingType.Linear, bool force = false) { alphaEaseType = easingType; alpha = Mathf.Max(0.0f, alpha); alpha = Mathf.Min(1.0f, alpha); if( t == 0.0f ) { if (transform.renderer.material.HasProperty("_Color") ) { if (GetComponent<DynamicText>() != null) { DynamicText dt = GetComponent<DynamicText>(); transitionStartColor = dt.color; transitionEndColor = new Color(transparantColor.r, transparantColor.g, transparantColor.b, alpha); oldAlpha = dt.color.a; dt.color = transitionEndColor; } else { transitionStartColor = renderer.material.color; transitionEndColor = new Color(transparantColor.r, transparantColor.g, transparantColor.b, alpha); oldAlpha = renderer.material.color.a; renderer.material.color = transitionEndColor; } } else { oldAlpha = transform.renderer.material.GetFloat("_alpha_blend"); transform.renderer.material.SetFloat("_alpha_blend", alpha); } m_isVisible = alpha > 0.0f; // return; } duration = (t >= 0.0f ? t : defaultDuration); stage = 0F; if (transform.renderer.material.HasProperty("_Color") ) { if (GetComponent<DynamicText>() != null) { transitionStartColor = GetComponent<DynamicText>().color; oldAlpha = transitionStartColor.a; } else { transitionStartColor = renderer.material.color; oldAlpha = renderer.material.color.a; } transitionEndColor = new Color(transparantColor.r, transparantColor.g, transparantColor.b, alpha); } else { oldAlpha = transform.renderer.material.GetFloat("_alpha_blend"); } targetAlpha = alpha; m_isTransitioning = true; }
public Animation(object obj, string propName, float startValue, float endValue, EaseFunctionDelegate easeFunc, EasingType easeType) { if(propName != null) { _property = obj.GetType().GetProperty(propName); } else { _property = null; } PropertyName = propName; _obj = obj; _startValue = startValue; _endValue = endValue; _easeFunc = easeFunc; _easeType = easeType; }
public static Quaternion RotationBetween(Spline.Path pts, float t1, float t2, EasingType ease, bool easeIn, bool easeOut) { return Quaternion.LookRotation(Spline.Interp(pts, t2, ease, easeIn, easeOut) - Spline.Interp(pts, t1, ease, easeIn, easeOut)); }
public static Vector3 Interp(Path pts, float t, EasingType ease) { return(Interp(pts, t, ease, true)); }
//public /// <summary> /// Creates a tween that sets a method. It starts at the specified value and ends at the specified value. /// </summary> /// <param name="onUpdate">The method that is called with the new value every time the tween is updated.</param> /// <param name="start">The starting value.</param> /// <param name="end">The ending value.</param> /// <param name="duration">The duration, in milliseconds, of the tween.</param> /// <param name="type">(optional) The type of easing the tween will use.</param> /// <returns>The tween that was created.</returns> public static Tween FromTo(Action <double> onUpdate, double start, double end, double duration, EasingType type = EasingType.Linear) { return(new Tween(onUpdate, start, end, duration, type)); }
public static Vector3 MoveOnPath(Path pts, Vector3 currentPosition, ref float pathPosition, float maxSpeed = 1f, float smoothnessFactor = 100, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true) { maxSpeed *= Time.deltaTime; pathPosition = Mathf.Clamp01(pathPosition); var goal = Interp(pts, pathPosition, ease, easeIn, easeOut); float distance; while ((distance = (goal - currentPosition).magnitude) <= maxSpeed && pathPosition < 1) { currentPosition = goal; maxSpeed -= distance; pathPosition = Mathf.Clamp01(pathPosition + 1 / smoothnessFactor); goal = Interp(pts, pathPosition, ease, easeIn, easeOut); } if (distance != 0) { currentPosition = Vector3.MoveTowards(currentPosition, goal, maxSpeed); } return(currentPosition); }
private static float Ease(float t, EasingType ease, bool easeIn, bool easeOut) { t = Mathf.Clamp01(t); if (easeIn && easeOut) { t = Easing.EaseInOut((double)t, ease); } else if (easeIn) { t = Easing.EaseIn((double)t, ease); } else if (easeOut) { t = Easing.EaseOut((double)t, ease); } return t; }
private static float Ease(float t, EasingType ease, bool easeIn) { return(Ease(t, ease, easeIn, true)); }
//master function for using EasingType with default parameters public static float easeWithType(EasingType type, float t) { switch (type) { case EasingType.EaseNone: return(easeNone(t)); case EasingType.EaseInQuad: return(easeInQuad(t)); case EasingType.EaseOutQuad: return(easeOutQuad(t)); case EasingType.EaseOutInQuad: return(easeOutInQuad(t)); case EasingType.EaseInCubic: return(easeInCubic(t)); case EasingType.EaseOutCubic: return(easeOutCubic(t)); case EasingType.EaseInOutCubic: return(easeInOutCubic(t)); case EasingType.EaseOutInCubic: return(easeOutInCubic(t)); case EasingType.EaseInQuart: return(easeInQuart(t)); case EasingType.EaseOutQuart: return(easeOutQuart(t)); case EasingType.EaseInOutQuart: return(easeInOutQuart(t)); case EasingType.EaseOutInQuart: return(easeOutInQuart(t)); case EasingType.EaseInQuint: return(easeInQuint(t)); case EasingType.EaseOutQuint: return(easeOutQuint(t)); case EasingType.EaseInOutQuint: return(easeInOutQuint(t)); case EasingType.EaseOutInQuint: return(easeOutInQuint(t)); case EasingType.EaseInSine: return(easeInSine(t)); case EasingType.EaseOutSine: return(easeOutSine(t)); case EasingType.EaseInOutSine: return(easeInOutSine(t)); case EasingType.EaseOutInSine: return(easeOutInSine(t)); case EasingType.EaseInExpo: return(easeInExpo(t)); case EasingType.EaseOutExpo: return(easeOutExpo(t)); case EasingType.EaseInOutExpo: return(easeInOutExpo(t)); case EasingType.EaseOutInExpo: return(easeOutInExpo(t)); case EasingType.EaseInCirc: return(easeInCirc(t)); case EasingType.EaseOutCirc: return(easeOutCirc(t)); case EasingType.EaseInOutCirc: return(easeInOutCirc(t)); case EasingType.EaseOutInCirc: return(easeOutInCirc(t)); case EasingType.EaseInBounce: return(easeInBounce(t)); case EasingType.EaseOutBounce: return(easeOutBounce(t)); case EasingType.EaseInOutBounce: return(easeInOutBounce(t)); case EasingType.EaseOutInBounce: return(easeOutInBounce(t)); case EasingType.EaseInBack: return(easeInBack(t)); case EasingType.EaseOutBack: return(easeOutBack(t)); case EasingType.EaseInOutBack: return(easeInOutBack(t)); case EasingType.EaseOutInBack: return(easeOutInBack(t, 1.70158f)); case EasingType.EaseInElastic: return(easeInElastic(t, 1.25f, 1.5f)); case EasingType.EaseOutElastic: return(easeOutElastic(t, 1.25f, 1.5f)); case EasingType.EaseInOutElastic: return(easeInOutElastic(t, 1.25f, 1.5f)); case EasingType.EaseOutInElastic: return(easeOutInElastic(t, 1.25f, 1.5f)); case EasingType.EaseInAtan: return(easeInAtan(t)); case EasingType.EaseOutAtan: return(easeOutAtan(t)); case EasingType.EaseInOutAtan: return(easeInOutAtan(t)); } return(t); }
public static Vector3 MoveOnPath(Path pts, Vector3 currentPosition, ref float pathPosition, float maxSpeed, float smoothnessFactor, EasingType ease, bool easeIn, bool easeOut) { maxSpeed *= Time.deltaTime; pathPosition = Clamp(pathPosition); var goal = InterpConstantSpeed(pts, pathPosition, ease, easeIn, easeOut); float distance; while ((distance = (goal - currentPosition).magnitude) <= maxSpeed && pathPosition != 1) { //currentPosition = goal; //maxSpeed -= distance; pathPosition = Clamp(pathPosition + 1 / smoothnessFactor); goal = InterpConstantSpeed(pts, pathPosition, ease, easeIn, easeOut); } if (distance != 0) { currentPosition = Vector3.MoveTowards(currentPosition, goal, maxSpeed); } return(currentPosition); }
public static void GizmoDraw(Vector3[] pts, float t, EasingType ease, bool easeIn) { GizmoDraw(pts, t, ease, easeIn, true); }
public virtual async UniTask TransitionAsync(Transition transition, float duration, EasingType easingType = EasingType.Linear, CancellationToken cancellationToken = default) { if (transitionTweener.Running) { transitionTweener.CompleteInstantly(); } material.UpdateRandomSeed(); material.TransitionProgress = 0; material.TransitionName = transition.Name; material.TransitionParams = transition.Parameters; if (ObjectUtils.IsValid(transition.DissolveTexture)) { material.DissolveTexture = transition.DissolveTexture; } var transitionTexture = RenderTexture.GetTemporary(cameraManager.Camera.scaledPixelWidth, cameraManager.Camera.scaledPixelHeight); var initialRenderTexture = cameraManager.Camera.targetTexture; cameraManager.Camera.targetTexture = transitionTexture; material.TransitionTexture = transitionTexture; var tween = new FloatTween(material.TransitionProgress, 1, duration, value => material.TransitionProgress = value, false, easingType, material); await transitionTweener.RunAsync(tween, cancellationToken); if (cancellationToken.CancelASAP) { // Try restore camera target texture before cancellation, otherwise it'll mess when rolling back. if (cameraManager != null && cameraManager.Camera) { cameraManager.Camera.targetTexture = initialRenderTexture; } RenderTexture.ReleaseTemporary(transitionTexture); return; } cameraManager.Camera.targetTexture = initialRenderTexture; SetVisibility(false); RenderTexture.ReleaseTemporary(transitionTexture); // In case of rollbacks, revert to the original scene texture. material.TransitionProgress = 0; }
public static Vector3 Velocity(Path pts, float t, EasingType ease, bool easeIn) { return(Velocity(pts, t, ease, easeIn, true)); }
public static Quaternion RotationBetween(Path pts, float t1, float t2, EasingType ease, bool easeIn, bool easeOut) { return(Quaternion.LookRotation(Interp(pts, t2, ease, easeIn, easeOut) - Interp(pts, t1, ease, easeIn, easeOut))); }
public static Quaternion RotationBetween(Path pts, float t1, float t2, EasingType ease, bool easeIn) { return(RotationBetween(pts, t1, t2, ease, easeIn, true)); }
public static Vector3 Velocity(Spline.Path pts, float t, EasingType ease, bool easeIn) { return Spline.Velocity(pts, t, ease, easeIn, true); }
public FloatTween(float from, float to, float time, Action <float> onTween, bool ignoreTimeScale = false, EasingType easingType = default) { StartValue = from; TargetValue = to; TweenDuration = time; EasingType = easingType; IsTimeScaleIgnored = ignoreTimeScale; OnFloatTween = onTween; easingFunction = EasingType.GetEasingFunction(); }
private static float Ease(float t, EasingType ease) { return Spline.Ease(t, ease, true); }
public static Effect EaseDmxValue(Guid queue, int channel, int priority, byte startValue, byte endValue, int duration, EasingType typeIn, EasingType typeOut, EasingExtents extents) { Effect handle = new Effect(queue, channel, priority, startValue, endValue, duration, typeIn, typeOut, extents); QueueEffect(handle); handle.Start(); return(handle); }
public static Vector3 MoveOnPath(Path pts, Vector3 currentPosition, ref float pathPosition, ref Quaternion rotation, float maxSpeed, float smoothnessFactor, EasingType ease, bool easeIn, bool easeOut) { var result = MoveOnPath(pts, currentPosition, ref pathPosition, maxSpeed, smoothnessFactor, ease, easeIn, easeOut); rotation = result.Equals(currentPosition) ? Quaternion.identity : Quaternion.LookRotation(result - currentPosition); return(result); }
public static Effect EaseDmxValue(Guid queue, int channel, int priority, byte startValue, byte endValue, int duration, EasingType typeIn, EasingType typeOut, EasingExtents extents, DateTime when) { Effect handle = new Effect(queue, channel, priority, startValue, endValue, duration, typeIn, typeOut, extents); QueueEffect(handle); handle.StartIn((int)(when - DateTime.Now).TotalMilliseconds); return(handle); }
//constructor /// <summary> /// An object used to smoothly translate a field from start to finish with various types of easing. The tween is automatically started upon creation. /// </summary> /// <param name="onUpdate">The method that is called with the new value every time the tween is updated.</param> /// <param name="start">The starting value of the tween.</param> /// <param name="end">The ending value of the tween.</param> /// <param name="duration">The duration, in milliseconds, of the tween.</param> /// <param name="type">(optional) The type of easing the tween will use.</param> public Tween(Action <double> onUpdate, double start, double end, double duration, EasingType type = EasingType.Linear) { if (onUpdate == null) { throw new ArgumentNullException("setFunc"); } if (double.IsNaN(start) || double.IsInfinity(start)) { throw new InvalidOperationException("start cannot be NaN or infinity."); } if (double.IsNaN(end) || double.IsInfinity(end)) { throw new InvalidOperationException("end cannot be NaN or infinity."); } if (double.IsNaN(duration) || double.IsInfinity(duration)) { throw new InvalidOperationException("duration cannot be NaN or infinity."); } if (type == EasingType.None) { type = EasingType.Linear; } tweens.Add(this); this.onUpdate = onUpdate; _start = start; _end = end; _duration = duration; _type = type; }
/// <summary> /// Returns an <see cref="EasignFunction"/> delegate that implements the /// easing equation defined by the <paramref name="easeType"/> argument. /// </summary> /// <param name="easeType">The easing equation to be used</param> public static TweenEasingCallback GetFunction(EasingType easeType) { switch (easeType) { case EasingType.BackEaseIn: return(EaseInBack); case EasingType.BackEaseInOut: return(EaseInOutBack); case EasingType.BackEaseOut: return(EaseOutBack); case EasingType.Bounce: return(Bounce); case EasingType.CircEaseIn: return(EaseInCirc); case EasingType.CircEaseInOut: return(EaseInOutCirc); case EasingType.CircEaseOut: return(EaseOutCirc); case EasingType.CubicEaseIn: return(EaseInCubic); case EasingType.CubicEaseInOut: return(EaseInOutCubic); case EasingType.CubicEaseOut: return(EaseOutCubic); case EasingType.ExpoEaseIn: return(EaseInExpo); case EasingType.ExpoEaseInOut: return(EaseInOutExpo); case EasingType.ExpoEaseOut: return(EaseOutExpo); case EasingType.Linear: return(Linear); case EasingType.QuadEaseIn: return(EaseInQuad); case EasingType.QuadEaseInOut: return(EaseInOutQuad); case EasingType.QuadEaseOut: return(EaseOutQuad); case EasingType.QuartEaseIn: return(EaseInQuart); case EasingType.QuartEaseInOut: return(EaseInOutQuart); case EasingType.QuartEaseOut: return(EaseOutQuart); case EasingType.QuintEaseIn: return(EaseInQuint); case EasingType.QuintEaseInOut: return(EaseInOutQuint); case EasingType.QuintEaseOut: return(EaseOutQuint); case EasingType.SineEaseIn: return(EaseInSine); case EasingType.SineEaseInOut: return(EaseInOutSine); case EasingType.SineEaseOut: return(EaseOutSine); case EasingType.Spring: return(Spring); } throw new System.NotImplementedException(); }
public abstract INormalizedKeyFrameAnimationBuilder <T> ExpressionKeyFrame( double progress, string expression, EasingType easingType, EasingMode easingMode);
// Fallback with dynamic typing public AniMator(System.Object sta, System.Object end, System.Object chg, float dur, float delay, AnimationEasingType eas, EasingType typ, AnimationDriveType d) { startValue = sta; endValue = end; change = chg; Setup(dur, delay, eas, typ, d); }
private static float Ease(float t, EasingType ease) { return(Ease(t, ease, true)); }
public static Vector3 InterpConstantSpeed(Path pts, float t, EasingType ease, bool easeIn) { return(InterpConstantSpeed(pts, t, ease, easeIn, true)); }
public static double ValueAt(double initial, double end, double alpha, EasingType easing) { switch (easing) { default: case EasingType.None: case EasingType.Linear: return((end * alpha) + (initial * (1 - alpha))); case EasingType.QuadIn: { double factor = alpha * alpha; return((end * factor) + (initial * (1 - factor))); } case EasingType.QuadOut: { double factor = (2 - alpha) * alpha; return((end * factor) + (initial * (1 - factor))); } case EasingType.QuadInOut: { double mid = initial + (end - initial) / 2.0; if (alpha <= 0.5) { return(ValueAt(initial, mid, alpha * 2, EasingType.QuadIn)); } else { return(ValueAt(mid, end, (alpha - 0.5) * 2, EasingType.QuadOut)); } } case EasingType.CubeIn: { double factor = alpha * alpha * alpha; return((end * factor) + (initial * (1 - factor))); } case EasingType.CubeOut: { double factor = -(alpha - 1); factor = -(factor * factor * factor) + 1; return((end * factor) + (initial * (1 - factor))); } case EasingType.CubeInOut: { double mid = initial + (end - initial) / 2.0; if (alpha <= 0.5) { return(ValueAt(initial, mid, alpha * 2, EasingType.CubeIn)); } else { return(ValueAt(mid, end, (alpha - 0.5) * 2, EasingType.CubeOut)); } } case EasingType.QuartIn: { double factor = alpha * alpha * alpha * alpha; return((end * factor) + (initial * (1 - factor))); } case EasingType.QuartOut: { double factor = -(alpha - 1); factor = 1 - (factor * factor * factor * factor); return((end * factor) + (initial * (1 - factor))); } case EasingType.QuartInOut: { double mid = initial + (end - initial) / 2.0; if (alpha <= 0.5) { return(ValueAt(initial, mid, alpha * 2, EasingType.QuartIn)); } else { return(ValueAt(mid, end, (alpha - 0.5) * 2, EasingType.QuartOut)); } } case EasingType.QuintIn: { double factor = alpha * alpha * alpha * alpha * alpha; return((end * factor) + (initial * (1 - factor))); } case EasingType.QuintOut: { double factor = -(alpha - 1); factor = 1 - (factor * factor * factor * factor * factor); return((end * factor) + (initial * (1 - factor))); } case EasingType.QuintInOut: { double mid = initial + (end - initial) / 2.0; if (alpha <= 0.5) { return(ValueAt(initial, mid, alpha / 0.5, EasingType.QuintIn)); } else { return(ValueAt(mid, end, (alpha - 0.5) / 0.5, EasingType.QuintOut)); } } case EasingType.SineIn: { double factor = 1 - Math.Cos(Math.PI / 2 * alpha); return((end * factor) + (initial * (1 - factor))); } case EasingType.SineOut: { double factor = Math.Sin(Math.PI / 2 * alpha); return((end * factor) + (initial * (1 - factor))); } case EasingType.SineInOut: { if (alpha <= 0.5) { return(ValueAt(initial, (initial + end) / 2.0, alpha * 2, EasingType.SineIn)); } else { return(ValueAt((initial + end) / 2.0, end, (alpha - 0.5) * 2, EasingType.SineOut)); } } } }
public static float EaseInOut ( double linearStep, EasingType easeInType, EasingType easeOutType ) { return linearStep < 0.5 ? EaseInOut ( linearStep, easeInType ) : EaseInOut ( linearStep, easeOutType ); }
public static Quaternion RotationBetween(Spline.Path pts, float t1, float t2, EasingType ease, bool easeIn) { return Spline.RotationBetween(pts, t1, t2, ease, easeIn, true); }
public static float EaseInOut(double linearStep, EasingType easeInType, EasingType easeOutType) { linearStep = Mathf.Clamp01((float)linearStep); return linearStep < 0.5 ? EaseInOut(linearStep, easeInType) : EaseInOut(linearStep, easeOutType); }
public static void GizmoDraw(Vector3[] pts, float t, EasingType ease, bool easeIn) { Spline.GizmoDraw(pts, t, ease, easeIn, true); }
private static float Ease(float t, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true) { t = Mathf.Clamp01(t); if(easeIn && easeOut) { t = Easing.EaseInOut(t, ease); } else if(easeIn) { t = Easing.EaseIn(t, ease); } else if(easeOut) { t = Easing.EaseOut(t, ease); } return t; }
/// <summary> /// Returns the output of an easing function for a specific time. /// </summary> /// <param name="t">The normalized time</param> /// <param name="easingType">The easing function to use</param> /// <returns>The eased output</returns> public static float Ease(float t, EasingType easingType) { switch (easingType) { case EasingType.ExponentialIn: return(Functions.ExponentialIn(t)); case EasingType.ExponentialOut: return(Functions.ExponentialOut(t)); case EasingType.ExponentialInOut: return(Functions.ExponentialInOut(t)); case EasingType.ExponentialOutIn: return(Functions.ExponentialOutIn(t)); case EasingType.SineIn: return(Functions.SineIn(t)); case EasingType.SineOut: return(Functions.SineOut(t)); case EasingType.SineInOut: return(Functions.SineInOut(t)); case EasingType.SineOutIn: return(Functions.SineOutIn(t)); case EasingType.CubicIn: return(Functions.CubicIn(t)); case EasingType.CubicOut: return(Functions.CubicOut(t)); case EasingType.CubicInOut: return(Functions.CubicInOut(t)); case EasingType.CubicOutIn: return(Functions.CubicOutIn(t)); case EasingType.QuinticIn: return(Functions.QuinticIn(t)); case EasingType.QuinticOut: return(Functions.QuinticOut(t)); case EasingType.QuinticInOut: return(Functions.QuinticInOut(t)); case EasingType.QuinticOutIn: return(Functions.QuinticOutIn(t)); case EasingType.CircularIn: return(Functions.CircularIn(t)); case EasingType.CircularOut: return(Functions.CircularOut(t)); case EasingType.CircularInOut: return(Functions.CircularInOut(t)); case EasingType.CircularOutIn: return(Functions.CircularOutIn(t)); case EasingType.ElasticIn: return(Functions.ElasticIn(t)); case EasingType.ElasticOut: return(Functions.ElasticOut(t)); case EasingType.ElasticInOut: return(Functions.ElasticInOut(t)); case EasingType.ElasticOutIn: return(Functions.ElasticOutIn(t)); case EasingType.QuadraticIn: return(Functions.QuadraticIn(t)); case EasingType.QuadraticOut: return(Functions.QuadraticOut(t)); case EasingType.QuadraticInOut: return(Functions.QuadraticInOut(t)); case EasingType.QuadraticOutIn: return(Functions.QuadraticOutIn(t)); case EasingType.QuarticIn: return(Functions.QuarticIn(t)); case EasingType.QuarticOut: return(Functions.QuarticOut(t)); case EasingType.QuarticInOut: return(Functions.QuarticInOut(t)); case EasingType.QuarticOutIn: return(Functions.QuarticOutIn(t)); case EasingType.BackIn: return(Functions.BackIn(t)); case EasingType.BackOut: return(Functions.BackOut(t)); case EasingType.BackInOut: return(Functions.BackInOut(t)); case EasingType.BackOutIn: return(Functions.BackOutIn(t)); case EasingType.BounceIn: return(Functions.BounceIn(t)); case EasingType.BounceOut: return(Functions.BounceOut(t)); case EasingType.BounceInOut: return(Functions.BounceInOut(t)); case EasingType.BounceOutIn: return(Functions.BounceOutIn(t)); default: return(Functions.Linear(t)); } }
public static Vector3 MoveOnPath(Path pts, Vector3 currentPosition, ref float pathPosition, ref Quaternion rotation, float maxSpeed=1f, float smoothnessFactor=100, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true) { var result = MoveOnPath(pts, currentPosition, ref pathPosition, maxSpeed, smoothnessFactor, ease, easeIn, easeOut); rotation = result.Equals(currentPosition) ? Quaternion.identity : Quaternion.LookRotation(result - currentPosition); return result; }
private static float Ease(float t, EasingType ease, bool easeIn) { return Spline.Ease(t, ease, easeIn, true); }
public static Vector3 Velocity(Path pts, float t, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true) { t = Ease(t); if(pts.Length == 0) { return Vector3.zero; } else if(pts.Length ==1 ) { return pts[0]; } else if(pts.Length == 2) { return Vector3.Lerp(pts[0], pts[1], t); } else if(pts.Length == 3) { return QuadBez.Velocity(pts[0], pts[2], pts[1], t); } else if(pts.Length == 4) { return CubicBez.Velocity(pts[0], pts[3], pts[1], pts[2], t); } else { return CRSpline.Velocity(Wrap(pts), t); } }
public static Vector3 Interp(Spline.Path pts, float t, EasingType ease) { return Spline.Interp(pts, t, ease, true); }
public static Vector3 MoveOnPath(Path pts, Vector3 currentPosition, ref float pathPosition, ref Quaternion rotation, float maxSpeed, float smoothnessFactor, EasingType ease, bool easeIn) { return(MoveOnPath(pts, currentPosition, ref pathPosition, ref rotation, maxSpeed, smoothnessFactor, ease, easeIn, true)); }
public static Vector3 InterpConstantSpeed(Spline.Path pts, float t, EasingType ease, bool easeIn) { return Spline.InterpConstantSpeed(pts, t, ease, easeIn, true); }
/// <summary> /// Animates the scale of the the specified UIElement. /// </summary> /// <param name="animationSet">The animationSet object.</param> /// <param name="scaleX">The scale on the x axis.</param> /// <param name="scaleY">The scale on the y axis.</param> /// <param name="centerX">The center x in pixels.</param> /// <param name="centerY">The center y in pixels.</param> /// <param name="duration">The duration in milliseconds.</param> /// <param name="delay">The delay in milliseconds. (ignored if duration == 0)</param> /// <param name="easingType">Used to describe how the animation interpolates between keyframes.</param> /// <returns> /// An AnimationSet. /// </returns> public static AnimationSet Scale( this AnimationSet animationSet, float scaleX = 1f, float scaleY = 1f, float centerX = 0f, float centerY = 0f, double duration = 500d, double delay = 0d, EasingType easingType = EasingType.Default) { if (animationSet == null) { return(null); } if (!AnimationSet.UseComposition) { var element = animationSet.Element; var transform = GetAttachedCompositeTransform(element); transform.CenterX = centerX; transform.CenterY = centerY; var animationX = new DoubleAnimation(); var animationY = new DoubleAnimation(); animationX.To = scaleX; animationY.To = scaleY; animationX.Duration = animationY.Duration = TimeSpan.FromMilliseconds(duration); animationX.BeginTime = animationY.BeginTime = TimeSpan.FromMilliseconds(delay); animationX.EasingFunction = animationY.EasingFunction = GetEasingFunction(easingType); animationSet.AddStoryboardAnimation(GetAnimationPath(transform, element, "ScaleX"), animationX); animationSet.AddStoryboardAnimation(GetAnimationPath(transform, element, "ScaleY"), animationY); } else { var visual = animationSet.Visual; visual.CenterPoint = new Vector3(centerX, centerY, 0); var scaleVector = new Vector3(scaleX, scaleY, 1.0f); if (duration <= 0) { animationSet.AddCompositionDirectPropertyChange("Scale", scaleVector); return(animationSet); } var compositor = visual.Compositor; if (compositor == null) { return(null); } var animation = compositor.CreateVector3KeyFrameAnimation(); animation.Duration = TimeSpan.FromMilliseconds(duration); animation.DelayTime = TimeSpan.FromMilliseconds(delay); animation.InsertKeyFrame(1f, scaleVector); animationSet.AddCompositionAnimation("Scale", animation); } return(animationSet); }
public static float EaseWithReturn(double linearStep, EasingType ease) { linearStep = (double)Mathf.Clamp01((float)linearStep); var amount = linearStep > 0.5 ? 1+((0.5-linearStep)*2) : (linearStep * 2); return EaseOut(amount, ease); }
public static EasingEquation GetEquation(EasingType type) { switch (type) { case EasingType.Linear: return(Easing.Linear); case EasingType.EaseInQuad: return(Easing.EaseInQuad); case EasingType.EaseOutQuad: return(Easing.EaseOutQuad); case EasingType.EaseInOutQuad: return(Easing.EaseInOutQuad); case EasingType.EaseOutInQuad: return(Easing.EaseOutInQuad); case EasingType.EaseInCubic: return(Easing.EaseInCubic); case EasingType.EaseOutCubic: return(Easing.EaseOutCubic); case EasingType.EaseInOutCubic: return(Easing.EaseInOutCubic); case EasingType.EaseOutInCubic: return(Easing.EaseOutInCubic); case EasingType.EaseInQuart: return(Easing.EaseInQuart); case EasingType.EaseOutQuart: return(Easing.EaseOutQuart); case EasingType.EaseInOutQuart: return(Easing.EaseInOutQuart); case EasingType.EaseOutInQuart: return(Easing.EaseOutInQuart); case EasingType.EaseInQuint: return(Easing.EaseInQuint); case EasingType.EaseOutQuint: return(Easing.EaseOutQuint); case EasingType.EaseInOutQuint: return(Easing.EaseInOutQuint); case EasingType.EaseOutInQuint: return(Easing.EaseOutInQuint); case EasingType.EaseInSine: return(Easing.EaseInSine); case EasingType.EaseOutSine: return(Easing.EaseOutSine); case EasingType.EaseInOutSine: return(Easing.EaseInOutSine); case EasingType.EaseOutInSine: return(Easing.EaseOutInSine); case EasingType.EaseInExpo: return(Easing.EaseInExpo); case EasingType.EaseOutExpo: return(Easing.EaseOutExpo); case EasingType.EaseInOutExpo: return(Easing.EaseInOutExpo); case EasingType.EaseOutInExpo: return(Easing.EaseOutInExpo); case EasingType.EaseInCirc: return(Easing.EaseInCirc); case EasingType.EaseOutCirc: return(Easing.EaseOutCirc); case EasingType.EaseInOutCirc: return(Easing.EaseInOutCirc); case EasingType.EaseOutInCirc: return(Easing.EaseOutInCirc); case EasingType.EaseInBack: return(Easing.EaseInBack); case EasingType.EaseOutBack: return(Easing.EaseOutBack); case EasingType.EaseInOutBack: return(Easing.EaseInOutBack); case EasingType.EaseOutInBack: return(Easing.EaseOutInBack); case EasingType.EaseInElastic: return(Easing.EaseInElastic); case EasingType.EaseOutElastic: return(Easing.EaseOutElastic); case EasingType.EaseInOutElastic: return(Easing.EaseInOutElastic); case EasingType.EaseOutInElastic: return(Easing.EaseOutInElastic); case EasingType.EaseInBounce: return(Easing.EaseInBounce); case EasingType.EaseOutBounce: return(Easing.EaseOutBounce); case EasingType.EaseInOutBounce: return(Easing.EaseInOutBounce); case EasingType.EaseOutInBounce: return(Easing.EaseOutInBounce); default: return(null); } }
public override void Vibrate(VibrationMotor motor, double amount, float duration, EasingType easingType) { throw new NotSupportedException(); }
protected virtual async UniTask ApplyAppearanceModificationAsync(TActor actor, EasingType easingType, float duration, CancellationToken cancellationToken) { if (string.IsNullOrEmpty(AssignedAppearance)) { return; } var transitionName = !string.IsNullOrEmpty(AssignedTransition) ? AssignedTransition : TransitionType.Crossfade; var defaultParams = TransitionUtils.GetDefaultParams(transitionName); var transitionParams = Assigned(TransitionParams) ? new Vector4( TransitionParams.ElementAtOrNull(0) ?? defaultParams.x, TransitionParams.ElementAtOrNull(1) ?? defaultParams.y, TransitionParams.ElementAtOrNull(2) ?? defaultParams.z, TransitionParams.ElementAtOrNull(3) ?? defaultParams.w) : defaultParams; if (Assigned(DissolveTexturePath) && !ObjectUtils.IsValid(preloadedDissolveTexture)) { preloadedDissolveTexture = Resources.Load <Texture2D>(DissolveTexturePath); } var transition = new Transition(transitionName, transitionParams, preloadedDissolveTexture); await actor.ChangeAppearanceAsync(AssignedAppearance, duration, easingType, transition, cancellationToken); }
public static Vector3 MoveOnPath(Path pts, Vector3 currentPosition, ref float pathPosition, float maxSpeed=1f, float smoothnessFactor=100, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true) { maxSpeed *= Time.deltaTime; pathPosition = Mathf.Clamp01(pathPosition); var goal = Interp(pts, pathPosition, ease, easeIn, easeOut); float distance; while((distance = (goal - currentPosition).magnitude) <= maxSpeed && pathPosition < 1) { currentPosition = goal; maxSpeed -= distance; pathPosition = Mathf.Clamp01(pathPosition + 1/smoothnessFactor); goal = Interp(pts, pathPosition, ease, easeIn, easeOut); } if(distance != 0) { currentPosition = Vector3.MoveTowards(currentPosition, goal, maxSpeed); } return currentPosition; }
protected virtual async UniTask ApplyVisibilityModificationAsync(TActor actor, EasingType easingType, float duration, CancellationToken cancellationToken) { if (!AssignedVisibility.HasValue) { return; } await actor.ChangeVisibilityAsync(AssignedVisibility.Value, duration, easingType, cancellationToken); }
public static Quaternion RotationBetween(Path pts, float t1, float t2, EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true) { return Quaternion.LookRotation(Interp(pts, t2, ease, easeIn, easeOut) - Interp(pts, t1, ease, easeIn, easeOut)); }
protected virtual async UniTask ApplyTintColorModificationAsync(TActor actor, EasingType easingType, float duration, CancellationToken cancellationToken) { if (!AssignedTintColor.HasValue) { return; } await actor.ChangeTintColorAsync(AssignedTintColor.Value, duration, easingType, cancellationToken); }
public static void GizmoDraw(Vector3[] pts, float t,EasingType ease = EasingType.Linear, bool easeIn = true, bool easeOut = true) { Gizmos.color = Color.white; Vector3 prevPt = Interp(pts, 0); for (int i = 1; i <= 20; i++) { float pm = (float) i / 20f; Vector3 currPt = Interp(pts, pm, ease, easeIn, easeOut); Gizmos.DrawLine(currPt, prevPt); prevPt = currPt; } Gizmos.color = Color.blue; Vector3 pos = Interp(pts, t, ease, easeIn, easeOut); Gizmos.DrawLine(pos, pos + Velocity(pts, t, ease, easeIn, easeOut)); }
public static float EaseInOut(double linearStep, EasingType easeInType, EasingType easeOutType) { return(linearStep < 0.5 ? EaseInOut(linearStep, easeInType) : EaseInOut(linearStep, easeOutType)); }