1 // Copyright 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include <algorithm> 6 #include <cmath> 7 8 #include "base/logging.h" 9 #include "cc/animation/timing_function.h" 10 11 namespace cc { 12 13 namespace { 14 15 static const double kBezierEpsilon = 1e-7; 16 static const int MAX_STEPS = 30; 17 18 static double eval_bezier(double x1, double x2, double t) { 19 const double x1_times_3 = 3.0 * x1; 20 const double x2_times_3 = 3.0 * x2; 21 const double h3 = x1_times_3; 22 const double h1 = x1_times_3 - x2_times_3 + 1.0; 23 const double h2 = x2_times_3 - 6.0 * x1; 24 return t * (t * (t * h1 + h2) + h3); 25 } 26 27 static double bezier_interp(double x1, 28 double y1, 29 double x2, 30 double y2, 31 double x) { 32 DCHECK_GE(1.0, x1); 33 DCHECK_LE(0.0, x1); 34 DCHECK_GE(1.0, x2); 35 DCHECK_LE(0.0, x2); 36 37 x1 = std::min(std::max(x1, 0.0), 1.0); 38 x2 = std::min(std::max(x2, 0.0), 1.0); 39 x = std::min(std::max(x, 0.0), 1.0); 40 41 // Step 1. Find the t corresponding to the given x. I.e., we want t such that 42 // eval_bezier(x1, x2, t) = x. There is a unique solution if x1 and x2 lie 43 // within (0, 1). 44 // 45 // We're just going to do bisection for now (for simplicity), but we could 46 // easily do some newton steps if this turns out to be a bottleneck. 47 double t = 0.0; 48 double step = 1.0; 49 for (int i = 0; i < MAX_STEPS; ++i, step *= 0.5) { 50 const double error = eval_bezier(x1, x2, t) - x; 51 if (std::abs(error) < kBezierEpsilon) 52 break; 53 t += error > 0.0 ? -step : step; 54 } 55 56 // We should have terminated the above loop because we got close to x, not 57 // because we exceeded MAX_STEPS. Do a DCHECK here to confirm. 58 DCHECK_GT(kBezierEpsilon, std::abs(eval_bezier(x1, x2, t) - x)); 59 60 // Step 2. Return the interpolated y values at the t we computed above. 61 return eval_bezier(y1, y2, t); 62 } 63 64 } // namespace 65 66 TimingFunction::TimingFunction() {} 67 68 TimingFunction::~TimingFunction() {} 69 70 double TimingFunction::Duration() const { 71 return 1.0; 72 } 73 74 scoped_ptr<CubicBezierTimingFunction> CubicBezierTimingFunction::Create( 75 double x1, double y1, double x2, double y2) { 76 return make_scoped_ptr(new CubicBezierTimingFunction(x1, y1, x2, y2)); 77 } 78 79 CubicBezierTimingFunction::CubicBezierTimingFunction(double x1, 80 double y1, 81 double x2, 82 double y2) 83 : x1_(x1), y1_(y1), x2_(x2), y2_(y2) {} 84 85 CubicBezierTimingFunction::~CubicBezierTimingFunction() {} 86 87 float CubicBezierTimingFunction::GetValue(double x) const { 88 return static_cast<float>(bezier_interp(x1_, y1_, x2_, y2_, x)); 89 } 90 91 scoped_ptr<AnimationCurve> CubicBezierTimingFunction::Clone() const { 92 return make_scoped_ptr( 93 new CubicBezierTimingFunction(*this)).PassAs<AnimationCurve>(); 94 } 95 96 void CubicBezierTimingFunction::Range(float* min, float* max) const { 97 *min = 0.f; 98 *max = 1.f; 99 if (0.f <= y1_ && y1_ < 1.f && 0.f <= y2_ && y2_ <= 1.f) 100 return; 101 102 // Represent the function's derivative in the form at^2 + bt + c. 103 float a = 3.f * (y1_ - y2_) + 1.f; 104 float b = 2.f * (y2_ - 2.f * y1_); 105 float c = y1_; 106 107 // Check if the derivative is constant. 108 if (std::abs(a) < kBezierEpsilon && 109 std::abs(b) < kBezierEpsilon) 110 return; 111 112 // Zeros of the function's derivative. 113 float t_1 = 0.f; 114 float t_2 = 0.f; 115 116 if (std::abs(a) < kBezierEpsilon) { 117 // The function's derivative is linear. 118 t_1 = -c / b; 119 } else { 120 // The function's derivative is a quadratic. We find the zeros of this 121 // quadratic using the quadratic formula. 122 float discriminant = b * b - 4 * a * c; 123 if (discriminant < 0.f) 124 return; 125 float discriminant_sqrt = sqrt(discriminant); 126 t_1 = (-b + discriminant_sqrt) / (2.f * a); 127 t_2 = (-b - discriminant_sqrt) / (2.f * a); 128 } 129 130 float sol_1 = 0.f; 131 float sol_2 = 0.f; 132 133 if (0.f < t_1 && t_1 < 1.f) 134 sol_1 = eval_bezier(y1_, y2_, t_1); 135 136 if (0.f < t_2 && t_2 < 1.f) 137 sol_2 = eval_bezier(y1_, y2_, t_2); 138 139 *min = std::min(std::min(*min, sol_1), sol_2); 140 *max = std::max(std::max(*max, sol_1), sol_2); 141 } 142 143 // These numbers come from 144 // http://www.w3.org/TR/css3-transitions/#transition-timing-function_tag. 145 scoped_ptr<TimingFunction> EaseTimingFunction::Create() { 146 return CubicBezierTimingFunction::Create( 147 0.25, 0.1, 0.25, 1.0).PassAs<TimingFunction>(); 148 } 149 150 scoped_ptr<TimingFunction> EaseInTimingFunction::Create() { 151 return CubicBezierTimingFunction::Create( 152 0.42, 0.0, 1.0, 1.0).PassAs<TimingFunction>(); 153 } 154 155 scoped_ptr<TimingFunction> EaseOutTimingFunction::Create() { 156 return CubicBezierTimingFunction::Create( 157 0.0, 0.0, 0.58, 1.0).PassAs<TimingFunction>(); 158 } 159 160 scoped_ptr<TimingFunction> EaseInOutTimingFunction::Create() { 161 return CubicBezierTimingFunction::Create( 162 0.42, 0.0, 0.58, 1).PassAs<TimingFunction>(); 163 } 164 165 } // namespace cc 166
