flutter / mirrors / flutter / refs/tags/v1.14.6 / . / packages / flutter / lib / src / animation / curves.dart

// Copyright 2014 The Flutter Authors. All rights reserved. | |

// Use of this source code is governed by a BSD-style license that can be | |

// found in the LICENSE file. | |

import 'dart:math' as math; | |

import 'dart:ui'; | |

import 'package:flutter/foundation.dart'; | |

/// An abstract class providing an interface for evaluating a parametric curve. | |

/// | |

/// A parametric curve transforms a parameter (hence the name) `t` along a curve | |

/// to the value of the curve at that value of `t`. The curve can be of | |

/// arbitrary dimension, but is typically a 1D, 2D, or 3D curve. | |

/// | |

/// See also: | |

/// | |

/// * [Curve], a 1D animation easing curve that starts at 0.0 and ends at 1.0. | |

/// * [Curve2D], a parametric curve that transforms the parameter to a 2D point. | |

abstract class ParametricCurve<T> { | |

/// Abstract const constructor to enable subclasses to provide | |

/// const constructors so that they can be used in const expressions. | |

const ParametricCurve(); | |

/// Returns the value of the curve at point `t`. | |

/// | |

/// This method asserts that t is between 0 and 1 before delegating to | |

/// [transformInternal]. | |

/// | |

/// It is recommended that subclasses override [transformInternal] instead of | |

/// this function, as the above case is already handled in the default | |

/// implementation of [transform], which delegates the remaining logic to | |

/// [transformInternal]. | |

T transform(double t) { | |

assert(t != null); | |

assert(t >= 0.0 && t <= 1.0, 'parametric value $t is outside of [0, 1] range.'); | |

return transformInternal(t); | |

} | |

/// Returns the value of the curve at point `t`. | |

/// | |

/// The given parametric value `t` will be between 0.0 and 1.0, inclusive. | |

@protected | |

T transformInternal(double t) { | |

throw UnimplementedError(); | |

} | |

@override | |

String toString() => '${objectRuntimeType(this, 'ParametricCurve')}'; | |

} | |

/// An parametric animation easing curve, i.e. a mapping of the unit interval to | |

/// the unit interval. | |

/// | |

/// Easing curves are used to adjust the rate of change of an animation over | |

/// time, allowing them to speed up and slow down, rather than moving at a | |

/// constant rate. | |

/// | |

/// A [Curve] must map t=0.0 to 0.0 and t=1.0 to 1.0. | |

/// | |

/// See also: | |

/// | |

/// * [Curves], a collection of common animation easing curves. | |

/// * [CurveTween], which can be used to apply a [Curve] to an [Animation]. | |

/// * [Canvas.drawArc], which draws an arc, and has nothing to do with easing | |

/// curves. | |

/// * [Animatable], for a more flexible interface that maps fractions to | |

/// arbitrary values. | |

@immutable | |

abstract class Curve extends ParametricCurve<double> { | |

/// Abstract const constructor to enable subclasses to provide | |

/// const constructors so that they can be used in const expressions. | |

const Curve(); | |

/// Returns the value of the curve at point `t`. | |

/// | |

/// This function must ensure the following: | |

/// - The value of `t` must be between 0.0 and 1.0 | |

/// - Values of `t`=0.0 and `t`=1.0 must be mapped to 0.0 and 1.0, | |

/// respectively. | |

/// | |

/// It is recommended that subclasses override [transformInternal] instead of | |

/// this function, as the above cases are already handled in the default | |

/// implementation of [transform], which delegates the remaining logic to | |

/// [transformInternal]. | |

@override | |

double transform(double t) { | |

if (t == 0.0 || t == 1.0) { | |

return t; | |

} | |

return super.transform(t); | |

} | |

/// Returns a new curve that is the reversed inversion of this one. | |

/// | |

/// This is often useful with [CurvedAnimation.reverseCurve]. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_bounce_in.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_flipped.mp4} | |

/// | |

/// See also: | |

/// | |

/// * [FlippedCurve], the class that is used to implement this getter. | |

/// * [ReverseAnimation], which reverses an [Animation] rather than a [Curve]. | |

/// * [CurvedAnimation], which can take a separate curve and reverse curve. | |

Curve get flipped => FlippedCurve(this); | |

} | |

/// The identity map over the unit interval. | |

/// | |

/// See [Curves.linear] for an instance of this class. | |

class _Linear extends Curve { | |

const _Linear._(); | |

@override | |

double transformInternal(double t) => t; | |

} | |

/// A sawtooth curve that repeats a given number of times over the unit interval. | |

/// | |

/// The curve rises linearly from 0.0 to 1.0 and then falls discontinuously back | |

/// to 0.0 each iteration. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_sawtooth.mp4} | |

class SawTooth extends Curve { | |

/// Creates a sawtooth curve. | |

/// | |

/// The [count] argument must not be null. | |

const SawTooth(this.count) : assert(count != null); | |

/// The number of repetitions of the sawtooth pattern in the unit interval. | |

final int count; | |

@override | |

double transformInternal(double t) { | |

t *= count; | |

return t - t.truncateToDouble(); | |

} | |

@override | |

String toString() { | |

return '${objectRuntimeType(this, 'SawTooth')}($count)'; | |

} | |

} | |

/// A curve that is 0.0 until [begin], then curved (according to [curve]) from | |

/// 0.0 at [begin] to 1.0 at [end], then remains 1.0 past [end]. | |

/// | |

/// An [Interval] can be used to delay an animation. For example, a six second | |

/// animation that uses an [Interval] with its [begin] set to 0.5 and its [end] | |

/// set to 1.0 will essentially become a three-second animation that starts | |

/// three seconds later. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_interval.mp4} | |

class Interval extends Curve { | |

/// Creates an interval curve. | |

/// | |

/// The arguments must not be null. | |

const Interval(this.begin, this.end, { this.curve = Curves.linear }) | |

: assert(begin != null), | |

assert(end != null), | |

assert(curve != null); | |

/// The largest value for which this interval is 0.0. | |

/// | |

/// From t=0.0 to t=`begin`, the interval's value is 0.0. | |

final double begin; | |

/// The smallest value for which this interval is 1.0. | |

/// | |

/// From t=`end` to t=1.0, the interval's value is 1.0. | |

final double end; | |

/// The curve to apply between [begin] and [end]. | |

final Curve curve; | |

@override | |

double transformInternal(double t) { | |

assert(begin >= 0.0); | |

assert(begin <= 1.0); | |

assert(end >= 0.0); | |

assert(end <= 1.0); | |

assert(end >= begin); | |

t = ((t - begin) / (end - begin)).clamp(0.0, 1.0) as double; | |

if (t == 0.0 || t == 1.0) | |

return t; | |

return curve.transform(t); | |

} | |

@override | |

String toString() { | |

if (curve is! _Linear) | |

return '${objectRuntimeType(this, 'Interval')}($begin\u22EF$end)\u27A9$curve'; | |

return '${objectRuntimeType(this, 'Interval')}($begin\u22EF$end)'; | |

} | |

} | |

/// A curve that is 0.0 until it hits the threshold, then it jumps to 1.0. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_threshold.mp4} | |

class Threshold extends Curve { | |

/// Creates a threshold curve. | |

/// | |

/// The [threshold] argument must not be null. | |

const Threshold(this.threshold) : assert(threshold != null); | |

/// The value before which the curve is 0.0 and after which the curve is 1.0. | |

/// | |

/// When t is exactly [threshold], the curve has the value 1.0. | |

final double threshold; | |

@override | |

double transformInternal(double t) { | |

assert(threshold >= 0.0); | |

assert(threshold <= 1.0); | |

return t < threshold ? 0.0 : 1.0; | |

} | |

} | |

/// A cubic polynomial mapping of the unit interval. | |

/// | |

/// The [Curves] class contains some commonly used cubic curves: | |

/// | |

/// * [Curves.ease] | |

/// * [Curves.easeIn] | |

/// * [Curves.easeOut] | |

