animation_test_common.cc revision 2a99a7e74a7f215066514fe81d2bfa6639d9eddd 
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/keyframed_animation_curve.h"
8#include "cc/animation/layer_animation_controller.h"
9#include "cc/animation/transform_operations.h"
10#include "cc/layers/layer.h"
11#include "cc/layers/layer_impl.h"
12
13using cc::Animation;
14using cc::AnimationCurve;
15using cc::EaseTimingFunction;
16using cc::FloatKeyframe;
17using cc::KeyframedFloatAnimationCurve;
18using cc::KeyframedTransformAnimationCurve;
19using cc::TimingFunction;
20using cc::TransformKeyframe;
21
22namespace cc {
23
24static int s_next_animation_id = 0;
25
26template <class Target>
27int AddOpacityTransition(Target* target,
28                         double duration,
29                         float start_opacity,
30                         float end_opacity,
31                         bool use_timing_function) {
32  scoped_ptr<KeyframedFloatAnimationCurve>
33      curve(KeyframedFloatAnimationCurve::Create());
34
35  scoped_ptr<TimingFunction> func;
36  if (!use_timing_function)
37    func = EaseTimingFunction::Create();
38  if (duration > 0.0)
39    curve->AddKeyframe(FloatKeyframe::Create(0.0, start_opacity, func.Pass()));
40  curve->AddKeyframe(FloatKeyframe::Create(duration,
41                                           end_opacity,
42                                           scoped_ptr<cc::TimingFunction>()));
43
44  int id = s_next_animation_id++;
45
46  scoped_ptr<Animation> animation(Animation::Create(
47      curve.PassAs<AnimationCurve>(),
48      id,
49      0,
50      Animation::Opacity));
51  animation->set_needs_synchronized_start_time(true);
52
53  target->AddAnimation(animation.Pass());
54  return id;
55}
56
57template <class Target>
58int AddAnimatedTransform(Target* target,
59                         double duration,
60                         int delta_x,
61                         int delta_y) {
62  scoped_ptr<KeyframedTransformAnimationCurve>
63      curve(KeyframedTransformAnimationCurve::Create());
64
65  if (duration > 0.0) {
66    TransformOperations start_operations;
67    start_operations.AppendTranslate(delta_x, delta_y, 0.0);
68    curve->AddKeyframe(TransformKeyframe::Create(
69        0.0,
70        start_operations,
71        scoped_ptr<cc::TimingFunction>()));
72  }
73
74  TransformOperations operations;
75  operations.AppendTranslate(delta_x, delta_y, 0.0);
76  curve->AddKeyframe(TransformKeyframe::Create(
77      duration,
78      operations,
79      scoped_ptr<cc::TimingFunction>()));
80
81  int id = s_next_animation_id++;
82
83  scoped_ptr<Animation> animation(Animation::Create(
84      curve.PassAs<AnimationCurve>(),
85      id, 0, Animation::Transform));
86  animation->set_needs_synchronized_start_time(true);
87
88  target->AddAnimation(animation.Pass());
89  return id;
90}
91
92FakeFloatAnimationCurve::FakeFloatAnimationCurve()
93    : duration_(1.0)
94{
95}
96
97FakeFloatAnimationCurve::FakeFloatAnimationCurve(double duration)
98    : duration_(duration)
99{
100}
101
102FakeFloatAnimationCurve::~FakeFloatAnimationCurve() {
103}
104
105double FakeFloatAnimationCurve::Duration() const {
106  return duration_;
107}
108
109float FakeFloatAnimationCurve::GetValue(double now) const {
110  return 0.0f;
111}
112
113scoped_ptr<cc::AnimationCurve> FakeFloatAnimationCurve::Clone() const {
114  return make_scoped_ptr(
115      new FakeFloatAnimationCurve).PassAs<cc::AnimationCurve>();
116}
117
118FakeTransformTransition::FakeTransformTransition(double duration)
119    : duration_(duration)
120{
121}
122
123FakeTransformTransition::~FakeTransformTransition() {
124}
125
126double FakeTransformTransition::Duration() const {
127  return duration_;
128}
129
130gfx::Transform FakeTransformTransition::GetValue(double time) const {
131  return gfx::Transform();
132}
133
134scoped_ptr<cc::AnimationCurve> FakeTransformTransition::Clone() const {
135  return make_scoped_ptr(
136      new FakeTransformTransition(*this)).PassAs<cc::AnimationCurve>();
137}
138
139
140FakeFloatTransition::FakeFloatTransition(double duration, float from, float to)
141    : duration_(duration)
142    , from_(from)
143    , to_(to)
144{
145}
146
147FakeFloatTransition::~FakeFloatTransition() {
148}
149
150double FakeFloatTransition::Duration() const {
151  return duration_;
152}
153
154float FakeFloatTransition::GetValue(double time) const {
155  time /= duration_;
156  if (time >= 1.0)
157    time = 1.0;
158  return (1.0 - time) * from_ + time * to_;
159}
160
161FakeLayerAnimationValueObserver::FakeLayerAnimationValueObserver()
162    : opacity_(0.0f)
163{
164}
165
166FakeLayerAnimationValueObserver::~FakeLayerAnimationValueObserver() {
167}
168
169void FakeLayerAnimationValueObserver::OnOpacityAnimated(float opacity) {
170  opacity_ = opacity;
171}
172
173void FakeLayerAnimationValueObserver::OnTransformAnimated(
174    const gfx::Transform& transform) {
175  transform_ = transform;
176}
177
178bool FakeLayerAnimationValueObserver::IsActive() const {
179  return true;
180}
181
182scoped_ptr<cc::AnimationCurve> FakeFloatTransition::Clone() const {
183  return make_scoped_ptr(
184      new FakeFloatTransition(*this)).PassAs<cc::AnimationCurve>();
185}
186
187int AddOpacityTransitionToController(cc::LayerAnimationController* controller,
188                                     double duration,
189                                     float start_opacity,
190                                     float end_opacity,
191                                     bool use_timing_function) {
192  return AddOpacityTransition(controller,
193                              duration,
194                              start_opacity,
195                              end_opacity,
196                              use_timing_function);
197}
198
199int AddAnimatedTransformToController(cc::LayerAnimationController* controller,
200                                     double duration,
201                                     int delta_x,
202                                     int delta_y) {
203  return AddAnimatedTransform(controller,
204                              duration,
205                              delta_x,
206                              delta_y);
207}
208
209int AddOpacityTransitionToLayer(cc::Layer* layer,
210                                double duration,
211                                float start_opacity,
212                                float end_opacity,
213                                bool use_timing_function) {
214  return AddOpacityTransition(layer,
215                              duration,
216                              start_opacity,
217                              end_opacity,
218                              use_timing_function);
219}
220
221int AddOpacityTransitionToLayer(cc::LayerImpl* layer,
222                                double duration,
223                                float start_opacity,
224                                float end_opacity,
225                                bool use_timing_function) {
226  return AddOpacityTransition(layer->layer_animation_controller(),
227                              duration,
228                              start_opacity,
229                              end_opacity,
230                              use_timing_function);
231}
232
233int AddAnimatedTransformToLayer(cc::Layer* layer,
234                                double duration,
235                                int delta_x,
236                                int delta_y) {
237  return AddAnimatedTransform(layer, duration, delta_x, delta_y);
238}
239
240int AddAnimatedTransformToLayer(cc::LayerImpl* layer,
241                                double duration,
242                                int delta_x,
243                                int delta_y) {
244  return AddAnimatedTransform(layer->layer_animation_controller(),
245                              duration,
246                              delta_x,
247                              delta_y);
248}
249
250}  // namespace cc
251