curves.dart 5.72 KB
Newer Older
1 2 3 4
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5 6
import 'dart:math' as math;

7 8 9 10 11 12 13
double _evaluateCubic(double a, double b, double m) {
  // TODO(abarth): Would Math.pow be faster?
  return 3 * a * (1 - m) * (1 - m) * m + 3 * b * (1 - m) * m * m + m * m * m;
}

const double _kCubicErrorBound = 0.001;

14 15 16
/// A mapping of the unit interval to the unit interval
///
/// A curve must map 0.0 to 0.0 and 1.0 to 1.0.
17
abstract class Curve {
18 19 20
  /// Return the value of the curve at point t
  ///
  /// The value of t must be between 0.0 and 1.0, inclusive.
21 22 23
  double transform(double t);
}

24
/// The identity map over the unit interval
25 26
class Linear implements Curve {
  const Linear();
27
  double transform(double t) => t;
28 29
}

30
/// A curve that is 0.0 until start, then linear from 0.0 to 1.0 at end, then 1.0
31
class Interval implements Curve {
32
  const Interval(this.start, this.end);
33

34 35 36 37 38 39
  /// The smallest value for which this interval is 0.0
  final double start;

  /// The smallest value for which this interval is 1.0
  final double end;

40
  double transform(double t) {
41 42 43 44
    assert(start >= 0.0);
    assert(start <= 1.0);
    assert(end >= 0.0);
    assert(end <= 1.0);
45 46 47 48
    return ((t - start) / (end - start)).clamp(0.0, 1.0);
  }
}

49
/// A cubic polynomial mapping of the unit interval
50
class Cubic implements Curve {
51 52
  const Cubic(this.a, this.b, this.c, this.d);

53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
  final double a;
  final double b;
  final double c;
  final double d;

  double transform(double t) {
    double start = 0.0;
    double end = 1.0;
    while (true) {
      double midpoint = (start + end) / 2;
      double estimate = _evaluateCubic(a, c, midpoint);
      if ((t - estimate).abs() < _kCubicErrorBound)
        return _evaluateCubic(b, d, midpoint);
      if (estimate < t)
        start = midpoint;
      else
        end = midpoint;
    }
  }
}

74
double _bounce(double t) {
75 76 77 78 79 80 81 82 83 84 85 86 87
  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;
}

88
/// An oscillating curve that grows in magnitude
89 90 91 92 93 94 95
class BounceInCurve implements Curve {
  const BounceInCurve();
  double transform(double t) {
    return 1.0 - _bounce(1.0 - t);
  }
}

96
/// An oscillating curve that shrink in magnitude
97 98 99 100 101 102 103
class BounceOutCurve implements Curve {
  const BounceOutCurve();
  double transform(double t) {
    return _bounce(t);
  }
}

104
/// An oscillating curve that first grows and then shrink in magnitude
105 106 107 108 109 110 111 112 113 114
class BounceInOutCurve implements Curve {
  const BounceInOutCurve();
  double transform(double t) {
    if (t < 0.5)
      return (1.0 - _bounce(1.0 - t)) * 0.5;
    else
      return _bounce(t * 2.0 - 1.0) * 0.5 + 0.5;
  }
}

115
/// An oscillating curve that grows in magnitude while overshootings its bounds
116 117 118 119 120 121 122 123 124 125
class ElasticInCurve implements Curve {
  const ElasticInCurve([this.period = 0.4]);
  final double period;
  double transform(double t) {
    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);
  }
}

126
/// An oscillating curve that shrinks in magnitude while overshootings its bounds
127 128 129 130 131 132 133 134 135
class ElasticOutCurve implements Curve {
  const ElasticOutCurve([this.period = 0.4]);
  final double period;
  double transform(double t) {
    double s = period / 4.0;
    return math.pow(2.0, -10 * t) * math.sin((t - s) * (math.PI * 2.0) / period) + 1.0;
  }
}

136
/// An oscillating curve that grows and then shrinks in magnitude while overshootings its bounds
137 138 139 140 141
class ElasticInOutCurve implements Curve {
  const ElasticInOutCurve([this.period = 0.4]);
  final double period;
  double transform(double t) {
    double s = period / 4.0;
142
    t = 2.0 * t - 1.0;
143 144 145 146 147 148 149
    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;
  }
}

150
/// A linear animation curve
151
const Linear linear = const Linear();
152

153
/// A cubic animation curve that speeds up quickly and ends slowly
154
const Cubic ease = const Cubic(0.25, 0.1, 0.25, 1.0);
155

156
/// A cubic animation curve that starts slowly and ends quickly
157
const Cubic easeIn = const Cubic(0.42, 0.0, 1.0, 1.0);
158

159
/// A cubic animation curve that starts quickly and ends slowly
160
const Cubic easeOut = const Cubic(0.0, 0.0, 0.58, 1.0);
161

162
/// A cubic animation curve that starts slowly, speeds up, and then and ends slowly
163
const Cubic easeInOut = const Cubic(0.42, 0.0, 0.58, 1.0);
164 165

/// An oscillating curve that grows in magnitude
166
const BounceInCurve bounceIn = const BounceInCurve();
167 168

/// An oscillating curve that first grows and then shrink in magnitude
169
const BounceOutCurve bounceOut = const BounceOutCurve();
170 171

/// An oscillating curve that first grows and then shrink in magnitude
172
const BounceInOutCurve bounceInOut = const BounceInOutCurve();
173 174

/// An oscillating curve that grows in magnitude while overshootings its bounds
175
const ElasticInCurve elasticIn = const ElasticInCurve();
176 177

/// An oscillating curve that shrinks in magnitude while overshootings its bounds
178
const ElasticOutCurve elasticOut = const ElasticOutCurve();
179 180

/// An oscillating curve that grows and then shrinks in magnitude while overshootings its bounds
181
const ElasticInOutCurve elasticInOut = const ElasticInOutCurve();
182 183 184

/// 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.
const Curve fastOutSlowIn = const Cubic(0.4, 0.0, 0.2, 1.0);