/// * [Curves.easeInOut] | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out.mp4} | |

/// | |

/// The [Cubic] class implements third-order Bézier curves. | |

/// | |

/// See also: | |

/// | |

/// * [Curves], where many more predefined curves are available. | |

/// * [CatmullRomCurve], a curve which passes through specific values. | |

class Cubic extends Curve { | |

/// Creates a cubic curve. | |

/// | |

/// Rather than creating a new instance, consider using one of the common | |

/// cubic curves in [Curves]. | |

/// | |

/// The [a], [b], [c], and [d] arguments must not be null. | |

const Cubic(this.a, this.b, this.c, this.d) | |

: assert(a != null), | |

assert(b != null), | |

assert(c != null), | |

assert(d != null); | |

/// The x coordinate of the first control point. | |

/// | |

/// The line through the point (0, 0) and the first control point is tangent | |

/// to the curve at the point (0, 0). | |

final double a; | |

/// The y coordinate of the first control point. | |

/// | |

/// The line through the point (0, 0) and the first control point is tangent | |

/// to the curve at the point (0, 0). | |

final double b; | |

/// The x coordinate of the second control point. | |

/// | |

/// The line through the point (1, 1) and the second control point is tangent | |

/// to the curve at the point (1, 1). | |

final double c; | |

/// The y coordinate of the second control point. | |

/// | |

/// The line through the point (1, 1) and the second control point is tangent | |

/// to the curve at the point (1, 1). | |

final double d; | |

static const double _cubicErrorBound = 0.001; | |

double _evaluateCubic(double a, double b, double m) { | |

return 3 * a * (1 - m) * (1 - m) * m + | |

3 * b * (1 - m) * m * m + | |

m * m * m; | |

} | |

@override | |

double transformInternal(double t) { | |

double start = 0.0; | |

double end = 1.0; | |

while (true) { | |

final double midpoint = (start + end) / 2; | |

final double estimate = _evaluateCubic(a, c, midpoint); | |

if ((t - estimate).abs() < _cubicErrorBound) | |

return _evaluateCubic(b, d, midpoint); | |

if (estimate < t) | |

start = midpoint; | |

else | |

end = midpoint; | |

} | |

} | |

@override | |

String toString() { | |

return '${objectRuntimeType(this, 'Cubic')}(${a.toStringAsFixed(2)}, ${b.toStringAsFixed(2)}, ${c.toStringAsFixed(2)}, ${d.toStringAsFixed(2)})'; | |

} | |

} | |

/// Abstract class that defines an API for evaluating 2D parametric curves. | |

/// | |

/// [Curve2D] differs from [Curve] in that the values interpolated are [Offset] | |

/// values instead of [double] values, hence the "2D" in the name. They both | |

/// take a single double `t` that has a range of 0.0 to 1.0, inclusive, as input | |

/// to the [transform] function . Unlike [Curve], [Curve2D] is not required to | |

/// map `t=0.0` and `t=1.0` to specific output values. | |

/// | |

/// The interpolated `t` value given to [transform] represents the progression | |

/// along the curve, but it doesn't necessarily progress at a constant velocity, so | |

/// incrementing `t` by, say, 0.1 might move along the curve by quite a lot at one | |

/// part of the curve, or hardly at all in another part of the curve, depending | |

/// on the definition of the curve. | |

/// | |

/// {@tool sample --template=stateless_widget_material} | |

/// This example shows how to use a [Curve2D] to modify the position of a widget | |

/// so that it can follow an arbitrary path. | |

/// | |

/// ```dart preamble | |

/// // This is the path that the child will follow. It's a CatmullRomSpline so | |

/// // that the coordinates can be specified that it must pass through. If the | |

/// // tension is set to 1.0, it will linearly interpolate between those points, | |

/// // instead of interpolating smoothly. | |

/// final CatmullRomSpline path = CatmullRomSpline( | |

/// const <Offset>[ | |

/// Offset(0.05, 0.75), | |

/// Offset(0.18, 0.23), | |

/// Offset(0.32, 0.04), | |

/// Offset(0.73, 0.5), | |

/// Offset(0.42, 0.74), | |

/// Offset(0.73, 0.01), | |

/// Offset(0.93, 0.93), | |

/// Offset(0.05, 0.75), | |

/// ], | |

/// startHandle: Offset(0.93, 0.93), | |

/// endHandle: Offset(0.18, 0.23), | |

/// tension: 0.0, | |

/// ); | |

/// | |

/// class FollowCurve2D extends StatefulWidget { | |

/// const FollowCurve2D({ | |

/// Key key, | |

/// @required this.path, | |

/// this.curve = Curves.easeInOut, | |

/// @required this.child, | |

/// this.duration = const Duration(seconds: 1), | |

/// }) : assert(path != null), | |

/// assert(curve != null), | |

/// assert(child != null), | |

/// assert(duration != null), | |

/// super(key: key); | |

/// | |

/// final Curve2D path; | |

/// final Curve curve; | |

/// final Duration duration; | |

/// final Widget child; | |

/// | |

/// @override | |

/// _FollowCurve2DState createState() => _FollowCurve2DState(); | |

/// } | |

/// | |

/// class _FollowCurve2DState extends State<FollowCurve2D> with TickerProviderStateMixin { | |

/// // The animation controller for this animation. | |

/// AnimationController controller; | |

/// // The animation that will be used to apply the widget's animation curve. | |

/// Animation<double> animation; | |

/// | |

/// @override | |

/// void initState() { | |

/// super.initState(); | |

/// controller = AnimationController(duration: widget.duration, vsync: this); | |

/// animation = CurvedAnimation(parent: controller, curve: widget.curve); | |

/// // Have the controller repeat indefinitely. If you want it to "bounce" back | |

/// // and forth, set the reverse parameter to true. | |

/// controller.repeat(reverse: false); | |

/// controller.addListener(() => setState(() {})); | |

/// } | |

/// | |

/// @override | |

/// void dispose() { | |

/// super.dispose(); | |

/// // Always have to dispose of animation controllers when done. | |

/// controller.dispose(); | |

/// } | |

/// | |

/// @override | |

/// Widget build(BuildContext context) { | |

/// // Scale the path values to match the -1.0 to 1.0 domain of the Alignment widget. | |

/// final Offset position = widget.path.transform(animation.value) * 2.0 - Offset(1.0, 1.0); | |

/// return Align( | |

/// alignment: Alignment(position.dx, position.dy), | |

/// child: widget.child, | |

/// ); | |

/// } | |

/// } | |

/// ``` | |

/// | |

/// ```dart | |

/// Widget build(BuildContext context) { | |

/// return Container( | |

/// color: Colors.white, | |

/// alignment: Alignment.center, | |

/// child: FollowCurve2D( | |

/// path: path, | |

/// curve: Curves.easeInOut, | |

/// duration: const Duration(seconds: 3), | |

/// child: CircleAvatar( | |

/// backgroundColor: Colors.yellow, | |

/// child: DefaultTextStyle( | |

/// style: Theme.of(context).textTheme.headline6, | |

/// child: Text("B"), // Buzz, buzz! | |

/// ), | |

/// ), | |

/// ), | |

/// ); | |

/// } | |

/// ``` | |

/// {@end-tool} | |

/// | |

