218 lines
5.5 KiB
JavaScript
218 lines
5.5 KiB
JavaScript
import { cond, lessThan, multiply, pow, cos, sqrt, sub, add, divide } from './base';
|
|
import AnimatedBezier from './core/AnimatedBezier';
|
|
/**
|
|
* The `Easing` module implements common easing functions. This module is used
|
|
* by [Animate.timing()](docs/animate.html#timing) to convey physically
|
|
* believable motion in animations.
|
|
*
|
|
* You can find a visualization of some common easing functions at
|
|
* http://easings.net/
|
|
*
|
|
* ### Predefined animations
|
|
*
|
|
* The `Easing` module provides several predefined animations through the
|
|
* following methods:
|
|
*
|
|
* - [`back`](docs/easing.html#back) provides a simple animation where the
|
|
* object goes slightly back before moving forward
|
|
* - [`bounce`](docs/easing.html#bounce) provides a bouncing animation
|
|
* - [`ease`](docs/easing.html#ease) provides a simple inertial animation
|
|
* - [`elastic`](docs/easing.html#elastic) provides a simple spring interaction
|
|
*
|
|
* ### Standard functions
|
|
*
|
|
* Three standard easing functions are provided:
|
|
*
|
|
* - [`linear`](docs/easing.html#linear)
|
|
* - [`quad`](docs/easing.html#quad)
|
|
* - [`cubic`](docs/easing.html#cubic)
|
|
*
|
|
* The [`poly`](docs/easing.html#poly) function can be used to implement
|
|
* quartic, quintic, and other higher power functions.
|
|
*
|
|
* ### Additional functions
|
|
*
|
|
* Additional mathematical functions are provided by the following methods:
|
|
*
|
|
* - [`bezier`](docs/easing.html#bezier) provides a cubic bezier curve
|
|
* - [`circle`](docs/easing.html#circle) provides a circular function
|
|
* - [`sin`](docs/easing.html#sin) provides a sinusoidal function
|
|
* - [`exp`](docs/easing.html#exp) provides an exponential function
|
|
*
|
|
* The following helpers are used to modify other easing functions.
|
|
*
|
|
* - [`in`](docs/easing.html#in) runs an easing function forwards
|
|
* - [`inOut`](docs/easing.html#inout) makes any easing function symmetrical
|
|
* - [`out`](docs/easing.html#out) runs an easing function backwards
|
|
*/
|
|
|
|
export default class Easing {
|
|
/**
|
|
* A linear function, `f(t) = t`. Position correlates to elapsed time one to
|
|
* one.
|
|
*
|
|
* http://cubic-bezier.com/#0,0,1,1
|
|
*/
|
|
static linear(t) {
|
|
return t;
|
|
}
|
|
/**
|
|
* A simple inertial interaction, similar to an object slowly accelerating to
|
|
* speed.
|
|
*
|
|
* http://cubic-bezier.com/#.42,0,1,1
|
|
*/
|
|
|
|
|
|
static ease(t) {
|
|
return new AnimatedBezier(t, 0.42, 0, 1, 1);
|
|
}
|
|
/**
|
|
* A quadratic function, `f(t) = t * t`. Position equals the square of elapsed
|
|
* time.
|
|
*
|
|
* http://easings.net/#easeInQuad
|
|
*/
|
|
|
|
|
|
static quad(t) {
|
|
return multiply(t, t);
|
|
}
|
|
/**
|
|
* A cubic function, `f(t) = t * t * t`. Position equals the cube of elapsed
|
|
* time.
|
|
*
|
|
* http://easings.net/#easeInCubic
|
|
*/
|
|
|
|
|
|
static cubic(t) {
|
|
return multiply(t, t, t);
|
|
}
|
|
/**
|
|
* A power function. Position is equal to the Nth power of elapsed time.
|
|
*
|
|
* n = 4: http://easings.net/#easeInQuart
|
|
* n = 5: http://easings.net/#easeInQuint
|
|
*/
|
|
|
|
|
|
static poly(n) {
|
|
return t => pow(t, n);
|
|
}
|
|
/**
|
|
* A sinusoidal function.
|
|
*
|
|
* http://easings.net/#easeInSine
|
|
*/
|
|
|
|
|
|
static sin(t) {
|
|
return sub(1, cos(multiply(t, Math.PI, 0.5)));
|
|
}
|
|
/**
|
|
* A circular function.
|
|
*
|
|
* http://easings.net/#easeInCirc
|
|
*/
|
|
|
|
|
|
static circle(t) {
|
|
return sub(1, sqrt(sub(1, multiply(t, t))));
|
|
}
|
|
/**
|
|
* An exponential function.
|
|
*
|
|
* http://easings.net/#easeInExpo
|
|
*/
|
|
|
|
|
|
static exp(t) {
|
|
return pow(2, multiply(10, sub(t, 1)));
|
|
}
|
|
/**
|
|
* A simple elastic interaction, similar to a spring oscillating back and
|
|
* forth.
|
|
*
|
|
* Default bounciness is 1, which overshoots a little bit once. 0 bounciness
|
|
* doesn't overshoot at all, and bounciness of N > 1 will overshoot about N
|
|
* times.
|
|
*
|
|
* http://easings.net/#easeInElastic
|
|
*/
|
|
|
|
|
|
static elastic(bounciness = 1) {
|
|
const p = bounciness * Math.PI;
|
|
return t => sub(1, multiply(pow(cos(multiply(t, Math.PI, 0.5)), 3), cos(multiply(t, p))));
|
|
}
|
|
/**
|
|
* Use with `Animated.parallel()` to create a simple effect where the object
|
|
* animates back slightly as the animation starts.
|
|
*
|
|
* Wolfram Plot:
|
|
*
|
|
* - http://tiny.cc/back_default (s = 1.70158, default)
|
|
*/
|
|
|
|
|
|
static back(s) {
|
|
if (s === undefined) {
|
|
s = 1.70158;
|
|
}
|
|
|
|
return t => multiply(t, t, sub(multiply(add(s, 1), t), s));
|
|
}
|
|
/**
|
|
* Provides a simple bouncing effect.
|
|
*
|
|
* http://easings.net/#easeInBounce
|
|
*/
|
|
|
|
|
|
static bounce(t) {
|
|
const sq = v => multiply(7.5625, v, v);
|
|
|
|
return cond(lessThan(t, 1 / 2.75), sq(t), cond(lessThan(t, 2 / 2.75), add(0.75, sq(sub(t, 1.5 / 2.75))), cond(lessThan(t, 2.5 / 2.76), add(0.9375, sq(sub(t, 2.25 / 2.75))), add(0.984375, sq(sub(t, 2.625 / 2.75))))));
|
|
}
|
|
/**
|
|
* Provides a cubic bezier curve, equivalent to CSS Transitions'
|
|
* `transition-timing-function`.
|
|
*
|
|
* A useful tool to visualize cubic bezier curves can be found at
|
|
* http://cubic-bezier.com/
|
|
*/
|
|
|
|
|
|
static bezier(x1, y1, x2, y2) {
|
|
return t => new AnimatedBezier(t, x1, y1, x2, y2);
|
|
}
|
|
/**
|
|
* Runs an easing function forwards.
|
|
*/
|
|
|
|
|
|
static in(easing) {
|
|
return easing;
|
|
}
|
|
/**
|
|
* Runs an easing function backwards.
|
|
*/
|
|
|
|
|
|
static out(easing) {
|
|
return t => sub(1, easing(sub(1, t)));
|
|
}
|
|
/**
|
|
* Makes any easing function symmetrical. The easing function will run
|
|
* forwards for half of the duration, then backwards for the rest of the
|
|
* duration.
|
|
*/
|
|
|
|
|
|
static inOut(easing) {
|
|
return t => cond(lessThan(t, 0.5), divide(easing(multiply(t, 2)), 2), sub(1, divide(easing(multiply(sub(1, t), 2)), 2)));
|
|
}
|
|
|
|
}
|
|
//# sourceMappingURL=Easing.js.map
|