OLD | NEW |
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/animation/timing_function.h" | 5 #include "cc/animation/timing_function.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 #include "base/memory/ptr_util.h" | 10 #include "base/memory/ptr_util.h" |
11 #include "cc/base/math_util.h" | 11 #include "cc/base/math_util.h" |
12 | 12 |
13 namespace cc { | 13 namespace cc { |
14 | 14 |
15 TimingFunction::TimingFunction() {} | 15 TimingFunction::TimingFunction() {} |
16 | 16 |
17 TimingFunction::~TimingFunction() {} | 17 TimingFunction::~TimingFunction() {} |
18 | 18 |
19 std::unique_ptr<TimingFunction> CubicBezierTimingFunction::CreatePreset( | 19 std::unique_ptr<TimingFunction> CubicBezierTimingFunction::CreatePreset( |
20 EaseType ease_type) { | 20 EaseType ease_type) { |
21 switch (ease_type) { | 21 switch (ease_type) { |
22 case EaseType::EASE: | 22 case EaseType::EASE: |
23 return EaseTimingFunction::Create(); | 23 return base::WrapUnique( |
| 24 new CubicBezierTimingFunction(EaseType::EASE, 0.25, 0.1, 0.25, 1.0)); |
24 case EaseType::EASE_IN: | 25 case EaseType::EASE_IN: |
25 return EaseInTimingFunction::Create(); | 26 return base::WrapUnique(new CubicBezierTimingFunction( |
| 27 EaseType::EASE_IN, 0.42, 0.0, 1.0, 1.0)); |
26 case EaseType::EASE_OUT: | 28 case EaseType::EASE_OUT: |
27 return EaseOutTimingFunction::Create(); | 29 return base::WrapUnique(new CubicBezierTimingFunction( |
| 30 EaseType::EASE_OUT, 0.0, 0.0, 0.58, 1.0)); |
28 case EaseType::EASE_IN_OUT: | 31 case EaseType::EASE_IN_OUT: |
29 return EaseInOutTimingFunction::Create(); | 32 return base::WrapUnique(new CubicBezierTimingFunction( |
| 33 EaseType::EASE_IN_OUT, 0.42, 0.0, 0.58, 1)); |
30 default: | 34 default: |
31 NOTREACHED(); | 35 NOTREACHED(); |
32 return nullptr; | 36 return nullptr; |
33 } | 37 } |
34 } | 38 } |
35 | |
36 std::unique_ptr<CubicBezierTimingFunction> | 39 std::unique_ptr<CubicBezierTimingFunction> |
37 CubicBezierTimingFunction::Create(double x1, double y1, double x2, double y2) { | 40 CubicBezierTimingFunction::Create(double x1, double y1, double x2, double y2) { |
38 return base::WrapUnique(new CubicBezierTimingFunction(x1, y1, x2, y2)); | 41 return base::WrapUnique( |
| 42 new CubicBezierTimingFunction(EaseType::CUSTOM, x1, y1, x2, y2)); |
39 } | 43 } |
40 | 44 |
41 CubicBezierTimingFunction::CubicBezierTimingFunction(double x1, | 45 CubicBezierTimingFunction::CubicBezierTimingFunction(EaseType ease_type, |
| 46 double x1, |
42 double y1, | 47 double y1, |
43 double x2, | 48 double x2, |
44 double y2) | 49 double y2) |
45 : bezier_(x1, y1, x2, y2) {} | 50 : bezier_(x1, y1, x2, y2), ease_type_(ease_type) {} |
46 | 51 |
47 CubicBezierTimingFunction::~CubicBezierTimingFunction() {} | 52 CubicBezierTimingFunction::~CubicBezierTimingFunction() {} |
48 | 53 |
49 float CubicBezierTimingFunction::GetValue(double x) const { | 54 float CubicBezierTimingFunction::GetValue(double x) const { |
50 return static_cast<float>(bezier_.Solve(x)); | 55 return static_cast<float>(bezier_.Solve(x)); |
51 } | 56 } |
52 | 57 |
53 float CubicBezierTimingFunction::Velocity(double x) const { | 58 float CubicBezierTimingFunction::Velocity(double x) const { |
54 return static_cast<float>(bezier_.Slope(x)); | 59 return static_cast<float>(bezier_.Slope(x)); |
55 } | 60 } |
56 | 61 |
57 void CubicBezierTimingFunction::Range(float* min, float* max) const { | 62 void CubicBezierTimingFunction::Range(float* min, float* max) const { |
58 *min = static_cast<float>(bezier_.range_min()); | 63 *min = static_cast<float>(bezier_.range_min()); |
59 *max = static_cast<float>(bezier_.range_max()); | 64 *max = static_cast<float>(bezier_.range_max()); |
60 } | 65 } |
61 | 66 |
62 std::unique_ptr<TimingFunction> CubicBezierTimingFunction::Clone() const { | 67 std::unique_ptr<TimingFunction> CubicBezierTimingFunction::Clone() const { |
63 return base::WrapUnique(new CubicBezierTimingFunction(*this)); | 68 return base::WrapUnique(new CubicBezierTimingFunction(*this)); |
64 } | 69 } |
65 | 70 |
66 // These numbers come from | 71 // These numbers come from |
67 // http://www.w3.org/TR/css3-transitions/#transition-timing-function_tag. | 72 // http://www.w3.org/TR/css3-transitions/#transition-timing-function_tag. |
68 std::unique_ptr<TimingFunction> EaseTimingFunction::Create() { | 73 std::unique_ptr<TimingFunction> EaseTimingFunction::Create() { |
69 return CubicBezierTimingFunction::Create(0.25, 0.1, 0.25, 1.0); | 74 return CubicBezierTimingFunction::CreatePreset( |
| 75 CubicBezierTimingFunction::EaseType::EASE); |
70 } | 76 } |
71 | 77 |
72 std::unique_ptr<TimingFunction> EaseInTimingFunction::Create() { | 78 std::unique_ptr<TimingFunction> EaseInTimingFunction::Create() { |
73 return CubicBezierTimingFunction::Create(0.42, 0.0, 1.0, 1.0); | 79 return CubicBezierTimingFunction::CreatePreset( |
| 80 CubicBezierTimingFunction::EaseType::EASE_IN); |
74 } | 81 } |
75 | 82 |
76 std::unique_ptr<TimingFunction> EaseOutTimingFunction::Create() { | 83 std::unique_ptr<TimingFunction> EaseOutTimingFunction::Create() { |
77 return CubicBezierTimingFunction::Create(0.0, 0.0, 0.58, 1.0); | 84 return CubicBezierTimingFunction::CreatePreset( |
| 85 CubicBezierTimingFunction::EaseType::EASE_OUT); |
78 } | 86 } |
79 | 87 |
80 std::unique_ptr<TimingFunction> EaseInOutTimingFunction::Create() { | 88 std::unique_ptr<TimingFunction> EaseInOutTimingFunction::Create() { |
81 return CubicBezierTimingFunction::Create(0.42, 0.0, 0.58, 1); | 89 return CubicBezierTimingFunction::CreatePreset( |
| 90 CubicBezierTimingFunction::EaseType::EASE_IN_OUT); |
82 } | 91 } |
83 | 92 |
84 std::unique_ptr<StepsTimingFunction> StepsTimingFunction::Create( | 93 std::unique_ptr<StepsTimingFunction> StepsTimingFunction::Create( |
85 int steps, | 94 int steps, |
86 StepPosition step_position) { | 95 StepPosition step_position) { |
87 return base::WrapUnique(new StepsTimingFunction(steps, step_position)); | 96 return base::WrapUnique(new StepsTimingFunction(steps, step_position)); |
88 } | 97 } |
89 | 98 |
90 StepsTimingFunction::StepsTimingFunction(int steps, StepPosition step_position) | 99 StepsTimingFunction::StepsTimingFunction(int steps, StepPosition step_position) |
91 : steps_(steps) { | 100 : steps_(steps) { |
(...skipping 27 matching lines...) Expand all Loading... |
119 void StepsTimingFunction::Range(float* min, float* max) const { | 128 void StepsTimingFunction::Range(float* min, float* max) const { |
120 *min = 0.0f; | 129 *min = 0.0f; |
121 *max = 1.0f; | 130 *max = 1.0f; |
122 } | 131 } |
123 | 132 |
124 float StepsTimingFunction::Velocity(double x) const { | 133 float StepsTimingFunction::Velocity(double x) const { |
125 return 0.0f; | 134 return 0.0f; |
126 } | 135 } |
127 | 136 |
128 } // namespace cc | 137 } // namespace cc |
OLD | NEW |