abstract class Curve2D extends ParametricCurve<Offset> { | |

/// Abstract const constructor to enable subclasses to provide const | |

/// constructors so that they can be used in const expressions. | |

const Curve2D(); | |

/// Generates a list of samples with a recursive subdivision until a tolerance | |

/// of `tolerance` is reached. | |

/// | |

/// Samples are generated in order. | |

/// | |

/// Samples can be used to render a curve efficiently, since the samples | |

/// constitute line segments which vary in size with the curvature of the | |

/// curve. They can also be used to quickly approximate the value of the curve | |

/// by searching for the desired range in X and linearly interpolating between | |

/// samples to obtain an approximation of Y at the desired X value. The | |

/// implementation of [CatmullRomCurve] uses samples for this purpose | |

/// internally. | |

/// | |

/// The tolerance is computed as the area of a triangle formed by a new point | |

/// and the preceding and following point. | |

/// | |

/// See also: | |

/// | |

/// * Luiz Henrique de Figueire's Graphics Gem on [the algorithm](http://ariel.chronotext.org/dd/defigueiredo93adaptive.pdf). | |

Iterable<Curve2DSample> generateSamples({ | |

double start = 0.0, | |

double end = 1.0, | |

double tolerance = 1e-10, | |

}) { | |

// The sampling algorithm is: | |

// 1. Evaluate the area of the triangle (a proxy for the "flatness" of the | |

// curve) formed by two points and a test point. | |

// 2. If the area of the triangle is small enough (below tolerance), then | |

// the two points form the final segment. | |

// 3. If the area is still too large, divide the interval into two parts | |

// using a random subdivision point to avoid aliasing. | |

// 4. Recursively sample the two parts. | |

// | |

// This algorithm concentrates samples in areas of high curvature. | |

assert(tolerance != null); | |

assert(start != null); | |

assert(end != null); | |

assert(end > start); | |

// We want to pick a random seed that will keep the result stable if | |

// evaluated again, so we use the first non-generated control point. | |

final math.Random rand = math.Random(samplingSeed); | |

bool isFlat(Offset p, Offset q, Offset r) { | |

// Calculates the area of the triangle given by the three points. | |

final Offset pr = p - r; | |

final Offset qr = q - r; | |

final double z = pr.dx * qr.dy - qr.dx * pr.dy; | |

return (z * z) < tolerance; | |

} | |

final Curve2DSample first = Curve2DSample(start, transform(start)); | |

final Curve2DSample last = Curve2DSample(end, transform(end)); | |

final List<Curve2DSample> samples = <Curve2DSample>[first]; | |

void sample(Curve2DSample p, Curve2DSample q, {bool forceSubdivide = false}) { | |

// Pick a random point somewhat near the center, which avoids aliasing | |

// problems with periodic curves. | |

final double t = p.t + (0.45 + 0.1 * rand.nextDouble()) * (q.t - p.t); | |

final Curve2DSample r = Curve2DSample(t, transform(t)); | |

if (!forceSubdivide && isFlat(p.value, q.value, r.value)) { | |

samples.add(q); | |

} else { | |

sample(p, r); | |

sample(r, q); | |

} | |

} | |

// If the curve starts and ends on the same point, then we force it to | |

// subdivide at least once, because otherwise it will terminate immediately. | |

sample( | |

first, | |

last, | |

forceSubdivide: (first.value.dx - last.value.dx).abs() < tolerance && (first.value.dy - last.value.dy).abs() < tolerance, | |

); | |

return samples; | |

} | |

/// Returns a seed value used by [generateSamples] to seed a random number | |

/// generator to avoid sample aliasing. | |

/// | |

/// Subclasses should override this and provide a custom seed. | |

/// | |

/// The value returned should be the same each time it is called, unless the | |

/// curve definition changes. | |

@protected | |

int get samplingSeed => 0; | |

/// Returns the parameter `t` that corresponds to the given x value of the spline. | |

/// | |

/// This will only work properly for curves which are single-valued in x | |

/// (where every value of `x` maps to only one value in 'y', i.e. the curve | |

/// does not loop or curve back over itself). For curves that are not | |

/// single-valued, it will return the parameter for only one of the values at | |

/// the given `x` location. | |

double findInverse(double x) { | |

assert(x != null); | |

double start = 0.0; | |

double end = 1.0; | |

double mid; | |

double offsetToOrigin(double pos) => x - transform(pos).dx; | |

// Use a binary search to find the inverse point within 1e-6, or 100 | |

// subdivisions, whichever comes first. | |

const double errorLimit = 1e-6; | |

int count = 100; | |

final double startValue = offsetToOrigin(start); | |

while ((end - start) / 2.0 > errorLimit && count > 0) { | |

mid = (end + start) / 2.0; | |

final double value = offsetToOrigin(mid); | |

if (value.sign == startValue.sign) { | |

start = mid; | |

} else { | |

end = mid; | |

} | |

count--; | |

} | |

return mid; | |

} | |

} | |

/// A class that holds a sample of a 2D parametric curve, containing the [value] | |

/// (the X, Y coordinates) of the curve at the parametric value [t]. | |

/// | |

/// See also: | |

/// | |

/// * [Curve2D.generateSamples], which generates samples of this type. | |

/// * [Curve2D], a parametric curve that maps a double parameter to a 2D location. | |

class Curve2DSample { | |

/// A const constructor for the sample so that subclasses can be const. | |

/// | |

/// All arguments must not be null. | |

const Curve2DSample(this.t, this.value) : assert(t != null), assert(value != null); | |

/// The parametric location of this sample point along the curve. | |

final double t; | |

/// The value (the X, Y coordinates) of the curve at parametric value [t]. | |

final Offset value; | |

@override | |

String toString() { | |

return '[(${value.dx.toStringAsFixed(2)}, ${value.dy.toStringAsFixed(2)}), ${t.toStringAsFixed(2)}]'; | |

} | |

} | |

/// A 2D spline that passes smoothly through the given control points using a | |

/// centripetal Catmull-Rom spline. | |

/// | |

/// When the curve is evaluated with [transform], the output values will move | |

/// smoothly from one control point to the next, passing through the control | |

/// points. | |

/// | |

/// {@template flutter.animation.curves.catmull_rom_description} | |

/// Unlike most cubic splines, Catmull-Rom splines have the advantage that their | |

/// curves pass through the control points given to them. They are cubic | |

/// polynomial representations, and, in fact, Catmull-Rom splines can be | |

/// converted mathematically into cubic splines. This class implements a | |

/// "centripetal" Catmull-Rom spline. The term centripetal implies that it won't | |

/// form loops or self-intersections within a single segment. | |

/// {@endtemplate} | |

/// | |

/// See also: | |

/// * [Centripetal Catmull–Rom splines](https://en.wikipedia.org/wiki/Centripetal_Catmull%E2%80%93Rom_spline) | |

/// on Wikipedia. | |

/// * [Parameterization and Applications of Catmull-Rom Curves](http://faculty.cs.tamu.edu/schaefer/research/cr_cad.pdf), | |

/// a paper on using Catmull-Rom splines. | |

/// * [CatmullRomCurve], an animation curve that uses a [CatmullRomSpline] as its | |

/// internal representation. | |

