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 |
| 54 TimingFunction::Type CubicBezierTimingFunction::GetType() const { |
| 55 return Type::CUBIC_BEZIER; |
| 56 } |
| 57 |
49 float CubicBezierTimingFunction::GetValue(double x) const { | 58 float CubicBezierTimingFunction::GetValue(double x) const { |
50 return static_cast<float>(bezier_.Solve(x)); | 59 return static_cast<float>(bezier_.Solve(x)); |
51 } | 60 } |
52 | 61 |
53 float CubicBezierTimingFunction::Velocity(double x) const { | 62 float CubicBezierTimingFunction::Velocity(double x) const { |
54 return static_cast<float>(bezier_.Slope(x)); | 63 return static_cast<float>(bezier_.Slope(x)); |
55 } | 64 } |
56 | 65 |
57 void CubicBezierTimingFunction::Range(float* min, float* max) const { | 66 void CubicBezierTimingFunction::Range(float* min, float* max) const { |
58 *min = static_cast<float>(bezier_.range_min()); | 67 *min = static_cast<float>(bezier_.range_min()); |
59 *max = static_cast<float>(bezier_.range_max()); | 68 *max = static_cast<float>(bezier_.range_max()); |
60 } | 69 } |
61 | 70 |
62 std::unique_ptr<TimingFunction> CubicBezierTimingFunction::Clone() const { | 71 std::unique_ptr<TimingFunction> CubicBezierTimingFunction::Clone() const { |
63 return base::WrapUnique(new CubicBezierTimingFunction(*this)); | 72 return base::WrapUnique(new CubicBezierTimingFunction(*this)); |
64 } | 73 } |
65 | 74 |
66 // These numbers come from | 75 // These numbers come from |
67 // http://www.w3.org/TR/css3-transitions/#transition-timing-function_tag. | 76 // http://www.w3.org/TR/css3-transitions/#transition-timing-function_tag. |
68 std::unique_ptr<TimingFunction> EaseTimingFunction::Create() { | 77 std::unique_ptr<TimingFunction> EaseTimingFunction::Create() { |
69 return CubicBezierTimingFunction::Create(0.25, 0.1, 0.25, 1.0); | 78 return CubicBezierTimingFunction::CreatePreset( |
| 79 CubicBezierTimingFunction::EaseType::EASE); |
70 } | 80 } |
71 | 81 |
72 std::unique_ptr<TimingFunction> EaseInTimingFunction::Create() { | 82 std::unique_ptr<TimingFunction> EaseInTimingFunction::Create() { |
73 return CubicBezierTimingFunction::Create(0.42, 0.0, 1.0, 1.0); | 83 return CubicBezierTimingFunction::CreatePreset( |
| 84 CubicBezierTimingFunction::EaseType::EASE_IN); |
74 } | 85 } |
75 | 86 |
76 std::unique_ptr<TimingFunction> EaseOutTimingFunction::Create() { | 87 std::unique_ptr<TimingFunction> EaseOutTimingFunction::Create() { |
77 return CubicBezierTimingFunction::Create(0.0, 0.0, 0.58, 1.0); | 88 return CubicBezierTimingFunction::CreatePreset( |
| 89 CubicBezierTimingFunction::EaseType::EASE_OUT); |
78 } | 90 } |
79 | 91 |
80 std::unique_ptr<TimingFunction> EaseInOutTimingFunction::Create() { | 92 std::unique_ptr<TimingFunction> EaseInOutTimingFunction::Create() { |
81 return CubicBezierTimingFunction::Create(0.42, 0.0, 0.58, 1); | 93 return CubicBezierTimingFunction::CreatePreset( |
| 94 CubicBezierTimingFunction::EaseType::EASE_IN_OUT); |
82 } | 95 } |
83 | 96 |
84 std::unique_ptr<StepsTimingFunction> StepsTimingFunction::Create( | 97 std::unique_ptr<StepsTimingFunction> StepsTimingFunction::Create( |
85 int steps, | 98 int steps, |
86 StepPosition step_position) { | 99 StepPosition step_position) { |
87 return base::WrapUnique(new StepsTimingFunction(steps, step_position)); | 100 return base::WrapUnique(new StepsTimingFunction(steps, step_position)); |
88 } | 101 } |
89 | 102 |
90 StepsTimingFunction::StepsTimingFunction(int steps, StepPosition step_position) | 103 StepsTimingFunction::StepsTimingFunction(int steps, StepPosition step_position) |
91 : steps_(steps) { | 104 : steps_(steps) { |
92 switch (step_position) { | 105 switch (step_position) { |
93 case StepPosition::START: | 106 case StepPosition::START: |
94 steps_start_offset_ = 1; | 107 steps_start_offset_ = 1; |
95 break; | 108 break; |
96 case StepPosition::MIDDLE: | 109 case StepPosition::MIDDLE: |
97 steps_start_offset_ = 0.5; | 110 steps_start_offset_ = 0.5; |
98 break; | 111 break; |
99 case StepPosition::END: | 112 case StepPosition::END: |
100 steps_start_offset_ = 0; | 113 steps_start_offset_ = 0; |
101 break; | 114 break; |
102 } | 115 } |
103 } | 116 } |
104 | 117 |
105 StepsTimingFunction::~StepsTimingFunction() { | 118 StepsTimingFunction::~StepsTimingFunction() { |
106 } | 119 } |
107 | 120 |
| 121 TimingFunction::Type StepsTimingFunction::GetType() const { |
| 122 return Type::STEPS; |
| 123 } |
| 124 |
108 float StepsTimingFunction::GetValue(double t) const { | 125 float StepsTimingFunction::GetValue(double t) const { |
109 const double steps = static_cast<double>(steps_); | 126 const double steps = static_cast<double>(steps_); |
110 const double value = MathUtil::ClampToRange( | 127 const double value = MathUtil::ClampToRange( |
111 std::floor((steps * t) + steps_start_offset_) / steps, 0.0, 1.0); | 128 std::floor((steps * t) + steps_start_offset_) / steps, 0.0, 1.0); |
112 return static_cast<float>(value); | 129 return static_cast<float>(value); |
113 } | 130 } |
114 | 131 |
115 std::unique_ptr<TimingFunction> StepsTimingFunction::Clone() const { | 132 std::unique_ptr<TimingFunction> StepsTimingFunction::Clone() const { |
116 return base::WrapUnique(new StepsTimingFunction(*this)); | 133 return base::WrapUnique(new StepsTimingFunction(*this)); |
117 } | 134 } |
118 | 135 |
119 void StepsTimingFunction::Range(float* min, float* max) const { | 136 void StepsTimingFunction::Range(float* min, float* max) const { |
120 *min = 0.0f; | 137 *min = 0.0f; |
121 *max = 1.0f; | 138 *max = 1.0f; |
122 } | 139 } |
123 | 140 |
124 float StepsTimingFunction::Velocity(double x) const { | 141 float StepsTimingFunction::Velocity(double x) const { |
125 return 0.0f; | 142 return 0.0f; |
126 } | 143 } |
127 | 144 |
128 } // namespace cc | 145 } // namespace cc |
OLD | NEW |