animation_test_common.cc revision 4e180b6a0b4720a9b8e9e959a882386f690f08ff 
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 "cc/test/animation_test_common.h"
6
7#include "cc/animation/animation_id_provider.h"
8#include "cc/animation/keyframed_animation_curve.h"
9#include "cc/animation/layer_animation_controller.h"
10#include "cc/animation/transform_operations.h"
11#include "cc/layers/layer.h"
12#include "cc/layers/layer_impl.h"
13
14using cc::Animation;
15using cc::AnimationCurve;
16using cc::EaseTimingFunction;
17using cc::FloatKeyframe;
18using cc::KeyframedFloatAnimationCurve;
19using cc::KeyframedTransformAnimationCurve;
20using cc::TimingFunction;
21using cc::TransformKeyframe;
22
23namespace cc {
24
25template <class Target>
26int AddOpacityTransition(Target* target,
27                         double duration,
28                         float start_opacity,
29                         float end_opacity,
30                         bool use_timing_function) {
31  scoped_ptr<KeyframedFloatAnimationCurve>
32      curve(KeyframedFloatAnimationCurve::Create());
33
34  scoped_ptr<TimingFunction> func;
35  if (!use_timing_function)
36    func = EaseTimingFunction::Create();
37  if (duration > 0.0)
38    curve->AddKeyframe(FloatKeyframe::Create(0.0, start_opacity, func.Pass()));
39  curve->AddKeyframe(FloatKeyframe::Create(duration,
40                                           end_opacity,
41                                           scoped_ptr<cc::TimingFunction>()));
42
43  int id = AnimationIdProvider::NextAnimationId();
44
45  scoped_ptr<Animation> animation(Animation::Create(
46      curve.PassAs<AnimationCurve>(),
47      id,
48      AnimationIdProvider::NextGroupId(),
49      Animation::Opacity));
50  animation->set_needs_synchronized_start_time(true);
51
52  target->AddAnimation(animation.Pass());
53  return id;
54}
55
56template <class Target>
57int AddAnimatedTransform(Target* target,
58                         double duration,
59                         int delta_x,
60                         int delta_y) {
61  scoped_ptr<KeyframedTransformAnimationCurve>
62      curve(KeyframedTransformAnimationCurve::Create());
63
64  if (duration > 0.0) {
65    TransformOperations start_operations;
66    start_operations.AppendTranslate(delta_x, delta_y, 0.0);
67    curve->AddKeyframe(TransformKeyframe::Create(
68        0.0,
69        start_operations,
70        scoped_ptr<cc::TimingFunction>()));
71  }
72
73  TransformOperations operations;
74  operations.AppendTranslate(delta_x, delta_y, 0.0);
75  curve->AddKeyframe(TransformKeyframe::Create(
76      duration,
77      operations,
78      scoped_ptr<cc::TimingFunction>()));
79
80  int id = AnimationIdProvider::NextAnimationId();
81
82  scoped_ptr<Animation> animation(Animation::Create(
83      curve.PassAs<AnimationCurve>(),
84      id,
85      AnimationIdProvider::NextGroupId(),
86      Animation::Transform));
87  animation->set_needs_synchronized_start_time(true);
88
89  target->AddAnimation(animation.Pass());
90  return id;
91}
92
93template <class Target>
94int AddAnimatedFilter(Target* target,
95                      double duration,
96                      float start_brightness,
97                      float end_brightness) {
98  scoped_ptr<KeyframedFilterAnimationCurve>
99      curve(KeyframedFilterAnimationCurve::Create());
100
101  if (duration > 0.0) {
102    FilterOperations start_filters;
103    start_filters.Append(
104        FilterOperation::CreateBrightnessFilter(start_brightness));
105    curve->AddKeyframe(FilterKeyframe::Create(
106        0.0, start_filters, scoped_ptr<cc::TimingFunction>()));
107  }
108
109  FilterOperations filters;
110  filters.Append(FilterOperation::CreateBrightnessFilter(end_brightness));
111  curve->AddKeyframe(FilterKeyframe::Create(
112      duration, filters, scoped_ptr<cc::TimingFunction>()));
113
114  int id = AnimationIdProvider::NextAnimationId();
115
116  scoped_ptr<Animation> animation(Animation::Create(
117      curve.PassAs<AnimationCurve>(),
118      id,
119      AnimationIdProvider::NextGroupId(),
120      Animation::Filter));
121  animation->set_needs_synchronized_start_time(true);
122
123  target->AddAnimation(animation.Pass());
124  return id;
125}
126
127FakeFloatAnimationCurve::FakeFloatAnimationCurve()
128    : duration_(1.0) {}
129
130FakeFloatAnimationCurve::FakeFloatAnimationCurve(double duration)
131    : duration_(duration) {}
132
133FakeFloatAnimationCurve::~FakeFloatAnimationCurve() {}
134
135double FakeFloatAnimationCurve::Duration() const {
136  return duration_;
137}
138
139float FakeFloatAnimationCurve::GetValue(double now) const {
140  return 0.0f;
141}
142
143scoped_ptr<cc::AnimationCurve> FakeFloatAnimationCurve::Clone() const {
144  return make_scoped_ptr(
145      new FakeFloatAnimationCurve).PassAs<cc::AnimationCurve>();
146}
147
148FakeTransformTransition::FakeTransformTransition(double duration)
149    : duration_(duration) {}
150
151FakeTransformTransition::~FakeTransformTransition() {}
152
153double FakeTransformTransition::Duration() const {
154  return duration_;
155}
156
157gfx::Transform FakeTransformTransition::GetValue(double time) const {
158  return gfx::Transform();
159}
160
161bool FakeTransformTransition::AnimatedBoundsForBox(const gfx::BoxF& box,
162                                                   gfx::BoxF* bounds) const {
163  return false;
164}
165
166scoped_ptr<cc::AnimationCurve> FakeTransformTransition::Clone() const {
167  return make_scoped_ptr(
168      new FakeTransformTransition(*this)).PassAs<cc::AnimationCurve>();
169}
170
171
172FakeFloatTransition::FakeFloatTransition(double duration, float from, float to)
173    : duration_(duration), from_(from), to_(to) {}
174
175FakeFloatTransition::~FakeFloatTransition() {}
176
177double FakeFloatTransition::Duration() const {
178  return duration_;
179}
180
181float FakeFloatTransition::GetValue(double time) const {
182  time /= duration_;
183  if (time >= 1.0)
184    time = 1.0;
185  return (1.0 - time) * from_ + time * to_;
186}
187
188FakeLayerAnimationValueObserver::FakeLayerAnimationValueObserver()
189    : opacity_(0.0f) {}
190
191FakeLayerAnimationValueObserver::~FakeLayerAnimationValueObserver() {}
192
193void FakeLayerAnimationValueObserver::OnFilterAnimated(
194    const FilterOperations& filters) {
195  filters_ = filters;
196}
197
198void FakeLayerAnimationValueObserver::OnOpacityAnimated(float opacity) {
199  opacity_ = opacity;
200}
201
202void FakeLayerAnimationValueObserver::OnTransformAnimated(
203    const gfx::Transform& transform) {
204  transform_ = transform;
205}
206
207bool FakeLayerAnimationValueObserver::IsActive() const {
208  return true;
209}
210
211bool FakeInactiveLayerAnimationValueObserver::IsActive() const {
212  return false;
213}
214
215scoped_ptr<cc::AnimationCurve> FakeFloatTransition::Clone() const {
216  return make_scoped_ptr(
217      new FakeFloatTransition(*this)).PassAs<cc::AnimationCurve>();
218}
219
220int AddOpacityTransitionToController(cc::LayerAnimationController* controller,
221                                     double duration,
222                                     float start_opacity,
223                                     float end_opacity,
224                                     bool use_timing_function) {
225  return AddOpacityTransition(controller,
226                              duration,
227                              start_opacity,
228                              end_opacity,
229                              use_timing_function);
230}
231
232int AddAnimatedTransformToController(cc::LayerAnimationController* controller,
233                                     double duration,
234                                     int delta_x,
235                                     int delta_y) {
236  return AddAnimatedTransform(controller,
237                              duration,
238                              delta_x,
239                              delta_y);
240}
241
242int AddAnimatedFilterToController(cc::LayerAnimationController* controller,
243                                  double duration,
244                                  float start_brightness,
245                                  float end_brightness) {
246  return AddAnimatedFilter(
247      controller, duration, start_brightness, end_brightness);
248}
249
250int AddOpacityTransitionToLayer(cc::Layer* layer,
251                                double duration,
252                                float start_opacity,
253                                float end_opacity,
254                                bool use_timing_function) {
255  return AddOpacityTransition(layer,
256                              duration,
257                              start_opacity,
258                              end_opacity,
259                              use_timing_function);
260}
261
262int AddOpacityTransitionToLayer(cc::LayerImpl* layer,
263                                double duration,
264                                float start_opacity,
265                                float end_opacity,
266                                bool use_timing_function) {
267  return AddOpacityTransition(layer->layer_animation_controller(),
268                              duration,
269                              start_opacity,
270                              end_opacity,
271                              use_timing_function);
272}
273
274int AddAnimatedTransformToLayer(cc::Layer* layer,
275                                double duration,
276                                int delta_x,
277                                int delta_y) {
278  return AddAnimatedTransform(layer, duration, delta_x, delta_y);
279}
280
281int AddAnimatedTransformToLayer(cc::LayerImpl* layer,
282                                double duration,
283                                int delta_x,
284                                int delta_y) {
285  return AddAnimatedTransform(layer->layer_animation_controller(),
286                              duration,
287                              delta_x,
288                              delta_y);
289}
290
291int AddAnimatedFilterToLayer(cc::Layer* layer,
292                             double duration,
293                             float start_brightness,
294                             float end_brightness) {
295  return AddAnimatedFilter(layer, duration, start_brightness, end_brightness);
296}
297
298int AddAnimatedFilterToLayer(cc::LayerImpl* layer,
299                             double duration,
300                             float start_brightness,
301                             float end_brightness) {
302  return AddAnimatedFilter(layer->layer_animation_controller(),
303                           duration,
304                           start_brightness,
305                           end_brightness);
306}
307
308}  // namespace cc
309