class CatmullRomSpline extends Curve2D { | |

/// Constructs a centripetal Catmull-Rom spline curve. | |

/// | |

/// The `controlPoints` argument is a list of four or more points that | |

/// describe the points that the curve must pass through. | |

/// | |

/// The optional `tension` argument controls how tightly the curve approaches | |

/// the given `controlPoints`. It must be in the range 0.0 to 1.0, inclusive. It | |

/// defaults to 0.0, which provides the smoothest curve. A value of 1.0 | |

/// produces a linear interpolation between points. | |

/// | |

/// The optional `endHandle` and `startHandle` points are the beginning and | |

/// ending handle positions. If not specified, they are created automatically | |

/// by extending the line formed by the first and/or last line segment in the | |

/// `controlPoints`, respectively. The spline will not go through these handle | |

/// points, but they will affect the slope of the line at the beginning and | |

/// end of the spline. The spline will attempt to match the slope of the line | |

/// formed by the start or end handle and the neighboring first or last | |

/// control point. The default is chosen so that the slope of the line at the | |

/// ends matches that of the first or last line segment in the control points. | |

/// | |

/// The `tension` and `controlPoints` arguments must not be null, and the | |

/// `controlPoints` list must contain at least four control points to | |

/// interpolate. | |

/// | |

/// The internal curve data structures are lazily computed the first time | |

/// [transform] is called. If you would rather pre-compute the structures, | |

/// use [CatmullRomSpline.precompute] instead. | |

CatmullRomSpline( | |

List<Offset> controlPoints, { | |

double tension = 0.0, | |

Offset startHandle, | |

Offset endHandle, | |

}) : assert(controlPoints != null), | |

assert(tension != null), | |

assert(tension <= 1.0, 'tension $tension must not be greater than 1.0.'), | |

assert(tension >= 0.0, 'tension $tension must not be negative.'), | |

assert(controlPoints.length > 3, 'There must be at least four control points to create a CatmullRomSpline.'), | |

_controlPoints = controlPoints, | |

_startHandle = startHandle, | |

_endHandle = endHandle, | |

_tension = tension, | |

_cubicSegments = <List<Offset>>[]; | |

/// Constructs a centripetal Catmull-Rom spline curve. | |

/// | |

/// The same as [new CatmullRomSpline], except that the internal data | |

/// structures are precomputed instead of being computed lazily. | |

CatmullRomSpline.precompute( | |

List<Offset> controlPoints, { | |

double tension = 0.0, | |

Offset startHandle, | |

Offset endHandle, | |

}) : assert(controlPoints != null), | |

assert(tension != null), | |

assert(tension <= 1.0, 'tension $tension must not be greater than 1.0.'), | |

assert(tension >= 0.0, 'tension $tension must not be negative.'), | |

assert(controlPoints.length > 3, 'There must be at least four control points to create a CatmullRomSpline.'), | |

_controlPoints = null, | |

_startHandle = null, | |

_endHandle = null, | |

_tension = null, | |

_cubicSegments = _computeSegments(controlPoints, tension, startHandle: startHandle, endHandle: endHandle); | |

static List<List<Offset>> _computeSegments( | |

List<Offset> controlPoints, | |

double tension, { | |

Offset startHandle, | |

Offset endHandle, | |

}) { | |

// If not specified, select the first and last control points (which are | |

// handles: they are not intersected by the resulting curve) so that they | |

// extend the first and last segments, respectively. | |

startHandle ??= controlPoints[0] * 2.0 - controlPoints[1]; | |

endHandle ??= controlPoints.last * 2.0 - controlPoints[controlPoints.length - 2]; | |

final List<Offset> allPoints = <Offset>[ | |

startHandle, | |

...controlPoints, | |

endHandle, | |

]; | |

// An alpha of 0.5 is what makes it a centripetal Catmull-Rom spline. A | |

// value of 0.0 would make it a uniform Catmull-Rom spline, and a value of | |

// 1.0 would make it a chordal Catmull-Rom spline. Non-centripetal values | |

// for alpha can give self-intersecting behavior or looping within a | |

// segment. | |

const double alpha = 0.5; | |

final double reverseTension = 1.0 - tension; | |

final List<List<Offset>> result = <List<Offset>>[]; | |

for (int i = 0; i < allPoints.length - 3; ++i) { | |

final List<Offset> curve = <Offset>[allPoints[i], allPoints[i + 1], allPoints[i + 2], allPoints[i + 3]]; | |

final Offset diffCurve10 = curve[1] - curve[0]; | |

final Offset diffCurve21 = curve[2] - curve[1]; | |

final Offset diffCurve32 = curve[3] - curve[2]; | |

final double t01 = math.pow(diffCurve10.distance, alpha).toDouble(); | |

final double t12 = math.pow(diffCurve21.distance, alpha).toDouble(); | |

final double t23 = math.pow(diffCurve32.distance, alpha).toDouble(); | |

final Offset m1 = (diffCurve21 + (diffCurve10 / t01 - (curve[2] - curve[0]) / (t01 + t12)) * t12) * reverseTension; | |

final Offset m2 = (diffCurve21 + (diffCurve32 / t23 - (curve[3] - curve[1]) / (t12 + t23)) * t12) * reverseTension; | |

final Offset sumM12 = m1 + m2; | |

final List<Offset> segment = <Offset>[ | |

diffCurve21 * -2.0 + sumM12, | |

diffCurve21 * 3.0 - m1 - sumM12, | |

m1, | |

curve[1], | |

]; | |

result.add(segment); | |

} | |

return result; | |

} | |

// The list of control point lists for each cubic segment of the spline. | |

final List<List<Offset>> _cubicSegments; | |

// This is non-empty only if the _cubicSegments are being computed lazily. | |

final List<Offset> _controlPoints; | |

final Offset _startHandle; | |

final Offset _endHandle; | |

final double _tension; | |

void _initializeIfNeeded() { | |

if (_cubicSegments.isNotEmpty) { | |

return; | |

} | |

_cubicSegments.addAll( | |

_computeSegments(_controlPoints, _tension, startHandle: _startHandle, endHandle: _endHandle), | |

); | |

} | |

@override | |

@protected | |

int get samplingSeed { | |

_initializeIfNeeded(); | |

final Offset seedPoint = _cubicSegments[0][1]; | |

return ((seedPoint.dx + seedPoint.dy) * 10000).round(); | |

} | |

@override | |

Offset transformInternal(double t) { | |

_initializeIfNeeded(); | |

final double length = _cubicSegments.length.toDouble(); | |

double position; | |

double localT; | |

int index; | |

if (t < 1.0) { | |

position = t * length; | |

localT = position % 1.0; | |

index = position.floor(); | |

} else { | |

position = length; | |

localT = 1.0; | |

index = _cubicSegments.length - 1; | |

} | |

final List<Offset> cubicControlPoints = _cubicSegments[index]; | |

final double localT2 = localT * localT; | |

return cubicControlPoints[0] * localT2 * localT | |

+ cubicControlPoints[1] * localT2 | |

+ cubicControlPoints[2] * localT | |

+ cubicControlPoints[3]; | |

} | |

} | |

/// An animation easing curve that passes smoothly through the given control | |

/// points using a centripetal Catmull-Rom spline. | |

/// | |

/// When this curve is evaluated with [transform], the values will interpolate | |

/// smoothly from one control point to the next, passing through (0.0, 0.0), the | |

/// given points, and then (1.0, 1.0). | |

/// | |

/// {@macro flutter.animation.curves.catmull_rom_description} | |

/// | |

/// This class uses a centripetal Catmull-Rom curve (a [CatmullRomSpline]) as | |

/// its internal representation. The term centripetal implies that it won't form | |

/// loops or self-intersections within a single segment, and corresponds to a | |

/// Catmull-Rom α (alpha) value of 0.5. | |

/// | |

/// See also: | |

/// | |

/// * [CatmullRomSpline], the 2D spline that this curve uses to generate its values. | |

/// * A Wikipedia article on [centripetal Catmull-Rom splines](https://en.wikipedia.org/wiki/Centripetal_Catmull%E2%80%93Rom_spline). | |

/// * [new CatmullRomCurve] for a description of the constraints put on the | |

/// input control points. | |

/// * This [paper on using Catmull-Rom splines](http://faculty.cs.tamu.edu/schaefer/research/cr_cad.pdf). | |

