CC: Add curve (whole animation) timing function to compositor animations.

cc/animation/keyframed_animation_curve.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 
 #include "cc/animation/keyframed_animation_curve.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/box_f.h"
 
@@ skipping 11 matching lines @@
       if (keyframe->Time() < keyframes[i]->Time()) {
         keyframes.insert(keyframes.begin() + i, keyframe.Pass());
         return;
       }
     }
   }
 
   keyframes.push_back(keyframe.Pass());
 }
 
-template <class Keyframes>
-float GetProgress(double t, size_t i, const Keyframes& keyframes) {
-  float progress =
-      static_cast<float>((t - keyframes[i]->Time()) /
-                         (keyframes[i + 1]->Time() - keyframes[i]->Time()));
+template <typename Keyframe>

[ajuma, 2014/09/25 14:44:38]

I see the naming of this has been discussed already, but it seems confusing to
use 'Keyframe' here when that's already the name of a class. I'd prefer to use
something different, like KeyframeType as you had before.

[ikilpatrick, 2014/09/25 22:54:58]

Done.

+double TransformedAnimationTime(const ScopedPtrVector<Keyframe>& keyframes,
+                    const scoped_ptr<TimingFunction>& timing_function,
+                    double time) {
+  if (timing_function) {
+    double start_time = keyframes.front()->Time();
+    double duration = keyframes.back()->Time() - start_time;
+    double progress = (time - start_time) / duration;
 
-  if (keyframes[i]->timing_function())
+    time = timing_function->GetValue(progress) * duration + start_time;
+  }
+
+  return time;
+}
+
+template <typename Keyframe>
+size_t GetActiveKeyframe(const ScopedPtrVector<Keyframe>& keyframes,
+                         double time) {

[ajuma, 2014/09/25 14:44:38]

DCHECK_GE(keyframes.size(), 2ul);

[ikilpatrick, 2014/09/25 22:54:58]

Done.

+  size_t i = 0;
+  for (; i < keyframes.size() - 2; ++i) {  // Last keyframe is never active.
+    if (time < keyframes[i + 1]->Time())
+      break;
+  }
+
+  return i;
+}
+
+template <typename Keyframe>
+double TransformedKeyframeProgress(const ScopedPtrVector<Keyframe>& keyframes,
+                           double time,
+                           size_t i) {
+  double progress = (time - keyframes[i]->Time()) /
+                    (keyframes[i + 1]->Time() - keyframes[i]->Time());
+
+  if (keyframes[i]->timing_function()) {
     progress = keyframes[i]->timing_function()->GetValue(progress);
+  }
+
   return progress;
 }
 
 scoped_ptr<TimingFunction> CloneTimingFunction(
     const TimingFunction* timing_function) {
   DCHECK(timing_function);
   scoped_ptr<AnimationCurve> curve(timing_function->Clone());
   return scoped_ptr<TimingFunction>(
       static_cast<TimingFunction*>(curve.release()));
 }
@@ skipping 132 matching lines @@
 
 double KeyframedColorAnimationCurve::Duration() const {
   return keyframes_.back()->Time() - keyframes_.front()->Time();
 }
 
 scoped_ptr<AnimationCurve> KeyframedColorAnimationCurve::Clone() const {
   scoped_ptr<KeyframedColorAnimationCurve> to_return(
       KeyframedColorAnimationCurve::Create());
   for (size_t i = 0; i < keyframes_.size(); ++i)
     to_return->AddKeyframe(keyframes_[i]->Clone());
+
+  if (timing_function_)
+    to_return->SetTimingFunction(CloneTimingFunction(timing_function_.get()));
+
   return to_return.PassAs<AnimationCurve>();
 }
 
 SkColor KeyframedColorAnimationCurve::GetValue(double t) const {
   if (t <= keyframes_.front()->Time())
     return keyframes_.front()->Value();
 
   if (t >= keyframes_.back()->Time())
     return keyframes_.back()->Value();
 
-  size_t i = 0;
-  for (; i < keyframes_.size() - 1; ++i) {
-    if (t < keyframes_[i + 1]->Time())
-      break;
-  }
-
-  float progress = GetProgress(t, i, keyframes_);
+  t = TransformedAnimationTime(keyframes_, timing_function_, t);
+  size_t i = GetActiveKeyframe(keyframes_, t);
+  double progress = TransformedKeyframeProgress(keyframes_, t, i);
 
   return gfx::Tween::ColorValueBetween(
       progress, keyframes_[i]->Value(), keyframes_[i + 1]->Value());
 }
 
 // KeyframedFloatAnimationCurve
 
 scoped_ptr<KeyframedFloatAnimationCurve> KeyframedFloatAnimationCurve::
     Create() {
   return make_scoped_ptr(new KeyframedFloatAnimationCurve);
@@ skipping 10 matching lines @@
 
 double KeyframedFloatAnimationCurve::Duration() const {
   return keyframes_.back()->Time() - keyframes_.front()->Time();
 }
 
 scoped_ptr<AnimationCurve> KeyframedFloatAnimationCurve::Clone() const {
   scoped_ptr<KeyframedFloatAnimationCurve> to_return(
       KeyframedFloatAnimationCurve::Create());
   for (size_t i = 0; i < keyframes_.size(); ++i)
     to_return->AddKeyframe(keyframes_[i]->Clone());
+
+  if (timing_function_)
+    to_return->SetTimingFunction(CloneTimingFunction(timing_function_.get()));
+
   return to_return.PassAs<AnimationCurve>();
 }
 
 float KeyframedFloatAnimationCurve::GetValue(double t) const {
   if (t <= keyframes_.front()->Time())
     return keyframes_.front()->Value();
 
   if (t >= keyframes_.back()->Time())
     return keyframes_.back()->Value();
 
-  size_t i = 0;
-  for (; i < keyframes_.size() - 1; ++i) {
-    if (t < keyframes_[i+1]->Time())
-      break;
-  }
-
-  float progress = GetProgress(t, i, keyframes_);
+  t = TransformedAnimationTime(keyframes_, timing_function_, t);
+  size_t i = GetActiveKeyframe(keyframes_, t);
+  double progress = TransformedKeyframeProgress(keyframes_, t, i);
 
   return keyframes_[i]->Value() +
       (keyframes_[i+1]->Value() - keyframes_[i]->Value()) * progress;
 }
 
 scoped_ptr<KeyframedTransformAnimationCurve> KeyframedTransformAnimationCurve::
     Create() {
   return make_scoped_ptr(new KeyframedTransformAnimationCurve);
 }
 
 KeyframedTransformAnimationCurve::KeyframedTransformAnimationCurve() {}
 
 KeyframedTransformAnimationCurve::~KeyframedTransformAnimationCurve() {}
 
 void KeyframedTransformAnimationCurve::AddKeyframe(
     scoped_ptr<TransformKeyframe> keyframe) {
   InsertKeyframe(keyframe.Pass(), keyframes_);
 }
 
 double KeyframedTransformAnimationCurve::Duration() const {
   return keyframes_.back()->Time() - keyframes_.front()->Time();
 }
 
 scoped_ptr<AnimationCurve> KeyframedTransformAnimationCurve::Clone() const {
   scoped_ptr<KeyframedTransformAnimationCurve> to_return(
       KeyframedTransformAnimationCurve::Create());
   for (size_t i = 0; i < keyframes_.size(); ++i)
     to_return->AddKeyframe(keyframes_[i]->Clone());
+
+  if (timing_function_)
+    to_return->SetTimingFunction(CloneTimingFunction(timing_function_.get()));
+
   return to_return.PassAs<AnimationCurve>();
 }
 
-// Assumes that (*keyframes).front()->Time() < t < (*keyframes).back()-Time().
-template<typename ValueType, typename KeyframeType>
-static ValueType GetCurveValue(const ScopedPtrVector<KeyframeType>* keyframes,
-                               double t) {
-  size_t i = 0;
-  for (; i < keyframes->size() - 1; ++i) {
-    if (t < (*keyframes)[i+1]->Time())
-      break;
-  }
-
-  double progress = (t - (*keyframes)[i]->Time()) /
-                    ((*keyframes)[i+1]->Time() - (*keyframes)[i]->Time());
-
-  if ((*keyframes)[i]->timing_function())
-    progress = (*keyframes)[i]->timing_function()->GetValue(progress);
-
-  return (*keyframes)[i+1]->Value().Blend((*keyframes)[i]->Value(), progress);
-}
-
 gfx::Transform KeyframedTransformAnimationCurve::GetValue(double t) const {
   if (t <= keyframes_.front()->Time())
     return keyframes_.front()->Value().Apply();
 
   if (t >= keyframes_.back()->Time())
     return keyframes_.back()->Value().Apply();
 
-  return GetCurveValue<gfx::Transform, TransformKeyframe>(&keyframes_, t);
+  t = TransformedAnimationTime(keyframes_, timing_function_, t);
+  size_t i = GetActiveKeyframe(keyframes_, t);
+  double progress = TransformedKeyframeProgress(keyframes_, t, i);
+
+  return keyframes_[i + 1]->Value().Blend(keyframes_[i]->Value(), progress);
 }
 
 bool KeyframedTransformAnimationCurve::AnimatedBoundsForBox(
     const gfx::BoxF& box,
     gfx::BoxF* bounds) const {
   DCHECK_GE(keyframes_.size(), 2ul);
   *bounds = gfx::BoxF();
   for (size_t i = 0; i < keyframes_.size() - 1; ++i) {
     gfx::BoxF bounds_for_step;
     float min_progress = 0.0;
@@ skipping 65 matching lines @@
 
 double KeyframedFilterAnimationCurve::Duration() const {
   return keyframes_.back()->Time() - keyframes_.front()->Time();
 }
 
 scoped_ptr<AnimationCurve> KeyframedFilterAnimationCurve::Clone() const {
   scoped_ptr<KeyframedFilterAnimationCurve> to_return(
       KeyframedFilterAnimationCurve::Create());
   for (size_t i = 0; i < keyframes_.size(); ++i)
     to_return->AddKeyframe(keyframes_[i]->Clone());
+
+  if (timing_function_)
+    to_return->SetTimingFunction(CloneTimingFunction(timing_function_.get()));
+
   return to_return.PassAs<AnimationCurve>();
 }
 
 FilterOperations KeyframedFilterAnimationCurve::GetValue(double t) const {
   if (t <= keyframes_.front()->Time())
     return keyframes_.front()->Value();
 
   if (t >= keyframes_.back()->Time())
     return keyframes_.back()->Value();
 
-  return GetCurveValue<FilterOperations, FilterKeyframe>(&keyframes_, t);
+  t = TransformedAnimationTime(keyframes_, timing_function_, t);
+  size_t i = GetActiveKeyframe(keyframes_, t);
+  double progress = TransformedKeyframeProgress(keyframes_, t, i);
+
+  return keyframes_[i + 1]->Value().Blend(keyframes_[i]->Value(), progress);
 }
 
 bool KeyframedFilterAnimationCurve::HasFilterThatMovesPixels() const {
   for (size_t i = 0; i < keyframes_.size(); ++i) {
     if (keyframes_[i]->Value().HasFilterThatMovesPixels()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace cc