cc/keyframed_animation_curve.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/keyframed_animation_curve.h"
   6
   7 using WebKit::WebTransformationMatrix;
   8
   9 namespace cc {
  10
  11 namespace {
  12
  13 template <class Keyframe>
  14 void insertKeyframe(scoped_ptr<Keyframe> keyframe, ScopedPtrVector<Keyframe>& keyframes)
  15 {
  16     // Usually, the keyframes will be added in order, so this loop would be unnecessary and
  17     // we should skip it if possible.
  18     if (!keyframes.isEmpty() && keyframe->time() < keyframes.last()->time()) {
  19         for (size_t i = 0; i < keyframes.size(); ++i) {
  20             if (keyframe->time() < keyframes[i]->time()) {
  21                 keyframes.insert(i, keyframe.Pass());
  22                 return;
  23             }
  24         }
  25     }
  26
  27     keyframes.append(keyframe.Pass());
  28 }
  29
  30 scoped_ptr<TimingFunction> cloneTimingFunction(const TimingFunction* timingFunction)
  31 {
  32     DCHECK(timingFunction);
  33     scoped_ptr<AnimationCurve> curve(timingFunction->clone());
  34     return scoped_ptr<TimingFunction>(static_cast<TimingFunction*>(curve.release()));
  35 }
  36
  37 } // namespace
  38
  39 Keyframe::Keyframe(double time, scoped_ptr<TimingFunction> timingFunction)
  40     : m_time(time)
  41     , m_timingFunction(timingFunction.Pass())
  42 {
  43 }
  44
  45 Keyframe::~Keyframe()
  46 {
  47 }
  48
  49 double Keyframe::time() const
  50 {
  51     return m_time;
  52 }
  53
  54 const TimingFunction* Keyframe::timingFunction() const
  55 {
  56     return m_timingFunction.get();
  57 }
  58
  59 scoped_ptr<FloatKeyframe> FloatKeyframe::create(double time, float value, scoped_ptr<TimingFunction> timingFunction)
  60 {
  61     return make_scoped_ptr(new FloatKeyframe(time, value, timingFunction.Pass()));
  62 }
  63
  64 FloatKeyframe::FloatKeyframe(double time, float value, scoped_ptr<TimingFunction> timingFunction)
  65     : Keyframe(time, timingFunction.Pass())
  66     , m_value(value)
  67 {
  68 }
  69
  70 FloatKeyframe::~FloatKeyframe()
  71 {
  72 }
  73
  74 float FloatKeyframe::value() const
  75 {
  76     return m_value;
  77 }
  78
  79 scoped_ptr<FloatKeyframe> FloatKeyframe::clone() const
  80 {
  81     scoped_ptr<TimingFunction> func;
  82     if (timingFunction())
  83         func = cloneTimingFunction(timingFunction());
  84     return FloatKeyframe::create(time(), value(), func.Pass());
  85 }
  86
  87 scoped_ptr<TransformKeyframe> TransformKeyframe::create(double time, const WebKit::WebTransformOperations& value, scoped_ptr<TimingFunction> timingFunction)
  88 {
  89     return make_scoped_ptr(new TransformKeyframe(time, value, timingFunction.Pass()));
  90 }
  91
  92 TransformKeyframe::TransformKeyframe(double time, const WebKit::WebTransformOperations& value, scoped_ptr<TimingFunction> timingFunction)
  93     : Keyframe(time, timingFunction.Pass())
  94     , m_value(value)
  95 {
  96 }
  97
  98 TransformKeyframe::~TransformKeyframe()
  99 {
 100 }
 101
 102 const WebKit::WebTransformOperations& TransformKeyframe::value() const
 103 {
 104     return m_value;
 105 }
 106
 107 scoped_ptr<TransformKeyframe> TransformKeyframe::clone() const
 108 {
 109     scoped_ptr<TimingFunction> func;
 110     if (timingFunction())
 111         func = cloneTimingFunction(timingFunction());
 112     return TransformKeyframe::create(time(), value(), func.Pass());
 113 }
 114
 115 scoped_ptr<KeyframedFloatAnimationCurve> KeyframedFloatAnimationCurve::create()
 116 {
 117     return make_scoped_ptr(new KeyframedFloatAnimationCurve);
 118 }
 119
 120 KeyframedFloatAnimationCurve::KeyframedFloatAnimationCurve()
 121 {
 122 }
 123
 124 KeyframedFloatAnimationCurve::~KeyframedFloatAnimationCurve()
 125 {
 126 }
 127
 128 void KeyframedFloatAnimationCurve::addKeyframe(scoped_ptr<FloatKeyframe> keyframe)
 129 {
 130     insertKeyframe(keyframe.Pass(), m_keyframes);
 131 }
 132
 133 double KeyframedFloatAnimationCurve::duration() const
 134 {
 135     return m_keyframes.last()->time() - m_keyframes.first()->time();
 136 }
 137
 138 scoped_ptr<AnimationCurve> KeyframedFloatAnimationCurve::clone() const
 139 {
 140     scoped_ptr<KeyframedFloatAnimationCurve> toReturn(KeyframedFloatAnimationCurve::create());
 141     for (size_t i = 0; i < m_keyframes.size(); ++i)
 142         toReturn->addKeyframe(m_keyframes[i]->clone());
 143     return toReturn.PassAs<AnimationCurve>();
 144 }
 145
 146 float KeyframedFloatAnimationCurve::getValue(double t) const
 147 {
 148     if (t <= m_keyframes.first()->time())
 149         return m_keyframes.first()->value();
 150
 151     if (t >= m_keyframes.last()->time())
 152         return m_keyframes.last()->value();
 153
 154     size_t i = 0;
 155     for (; i < m_keyframes.size() - 1; ++i) {
 156         if (t < m_keyframes[i+1]->time())
 157             break;
 158     }
 159
 160     float progress = static_cast<float>((t - m_keyframes[i]->time()) / (m_keyframes[i+1]->time() - m_keyframes[i]->time()));
 161
 162     if (m_keyframes[i]->timingFunction())
 163         progress = m_keyframes[i]->timingFunction()->getValue(progress);
 164
 165     return m_keyframes[i]->value() + (m_keyframes[i+1]->value() - m_keyframes[i]->value()) * progress;
 166 }
 167
 168 scoped_ptr<KeyframedTransformAnimationCurve> KeyframedTransformAnimationCurve::create()
 169 {
 170     return make_scoped_ptr(new KeyframedTransformAnimationCurve);
 171 }
 172
 173 KeyframedTransformAnimationCurve::KeyframedTransformAnimationCurve()
 174 {
 175 }
 176
 177 KeyframedTransformAnimationCurve::~KeyframedTransformAnimationCurve()
 178 {
 179 }
 180
 181 void KeyframedTransformAnimationCurve::addKeyframe(scoped_ptr<TransformKeyframe> keyframe)
 182 {
 183     insertKeyframe(keyframe.Pass(), m_keyframes);
 184 }
 185
 186 double KeyframedTransformAnimationCurve::duration() const
 187 {
 188     return m_keyframes.last()->time() - m_keyframes.first()->time();
 189 }
 190
 191 scoped_ptr<AnimationCurve> KeyframedTransformAnimationCurve::clone() const
 192 {
 193     scoped_ptr<KeyframedTransformAnimationCurve> toReturn(KeyframedTransformAnimationCurve::create());
 194     for (size_t i = 0; i < m_keyframes.size(); ++i)
 195         toReturn->addKeyframe(m_keyframes[i]->clone());
 196     return toReturn.PassAs<AnimationCurve>();
 197 }
 198
 199 WebTransformationMatrix KeyframedTransformAnimationCurve::getValue(double t) const
 200 {
 201     if (t <= m_keyframes.first()->time())
 202         return m_keyframes.first()->value().apply();
 203
 204     if (t >= m_keyframes.last()->time())
 205         return m_keyframes.last()->value().apply();
 206
 207     size_t i = 0;
 208     for (; i < m_keyframes.size() - 1; ++i) {
 209         if (t < m_keyframes[i+1]->time())
 210             break;
 211     }
 212
 213     double progress = (t - m_keyframes[i]->time()) / (m_keyframes[i+1]->time() - m_keyframes[i]->time());
 214
 215     if (m_keyframes[i]->timingFunction())
 216         progress = m_keyframes[i]->timingFunction()->getValue(progress);
 217
 218     return m_keyframes[i+1]->value().blend(m_keyframes[i]->value(), progress);
 219 }
 220
 221 }  // namespace cc