class CatmullRomCurve extends Curve { | |

/// Constructs a centripetal [CatmullRomCurve]. | |

/// | |

/// It takes a list of two or more points that describe the points that the | |

/// curve must pass through. See [controlPoints] for a description of the | |

/// restrictions placed on control points. In addition to the given | |

/// [controlPoints], the curve will begin with an implicit control point at | |

/// (0.0, 0.0) and end with an implicit control point at (1.0, 1.0), so that | |

/// the curve begins and ends at those points. | |

/// | |

/// The optional [tension] argument controls how tightly the curve approaches | |

/// the given `controlPoints`. It must be in the range 0.0 to 1.0, inclusive. It | |

/// defaults to 0.0, which provides the smoothest curve. A value of 1.0 | |

/// is equivalent to a linear interpolation between points. | |

/// | |

/// The internal curve data structures are lazily computed the first time | |

/// [transform] is called. If you would rather pre-compute the curve, use | |

/// [CatmullRomCurve.precompute] instead. | |

/// | |

/// All of the arguments must not be null. | |

/// | |

/// See also: | |

/// | |

/// * This [paper on using Catmull-Rom splines](http://faculty.cs.tamu.edu/schaefer/research/cr_cad.pdf). | |

CatmullRomCurve(this.controlPoints, {this.tension = 0.0}) | |

: assert(tension != null), | |

assert(() { | |

return validateControlPoints( | |

controlPoints, | |

tension: tension, | |

reasons: _debugAssertReasons..clear(), | |

); | |

}(), 'control points $controlPoints could not be validated:\n ${_debugAssertReasons.join('\n ')}'), | |

// Pre-compute samples so that we don't have to evaluate the spline's inverse | |

// all the time in transformInternal. | |

_precomputedSamples = <Curve2DSample>[]; | |

/// Constructs a centripetal [CatmullRomCurve]. | |

/// | |

/// Same as [new CatmullRomCurve], but it precomputes the internal curve data | |

/// structures for a more predictable computation load. | |

CatmullRomCurve.precompute(this.controlPoints, {this.tension = 0.0}) | |

: assert(tension != null), | |

assert(() { | |

return validateControlPoints( | |

controlPoints, | |

tension: tension, | |

reasons: _debugAssertReasons..clear(), | |

); | |

}(), 'control points $controlPoints could not be validated:\n ${_debugAssertReasons.join('\n ')}'), | |

// Pre-compute samples so that we don't have to evaluate the spline's inverse | |

// all the time in transformInternal. | |

_precomputedSamples = _computeSamples(controlPoints, tension); | |

static List<Curve2DSample> _computeSamples(List<Offset> controlPoints, double tension) { | |

return CatmullRomSpline.precompute( | |

// Force the first and last control points for the spline to be (0, 0) | |

// and (1, 1), respectively. | |

<Offset>[Offset.zero, ...controlPoints, const Offset(1.0, 1.0)], | |

tension: tension, | |

).generateSamples(start: 0.0, end: 1.0, tolerance: 1e-12).toList(); | |

} | |

/// A static accumulator for assertion failures. Not used in release mode. | |

static final List<String> _debugAssertReasons = <String>[]; | |

// The precomputed approximation curve, so that evaluation of the curve is | |

// efficient. | |

// | |

// If the curve is constructed lazily, then this will be empty, and will be filled | |

// the first time transform is called. | |

final List<Curve2DSample> _precomputedSamples; | |

/// The control points used to create this curve. | |

/// | |

/// The `dx` value of each [Offset] in [controlPoints] represents the | |

/// animation value at which the curve should pass through the `dy` value of | |

/// the same control point. | |

/// | |

/// The [controlPoints] list must meet the following criteria: | |

/// | |

/// * The list must contain at least two points. | |

/// * The X value of each point must be greater than 0.0 and less then 1.0. | |

/// * The X values of each point must be greater than the | |

/// previous point's X value (i.e. monotonically increasing). The Y values | |

/// are not constrained. | |

/// * The resulting spline must be single-valued in X. That is, for each X | |

/// value, there must be exactly one Y value. This means that the control | |

/// points must not generated a spline that loops or overlaps itself. | |

/// | |

/// The static function [validateControlPoints] can be used to check that | |

/// these conditions are met, and will return true if they are. In debug mode, | |

/// it will also optionally return a list of reasons in text form. In debug | |

/// mode, the constructor will assert that these conditions are met and print | |

/// the reasons if the assert fires. | |

/// | |

/// When the curve is evaluated with [transform], the values will interpolate | |

/// smoothly from one control point to the next, passing through (0.0, 0.0), the | |

/// given control points, and (1.0, 1.0). | |

final List<Offset> controlPoints; | |

/// The "tension" of the curve. | |

/// | |

/// The `tension` attribute controls how tightly the curve approaches the | |

/// given [controlPoints]. It must be in the range 0.0 to 1.0, inclusive. It | |

/// is optional, and defaults to 0.0, which provides the smoothest curve. A | |

/// value of 1.0 is equivalent to a linear interpolation between control | |

/// points. | |

final double tension; | |

/// Validates that a given set of control points for a [CatmullRomCurve] is | |

/// well-formed and will not produce a spline that self-intersects. | |

/// | |

/// This method is also used in debug mode to validate a curve to make sure | |

/// that it won't violate the contract for the [new CatmullRomCurve] | |

/// constructor. | |

/// | |

/// If in debug mode, and `reasons` is non-null, this function will fill in | |

/// `reasons` with descriptions of the problems encountered. The `reasons` | |

/// argument is ignored in release mode. | |

/// | |

/// In release mode, this function can be used to decide if a proposed | |

/// modification to the curve will result in a valid curve. | |

static bool validateControlPoints( | |

List<Offset> controlPoints, { | |

double tension = 0.0, | |

List<String> reasons, | |

}) { | |

assert(tension != null); | |

if (controlPoints == null) { | |

assert(() { | |

reasons?.add('Supplied control points cannot be null'); | |

return true; | |

}()); | |

return false; | |

} | |

if (controlPoints.length < 2) { | |

assert(() { | |

reasons?.add('There must be at least two points supplied to create a valid curve.'); | |

return true; | |

}()); | |

return false; | |

} | |

controlPoints = <Offset>[Offset.zero, ...controlPoints, const Offset(1.0, 1.0)]; | |

final Offset startHandle = controlPoints[0] * 2.0 - controlPoints[1]; | |

final Offset endHandle = controlPoints.last * 2.0 - controlPoints[controlPoints.length - 2]; | |

controlPoints = <Offset>[startHandle, ...controlPoints, endHandle]; | |

double lastX = -double.infinity; | |

for (int i = 0; i < controlPoints.length; ++i) { | |

if (i > 1 && | |

i < controlPoints.length - 2 && | |

(controlPoints[i].dx <= 0.0 || controlPoints[i].dx >= 1.0)) { | |

assert(() { | |

reasons?.add('Control points must have X values between 0.0 and 1.0, exclusive. ' | |

'Point $i has an x value (${controlPoints[i].dx}) which is outside the range.'); | |

return true; | |

}()); | |

return false; | |

} | |

if (controlPoints[i].dx <= lastX) { | |

assert(() { | |

reasons?.add('Each X coordinate must be greater than the preceding X coordinate ' | |

'(i.e. must be monotonically increasing in X). Point $i has an x value of ' | |

'${controlPoints[i].dx}, which is not greater than $lastX'); | |

return true; | |

}()); | |

return false; | |

} | |

lastX = controlPoints[i].dx; | |

} | |

bool success = true; | |

// An empirical test to make sure things are single-valued in X. | |

lastX = -double.infinity; | |

const double tolerance = 1e-3; | |

final CatmullRomSpline testSpline = CatmullRomSpline(controlPoints, tension: tension); | |

final double start = testSpline.findInverse(0.0); | |

final double end = testSpline.findInverse(1.0); | |

final Iterable<Curve2DSample> samplePoints = testSpline.generateSamples(start: start, end: end); | |

/// If the first and last points in the samples aren't at (0,0) or (1,1) | |

/// respectively, then the curve is multi-valued at the ends. | |

if (samplePoints.first.value.dy.abs() > tolerance || (1.0 - samplePoints.last.value.dy).abs() > tolerance) { | |

bool bail = true; | |

success = false; | |

assert(() { | |

reasons?.add('The curve has more than one Y value at X = ${samplePoints.first.value.dx}. ' | |

'Try moving some control points further away from this value of X, or increasing ' | |

'the tension.'); | |

// No need to keep going if we're not giving reasons. | |

bail = reasons == null; | |

return true; | |

}()); | |

if (bail) { | |

// If we're not in debug mode, then we want to bail immediately | |

// instead of checking everything else. | |

return false; | |

} | |

} | |

for (final Curve2DSample sample in samplePoints) { | |

final Offset point = sample.value; | |

final double t = sample.t; | |

final double x = point.dx; | |

if (t >= start && t <= end && (x < -1e-3 || x > 1.0 + 1e-3)) { | |

bool bail = true; | |

success = false; | |

assert(() { | |

reasons?.add('The resulting curve has an X value ($x) which is outside ' | |

'the range [0.0, 1.0], inclusive.'); | |

// No need to keep going if we're not giving reasons. | |

bail = reasons == null; | |

return true; | |

}()); | |

if (bail) { | |

// If we're not in debug mode, then we want to bail immediately | |

// instead of checking all the segments. | |

return false; | |

} | |

} | |

if (x < lastX) { | |

bool bail = true; | |

success = false; | |

assert(() { | |

reasons?.add('The curve has more than one Y value at x = $x. Try moving ' | |

'some control points further apart in X, or increasing the tension.'); | |

// No need to keep going if we're not giving reasons. | |

bail = reasons == null; | |

return true; | |

}()); | |

if (bail) { | |

// If we're not in debug mode, then we want to bail immediately | |

// instead of checking all the segments. | |

return false; | |

} | |

} | |

lastX = x; | |

} | |

return success; | |

} | |

@override | |

double transformInternal(double t) { | |

// Linearly interpolate between the two closest samples generated when the | |

// curve was created. | |

if (_precomputedSamples.isEmpty) { | |

// Compute the samples now if we were constructed lazily. | |

_precomputedSamples.addAll(_computeSamples(controlPoints, tension)); | |

} | |

int start = 0; | |

int end = _precomputedSamples.length - 1; | |

int mid; | |

Offset value; | |

Offset startValue = _precomputedSamples[start].value; | |

Offset endValue = _precomputedSamples[end].value; | |

// Use a binary search to find the index of the sample point that is just | |

// before t. | |

while (end - start > 1) { | |

mid = (end + start) ~/ 2; | |

value = _precomputedSamples[mid].value; | |

if (t >= value.dx) { | |

start = mid; | |

startValue = value; | |

} else { | |

end = mid; | |

endValue = value; | |

} | |

} | |

// Now interpolate between the found sample and the next one. | |

final double t2 = (t - startValue.dx) / (endValue.dx - startValue.dx); | |

return lerpDouble(startValue.dy, endValue.dy, t2); | |

} | |

} | |

