cc/test/animation_test_common.cc

   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/keyframed_animation_curve.h"
   8 #include "cc/layer.h"
   9 #include "cc/layer_animation_controller.h"
  10 #include "cc/layer_impl.h"
  11 #include "cc/transform_operations.h"
  12
  13 using cc::Animation;
  14 using cc::AnimationCurve;
  15 using cc::EaseTimingFunction;
  16 using cc::FloatKeyframe;
  17 using cc::KeyframedFloatAnimationCurve;
  18 using cc::KeyframedTransformAnimationCurve;
  19 using cc::TimingFunction;
  20 using cc::TransformKeyframe;
  21
  22 namespace cc {
  23
  24 static int nextAnimationId = 0;
  25
  26 template <class Target>
  27 int addOpacityTransition(Target& target, double duration, float startOpacity, float endOpacity, bool useTimingFunction)
  28 {
  29     scoped_ptr<KeyframedFloatAnimationCurve> curve(KeyframedFloatAnimationCurve::create());
  30
  31     scoped_ptr<TimingFunction> func;
  32     if (!useTimingFunction)
  33         func = EaseTimingFunction::create();
  34     if (duration > 0)
  35         curve->addKeyframe(FloatKeyframe::create(0, startOpacity, func.Pass()));
  36     curve->addKeyframe(FloatKeyframe::create(duration, endOpacity, scoped_ptr<cc::TimingFunction>()));
  37
  38     int id = nextAnimationId++;
  39
  40     scoped_ptr<Animation> animation(Animation::create(curve.PassAs<AnimationCurve>(), id, 0, Animation::Opacity));
  41     animation->setNeedsSynchronizedStartTime(true);
  42
  43     target.addAnimation(animation.Pass());
  44     return id;
  45 }
  46
  47 template <class Target>
  48 int addAnimatedTransform(Target& target, double duration, int deltaX, int deltaY)
  49 {
  50     scoped_ptr<KeyframedTransformAnimationCurve> curve(KeyframedTransformAnimationCurve::create());
  51
  52     if (duration > 0) {
  53         TransformOperations startOperations;
  54         startOperations.AppendTranslate(deltaX, deltaY, 0);
  55         curve->addKeyframe(TransformKeyframe::create(0, startOperations, scoped_ptr<cc::TimingFunction>()));
  56     }
  57
  58     TransformOperations operations;
  59     operations.AppendTranslate(deltaX, deltaY, 0);
  60     curve->addKeyframe(TransformKeyframe::create(duration, operations, scoped_ptr<cc::TimingFunction>()));
  61
  62     int id = nextAnimationId++;
  63
  64     scoped_ptr<Animation> animation(Animation::create(curve.PassAs<AnimationCurve>(), id, 0, Animation::Transform));
  65     animation->setNeedsSynchronizedStartTime(true);
  66
  67     target.addAnimation(animation.Pass());
  68     return id;
  69 }
  70
  71 FakeFloatAnimationCurve::FakeFloatAnimationCurve()
  72     : m_duration(1)
  73 {
  74 }
  75
  76 FakeFloatAnimationCurve::FakeFloatAnimationCurve(double duration)
  77     : m_duration(duration)
  78 {
  79 }
  80
  81 FakeFloatAnimationCurve::~FakeFloatAnimationCurve()
  82 {
  83 }
  84
  85 double FakeFloatAnimationCurve::duration() const
  86 {
  87     return m_duration;
  88 }
  89
  90 float FakeFloatAnimationCurve::getValue(double now) const
  91 {
  92     return 0;
  93 }
  94
  95 scoped_ptr<cc::AnimationCurve> FakeFloatAnimationCurve::clone() const
  96 {
  97     return make_scoped_ptr(new FakeFloatAnimationCurve).PassAs<cc::AnimationCurve>();
  98 }
  99
 100 FakeTransformTransition::FakeTransformTransition(double duration)
 101     : m_duration(duration)
 102 {
 103 }
 104
 105 FakeTransformTransition::~FakeTransformTransition()
 106 {
 107 }
 108
 109 double FakeTransformTransition::duration() const
 110 {
 111     return m_duration;
 112 }
 113
 114 gfx::Transform FakeTransformTransition::getValue(double time) const
 115 {
 116     return gfx::Transform();
 117 }
 118
 119 scoped_ptr<cc::AnimationCurve> FakeTransformTransition::clone() const
 120 {
 121     return make_scoped_ptr(new FakeTransformTransition(*this)).PassAs<cc::AnimationCurve>();
 122 }
 123
 124
 125 FakeFloatTransition::FakeFloatTransition(double duration, float from, float to)
 126     : m_duration(duration)
 127     , m_from(from)
 128     , m_to(to)
 129 {
 130 }
 131
 132 FakeFloatTransition::~FakeFloatTransition()
 133 {
 134 }
 135
 136 double FakeFloatTransition::duration() const
 137 {
 138     return m_duration;
 139 }
 140
 141 float FakeFloatTransition::getValue(double time) const
 142 {
 143     time /= m_duration;
 144     if (time >= 1)
 145         time = 1;
 146     return (1 - time) * m_from + time * m_to;
 147 }
 148
 149 FakeLayerAnimationValueObserver::FakeLayerAnimationValueObserver()
 150     : m_opacity(0)
 151 {
 152 }
 153
 154 FakeLayerAnimationValueObserver::~FakeLayerAnimationValueObserver()
 155 {
 156 }
 157
 158 void FakeLayerAnimationValueObserver::OnOpacityAnimated(float opacity)
 159 {
 160     m_opacity = opacity;
 161 }
 162
 163 void FakeLayerAnimationValueObserver::OnTransformAnimated(const gfx::Transform& transform)
 164 {
 165     m_transform = transform;
 166 }
 167
 168 bool FakeLayerAnimationValueObserver::IsActive() const
 169 {
 170     return true;
 171 }
 172
 173 scoped_ptr<cc::AnimationCurve> FakeFloatTransition::clone() const
 174 {
 175     return make_scoped_ptr(new FakeFloatTransition(*this)).PassAs<cc::AnimationCurve>();
 176 }
 177
 178 int addOpacityTransitionToController(cc::LayerAnimationController& controller, double duration, float startOpacity, float endOpacity, bool useTimingFunction)
 179 {
 180     return addOpacityTransition(controller, duration, startOpacity, endOpacity, useTimingFunction);
 181 }
 182
 183 int addAnimatedTransformToController(cc::LayerAnimationController& controller, double duration, int deltaX, int deltaY)
 184 {
 185     return addAnimatedTransform(controller, duration, deltaX, deltaY);
 186 }
 187
 188 int addOpacityTransitionToLayer(cc::Layer& layer, double duration, float startOpacity, float endOpacity, bool useTimingFunction)
 189 {
 190     return addOpacityTransition(layer, duration, startOpacity, endOpacity, useTimingFunction);
 191 }
 192
 193 int addOpacityTransitionToLayer(cc::LayerImpl& layer, double duration, float startOpacity, float endOpacity, bool useTimingFunction)
 194 {
 195     return addOpacityTransition(*layer.layerAnimationController(), duration, startOpacity, endOpacity, useTimingFunction);
 196 }
 197
 198 int addAnimatedTransformToLayer(cc::Layer& layer, double duration, int deltaX, int deltaY)
 199 {
 200     return addAnimatedTransform(layer, duration, deltaX, deltaY);
 201 }
 202
 203 int addAnimatedTransformToLayer(cc::LayerImpl& layer, double duration, int deltaX, int deltaY)
 204 {
 205     return addAnimatedTransform(*layer.layerAnimationController(), duration, deltaX, deltaY);
 206 }
 207
 208 }  // namespace cc