/// A curve that is the reversed inversion of its given curve. | |

/// | |

/// This curve evaluates the given curve in reverse (i.e., from 1.0 to 0.0 as t | |

/// increases from 0.0 to 1.0) and returns the inverse of the given curve's | |

/// value (i.e., 1.0 minus the given curve's value). | |

/// | |

/// This is the class used to implement the [flipped] getter on curves. | |

/// | |

/// This is often useful with [CurvedAnimation.reverseCurve]. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_bounce_in.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_flipped.mp4} | |

/// | |

/// See also: | |

/// | |

/// * [Curve.flipped], which provides the [FlippedCurve] of a [Curve]. | |

/// * [ReverseAnimation], which reverses an [Animation] rather than a [Curve]. | |

/// * [CurvedAnimation], which can take a separate curve and reverse curve. | |

class FlippedCurve extends Curve { | |

/// Creates a flipped curve. | |

/// | |

/// The [curve] argument must not be null. | |

const FlippedCurve(this.curve) : assert(curve != null); | |

/// The curve that is being flipped. | |

final Curve curve; | |

@override | |

double transformInternal(double t) => 1.0 - curve.transform(1.0 - t); | |

@override | |

String toString() { | |

return '${objectRuntimeType(this, 'FlippedCurve')}($curve)'; | |

} | |

} | |

/// A curve where the rate of change starts out quickly and then decelerates; an | |

/// upside-down `f(t) = t²` parabola. | |

/// | |

/// This is equivalent to the Android `DecelerateInterpolator` class with a unit | |

/// factor (the default factor). | |

/// | |

/// See [Curves.decelerate] for an instance of this class. | |

class _DecelerateCurve extends Curve { | |

const _DecelerateCurve._(); | |

@override | |

double transformInternal(double t) { | |

// Intended to match the behavior of: | |

// https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/view/animation/DecelerateInterpolator.java | |

// ...as of December 2016. | |

t = 1.0 - t; | |

return 1.0 - t * t; | |

} | |

} | |

// BOUNCE CURVES | |

double _bounce(double t) { | |

if (t < 1.0 / 2.75) { | |

return 7.5625 * t * t; | |

} else if (t < 2 / 2.75) { | |

t -= 1.5 / 2.75; | |

return 7.5625 * t * t + 0.75; | |

} else if (t < 2.5 / 2.75) { | |

t -= 2.25 / 2.75; | |

return 7.5625 * t * t + 0.9375; | |

} | |

t -= 2.625 / 2.75; | |

return 7.5625 * t * t + 0.984375; | |

} | |

/// An oscillating curve that grows in magnitude. | |

/// | |

/// See [Curves.bounceIn] for an instance of this class. | |

class _BounceInCurve extends Curve { | |

const _BounceInCurve._(); | |

@override | |

double transformInternal(double t) { | |

return 1.0 - _bounce(1.0 - t); | |

} | |

} | |

/// An oscillating curve that shrink in magnitude. | |

/// | |

/// See [Curves.bounceOut] for an instance of this class. | |

class _BounceOutCurve extends Curve { | |

const _BounceOutCurve._(); | |

@override | |

double transformInternal(double t) { | |

return _bounce(t); | |

} | |

} | |

/// An oscillating curve that first grows and then shrink in magnitude. | |

/// | |

/// See [Curves.bounceInOut] for an instance of this class. | |

class _BounceInOutCurve extends Curve { | |

const _BounceInOutCurve._(); | |

@override | |

double transformInternal(double t) { | |

if (t < 0.5) | |

return (1.0 - _bounce(1.0 - t * 2.0)) * 0.5; | |

else | |

return _bounce(t * 2.0 - 1.0) * 0.5 + 0.5; | |

} | |

} | |

// ELASTIC CURVES | |

/// An oscillating curve that grows in magnitude while overshooting its bounds. | |

/// | |

/// An instance of this class using the default period of 0.4 is available as | |

/// [Curves.elasticIn]. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_elastic_in.mp4} | |

class ElasticInCurve extends Curve { | |

/// Creates an elastic-in curve. | |

/// | |

/// Rather than creating a new instance, consider using [Curves.elasticIn]. | |

const ElasticInCurve([this.period = 0.4]); | |

/// The duration of the oscillation. | |

final double period; | |

@override | |

double transformInternal(double t) { | |

final double s = period / 4.0; | |

t = t - 1.0; | |

return -math.pow(2.0, 10.0 * t) * math.sin((t - s) * (math.pi * 2.0) / period) as double; | |

} | |

@override | |

String toString() { | |

return '${objectRuntimeType(this, 'ElasticInCurve')}($period)'; | |

} | |

} | |

/// An oscillating curve that shrinks in magnitude while overshooting its bounds. | |

/// | |

/// An instance of this class using the default period of 0.4 is available as | |

/// [Curves.elasticOut]. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_elastic_out.mp4} | |

class ElasticOutCurve extends Curve { | |

/// Creates an elastic-out curve. | |

/// | |

/// Rather than creating a new instance, consider using [Curves.elasticOut]. | |

const ElasticOutCurve([this.period = 0.4]); | |

/// The duration of the oscillation. | |

final double period; | |

@override | |

double transformInternal(double t) { | |

final double s = period / 4.0; | |

return math.pow(2.0, -10 * t) * math.sin((t - s) * (math.pi * 2.0) / period) + 1.0 as double; | |

} | |

@override | |

String toString() { | |

return '${objectRuntimeType(this, 'ElasticOutCurve')}($period)'; | |

} | |

} | |

/// An oscillating curve that grows and then shrinks in magnitude while | |

/// overshooting its bounds. | |

/// | |

/// An instance of this class using the default period of 0.4 is available as | |

/// [Curves.elasticInOut]. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_elastic_in_out.mp4} | |

class ElasticInOutCurve extends Curve { | |

/// Creates an elastic-in-out curve. | |

/// | |

/// Rather than creating a new instance, consider using [Curves.elasticInOut]. | |

const ElasticInOutCurve([this.period = 0.4]); | |

/// The duration of the oscillation. | |

final double period; | |

@override | |

double transformInternal(double t) { | |

final double s = period / 4.0; | |

t = 2.0 * t - 1.0; | |

if (t < 0.0) | |

return -0.5 * math.pow(2.0, 10.0 * t) * math.sin((t - s) * (math.pi * 2.0) / period); | |

else | |

return math.pow(2.0, -10.0 * t) * math.sin((t - s) * (math.pi * 2.0) / period) * 0.5 + 1.0 as double; | |

} | |

@override | |

String toString() { | |

return '${objectRuntimeType(this, 'ElasticInOutCurve')}($period)'; | |

} | |

} | |

// PREDEFINED CURVES | |

/// A collection of common animation curves. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_bounce_in.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_bounce_in_out.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_bounce_out.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_decelerate.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_sine.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_quad.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_cubic.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_quart.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_quint.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_expo.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_circ.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_back.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_sine.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_quad.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_cubic.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_quart.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_quint.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_expo.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_circ.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_back.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_sine.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_quad.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_cubic.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_quart.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_quint.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_expo.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_circ.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_back.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_elastic_in.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_elastic_in_out.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_elastic_out.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_fast_out_slow_in.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_slow_middle.mp4} | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_linear.mp4} | |

/// | |

/// See also: | |

/// | |

/// * [Curve], the interface implemented by the constants available from the | |

/// [Curves] class. | |

class Curves { | |

// This class is not meant to be instatiated or extended; this constructor | |

// prevents instantiation and extension. | |

// ignore: unused_element | |

Curves._(); | |

/// A linear animation curve. | |

/// | |

/// This is the identity map over the unit interval: its [Curve.transform] | |

/// method returns its input unmodified. This is useful as a default curve for | |

/// cases where a [Curve] is required but no actual curve is desired. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_linear.mp4} | |

static const Curve linear = _Linear._(); | |

/// A curve where the rate of change starts out quickly and then decelerates; an | |

/// upside-down `f(t) = t²` parabola. | |

/// | |

/// This is equivalent to the Android `DecelerateInterpolator` class with a unit | |

/// factor (the default factor). | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_decelerate.mp4} | |

static const Curve decelerate = _DecelerateCurve._(); | |

/// A curve that is very steep and linear at the beginning, but quickly flattens out | |

/// and very slowly eases in. | |

/// | |

/// By default is the curve used to animate pages on iOS back to their original | |

/// position if a swipe gesture is ended midway through a swipe. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/fast_linear_to_slow_ease_in.mp4} | |

static const Cubic fastLinearToSlowEaseIn = Cubic(0.18, 1.0, 0.04, 1.0); | |

/// A cubic animation curve that speeds up quickly and ends slowly. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease.mp4} | |

static const Cubic ease = Cubic(0.25, 0.1, 0.25, 1.0); | |

/// A cubic animation curve that starts slowly and ends quickly. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in.mp4} | |

static const Cubic easeIn = Cubic(0.42, 0.0, 1.0, 1.0); | |

/// A cubic animation curve that starts starts slowly and ends linearly. | |

/// | |

/// The symmetric animation to [linearToEaseOut]. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_to_linear.mp4} | |

static const Cubic easeInToLinear = Cubic(0.67, 0.03, 0.65, 0.09); | |

/// A cubic animation curve that starts slowly and ends quickly. This is | |

/// similar to [Curves.easeIn], but with sinusoidal easing for a slightly less | |

/// abrupt beginning and end. Nonetheless, the result is quite gentle and is | |

/// hard to distinguish from [Curves.linear] at a glance. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_sine.mp4} | |

static const Cubic easeInSine = Cubic(0.47, 0.0, 0.745, 0.715); | |

/// A cubic animation curve that starts slowly and ends quickly. Based on a | |

/// quadratic equation where `f(t) = t²`, this is effectively the inverse of | |

/// [Curves.decelerate]. | |

/// | |

/// Compared to [Curves.easeInSine], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_quad.mp4} | |

static const Cubic easeInQuad = Cubic(0.55, 0.085, 0.68, 0.53); | |

/// A cubic animation curve that starts slowly and ends quickly. This curve is | |

/// based on a cubic equation where `f(t) = t³`. The result is a safe sweet | |

/// spot when choosing a curve for widgets animating off the viewport. | |

/// | |

/// Compared to [Curves.easeInQuad], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_cubic.mp4} | |

static const Cubic easeInCubic = Cubic(0.55, 0.055, 0.675, 0.19); | |

/// A cubic animation curve that starts slowly and ends quickly. This curve is | |

/// based on a quartic equation where `f(t) = t⁴`. | |

/// | |

/// Animations using this curve or steeper curves will benefit from a longer | |

/// duration to avoid motion feeling unnatural. | |

/// | |

/// Compared to [Curves.easeInCubic], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_quart.mp4} | |

static const Cubic easeInQuart = Cubic(0.895, 0.03, 0.685, 0.22); | |

/// A cubic animation curve that starts slowly and ends quickly. This curve is | |

/// based on a quintic equation where `f(t) = t⁵`. | |

/// | |

/// Compared to [Curves.easeInQuart], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_quint.mp4} | |

static const Cubic easeInQuint = Cubic(0.755, 0.05, 0.855, 0.06); | |

/// A cubic animation curve that starts slowly and ends quickly. This curve is | |

/// based on an exponential equation where `f(t) = 2¹⁰⁽ᵗ⁻¹⁾`. | |

/// | |

/// Using this curve can give your animations extra flare, but a longer | |

/// duration may need to be used to compensate for the steepness of the curve. | |

/// | |

/// Compared to [Curves.easeInQuint], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_expo.mp4} | |

static const Cubic easeInExpo = Cubic(0.95, 0.05, 0.795, 0.035); | |

/// A cubic animation curve that starts slowly and ends quickly. This curve is | |

/// effectively the bottom-right quarter of a circle. | |

/// | |

/// Like [Curves.easeInExpo], this curve is fairly dramatic and will reduce | |

/// the clarity of an animation if not given a longer duration. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_circ.mp4} | |

static const Cubic easeInCirc = Cubic(0.6, 0.04, 0.98, 0.335); | |

/// A cubic animation curve that starts slowly and ends quickly. This curve | |

/// is similar to [Curves.elasticIn] in that it overshoots its bounds before | |

/// reaching its end. Instead of repeated swinging motions before ascending, | |

/// though, this curve overshoots once, then continues to ascend. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_back.mp4} | |

static const Cubic easeInBack = Cubic(0.6, -0.28, 0.735, 0.045); | |

/// A cubic animation curve that starts quickly and ends slowly. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out.mp4} | |

static const Cubic easeOut = Cubic(0.0, 0.0, 0.58, 1.0); | |

/// A cubic animation curve that starts linearly and ends slowly. | |

/// | |

/// A symmetric animation to [easeInToLinear]. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/linear_to_ease_out.mp4} | |

static const Cubic linearToEaseOut = Cubic(0.35, 0.91, 0.33, 0.97); | |

/// A cubic animation curve that starts quickly and ends slowly. This is | |

/// similar to [Curves.easeOut], but with sinusoidal easing for a slightly | |

/// less abrupt beginning and end. Nonetheless, the result is quite gentle and | |

/// is hard to distinguish from [Curves.linear] at a glance. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_sine.mp4} | |

static const Cubic easeOutSine = Cubic(0.39, 0.575, 0.565, 1.0); | |

/// A cubic animation curve that starts quickly and ends slowly. This is | |

/// effectively the same as [Curves.decelerate], only simulated using a cubic | |

/// bezier function. | |

/// | |

/// Compared to [Curves.easeOutSine], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_quad.mp4} | |

static const Cubic easeOutQuad = Cubic(0.25, 0.46, 0.45, 0.94); | |

/// A cubic animation curve that starts quickly and ends slowly. This curve is | |

/// a flipped version of [Curves.easeInCubic]. | |

/// | |

/// The result is a safe sweet spot when choosing a curve for animating a | |

/// widget's position entering or already inside the viewport. | |

/// | |

/// Compared to [Curves.easeOutQuad], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_cubic.mp4} | |

static const Cubic easeOutCubic = Cubic(0.215, 0.61, 0.355, 1.0); | |

/// A cubic animation curve that starts quickly and ends slowly. This curve is | |

/// a flipped version of [Curves.easeInQuart]. | |

/// | |

/// Animations using this curve or steeper curves will benefit from a longer | |

/// duration to avoid motion feeling unnatural. | |

/// | |

/// Compared to [Curves.easeOutCubic], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_quart.mp4} | |

static const Cubic easeOutQuart = Cubic(0.165, 0.84, 0.44, 1.0); | |

/// A cubic animation curve that starts quickly and ends slowly. This curve is | |

/// a flipped version of [Curves.easeInQuint]. | |

/// | |

/// Compared to [Curves.easeOutQuart], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_quint.mp4} | |

static const Cubic easeOutQuint = Cubic(0.23, 1.0, 0.32, 1.0); | |

/// A cubic animation curve that starts quickly and ends slowly. This curve is | |

/// a flipped version of [Curves.easeInExpo]. Using this curve can give your | |

/// animations extra flare, but a longer duration may need to be used to | |

/// compensate for the steepness of the curve. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_expo.mp4} | |

static const Cubic easeOutExpo = Cubic(0.19, 1.0, 0.22, 1.0); | |

/// A cubic animation curve that starts quickly and ends slowly. This curve is | |

/// effectively the top-left quarter of a circle. | |

/// | |

/// Like [Curves.easeOutExpo], this curve is fairly dramatic and will reduce | |

/// the clarity of an animation if not given a longer duration. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_circ.mp4} | |

static const Cubic easeOutCirc = Cubic(0.075, 0.82, 0.165, 1.0); | |

/// A cubic animation curve that starts quickly and ends slowly. This curve is | |

/// similar to [Curves.elasticOut] in that it overshoots its bounds before | |

/// reaching its end. Instead of repeated swinging motions after ascending, | |

/// though, this curve only overshoots once. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_out_back.mp4} | |

static const Cubic easeOutBack = Cubic(0.175, 0.885, 0.32, 1.275); | |

/// A cubic animation curve that starts slowly, speeds up, and then ends | |

/// slowly. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out.mp4} | |

static const Cubic easeInOut = Cubic(0.42, 0.0, 0.58, 1.0); | |

/// A cubic animation curve that starts slowly, speeds up, and then ends | |

/// slowly. This is similar to [Curves.easeInOut], but with sinusoidal easing | |

/// for a slightly less abrupt beginning and end. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_sine.mp4} | |

static const Cubic easeInOutSine = Cubic(0.445, 0.05, 0.55, 0.95); | |

/// A cubic animation curve that starts slowly, speeds up, and then ends | |

/// slowly. This curve can be imagined as [Curves.easeInQuad] as the first | |

/// half, and [Curves.easeOutQuad] as the second. | |

/// | |

/// Compared to [Curves.easeInOutSine], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_quad.mp4} | |

static const Cubic easeInOutQuad = Cubic(0.455, 0.03, 0.515, 0.955); | |

/// A cubic animation curve that starts slowly, speeds up, and then ends | |

/// slowly. This curve can be imagined as [Curves.easeInCubic] as the first | |

/// half, and [Curves.easeOutCubic] as the second. | |

/// | |

/// The result is a safe sweet spot when choosing a curve for a widget whose | |

/// initial and final positions are both within the viewport. | |

/// | |

/// Compared to [Curves.easeInOutQuad], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_cubic.mp4} | |

static const Cubic easeInOutCubic = Cubic(0.645, 0.045, 0.355, 1.0); | |

/// A cubic animation curve that starts slowly, speeds up, and then ends | |

/// slowly. This curve can be imagined as [Curves.easeInQuart] as the first | |

/// half, and [Curves.easeOutQuart] as the second. | |

/// | |

/// Animations using this curve or steeper curves will benefit from a longer | |

/// duration to avoid motion feeling unnatural. | |

/// | |

/// Compared to [Curves.easeInOutCubic], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_quart.mp4} | |

static const Cubic easeInOutQuart = Cubic(0.77, 0.0, 0.175, 1.0); | |

/// A cubic animation curve that starts slowly, speeds up, and then ends | |

/// slowly. This curve can be imagined as [Curves.easeInQuint] as the first | |

/// half, and [Curves.easeOutQuint] as the second. | |

/// | |

/// Compared to [Curves.easeInOutQuart], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_quint.mp4} | |

static const Cubic easeInOutQuint = Cubic(0.86, 0.0, 0.07, 1.0); | |

/// A cubic animation curve that starts slowly, speeds up, and then ends | |

/// slowly. | |

/// | |

/// Since this curve is arrived at with an exponential function, the midpoint | |

/// is exceptionally steep. Extra consideration should be taken when designing | |

/// an animation using this. | |

/// | |

/// Compared to [Curves.easeInOutQuint], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_expo.mp4} | |

static const Cubic easeInOutExpo = Cubic(1.0, 0.0, 0.0, 1.0); | |

/// A cubic animation curve that starts slowly, speeds up, and then ends | |

/// slowly. This curve can be imagined as [Curves.easeInCirc] as the first | |

/// half, and [Curves.easeOutCirc] as the second. | |

/// | |

/// Like [Curves.easeInOutExpo], this curve is fairly dramatic and will reduce | |

/// the clarity of an animation if not given a longer duration. | |

/// | |

/// Compared to [Curves.easeInOutExpo], this curve is slightly steeper. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_circ.mp4} | |

static const Cubic easeInOutCirc = Cubic(0.785, 0.135, 0.15, 0.86); | |

/// A cubic animation curve that starts slowly, speeds up, and then ends | |

/// slowly. This curve can be imagined as [Curves.easeInBack] as the first | |

/// half, and [Curves.easeOutBack] as the second. | |

/// | |

/// Since two curves are used as a basis for this curve, the resulting | |

/// animation will overshoot its bounds twice before reaching its end - first | |

/// by exceeding its lower bound, then exceeding its upper bound and finally | |

/// descending to its final position. | |

/// | |

/// Derived from Robert Penner’s easing functions. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_ease_in_out_back.mp4} | |

static const Cubic easeInOutBack = Cubic(0.68, -0.55, 0.265, 1.55); | |

/// A curve that starts quickly and eases into its final position. | |

/// | |

/// Over the course of the animation, the object spends more time near its | |

/// final destination. As a result, the user isn’t left waiting for the | |

/// animation to finish, and the negative effects of motion are minimized. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_fast_out_slow_in.mp4} | |

static const Cubic fastOutSlowIn = Cubic(0.4, 0.0, 0.2, 1.0); | |

/// A cubic animation curve that starts quickly, slows down, and then ends | |

/// quickly. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_slow_middle.mp4} | |

static const Cubic slowMiddle = Cubic(0.15, 0.85, 0.85, 0.15); | |

/// An oscillating curve that grows in magnitude. | |

/// | |

static const Curve bounceIn = _BounceInCurve._(); | |

/// An oscillating curve that first grows and then shrink in magnitude. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_bounce_out.mp4} | |

static const Curve bounceOut = _BounceOutCurve._(); | |

/// An oscillating curve that first grows and then shrink in magnitude. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_bounce_in_out.mp4} | |

static const Curve bounceInOut = _BounceInOutCurve._(); | |

/// An oscillating curve that grows in magnitude while overshooting its bounds. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_elastic_in.mp4} | |

static const ElasticInCurve elasticIn = ElasticInCurve(); | |

/// An oscillating curve that shrinks in magnitude while overshooting its bounds. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_elastic_out.mp4} | |

static const ElasticOutCurve elasticOut = ElasticOutCurve(); | |

/// An oscillating curve that grows and then shrinks in magnitude while overshooting its bounds. | |

/// | |

/// {@animation 464 192 https://flutter.github.io/assets-for-api-docs/assets/animation/curve_elastic_in_out.mp4} | |

static const ElasticInOutCurve elasticInOut = ElasticInOutCurve(); | |

} |