Interpolated transforms

ui/gfx/interpolated_transform.cc

Index: ui/gfx/interpolated_transform.cc
diff --git a/ui/gfx/interpolated_transform.cc b/ui/gfx/interpolated_transform.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bd9da4a45cd2a3138b9e1ad538f938625e10563e
--- /dev/null
+++ b/ui/gfx/interpolated_transform.cc
@@ -0,0 +1,210 @@
+// Copyright (c) 2011 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 "ui/gfx/interpolated_transform.h"
+
+#include "base/logging.h"
+#include "ui/base/animation/tween.h"
+
+namespace ui {
+
+///////////////////////////////////////////////////////////////////////////////
+// InterpolatedTransform
+//
+
+InterpolatedTransform::InterpolatedTransform()
+  : start_time_(0.0f),

[sky, 2011/06/28 15:39:14]

nit: 4 space indent (same comment for all constructors you have).

+    end_time_(1.0f) {
+}
+
+InterpolatedTransform::InterpolatedTransform(float start_time,
+                                             float end_time)
+  : start_time_(start_time),
+    end_time_(end_time) {
+}
+
+ui::Transform InterpolatedTransform::Interpolate(float t) const {
+  ui::Transform result = InterpolateButDoNotCompose(t);
+  if (child_.get()) {
+    result.ConcatTransform(child_->Interpolate(t));
+  }
+  return result;
+}
+
+inline float InterpolatedTransform::ValueBetween(float time,
+                                                 float start_value,
+                                                 float end_value) const
+{

[sky, 2011/06/28 15:39:14]

nit: { on previous line.

+  // can't handle NaN
+  DCHECK(time == time &&
+         start_time_ == start_time_ &&
+         end_time_ == end_time_);
+
+  if (time != time ||

[sky, 2011/06/28 15:39:14]

nit: fit as much as you can on one line.

+      start_time_ != start_time_ ||
+      end_time_ != end_time_)
+    return start_value;
+
+  // Ok if equal -- we'll get a step function. Note: if end_time_ ==
+  // start_time_ == x, then if none of the numbers are NaN, then it
+  // must be true that time < x or time >= x, so we will return early
+  // due to one of the following if statements.
+  DCHECK(end_time_ >= start_time_);
+
+  if (time < start_time_)
+    return start_value;
+
+  if (time >= end_time_)
+    return end_value;
+
+  float t = (time - start_time_) / (end_time_ - start_time_);
+  return static_cast<float>(Tween::ValueBetween(t, start_value, end_value));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// InterpolatedRotation
+//
+
+InterpolatedRotation::InterpolatedRotation(float start_degrees,
+                                           float end_degrees)
+  : InterpolatedTransform(),
+    start_degrees_(start_degrees),
+    end_degrees_(end_degrees) {
+}
+
+InterpolatedRotation::InterpolatedRotation(float start_degrees,
+                                           float end_degrees,
+                                           float start_time,
+                                           float end_time)
+  : InterpolatedTransform(start_time, end_time),
+    start_degrees_(start_degrees),
+    end_degrees_(end_degrees) {
+}
+
+ui::Transform InterpolatedRotation::InterpolateButDoNotCompose(float t) const {
+  ui::Transform result;
+  result.SetRotate(ValueBetween(t, start_degrees_, end_degrees_));
+  return result;
+}
+
+

[sky, 2011/06/28 15:39:14]

nit: remove newline.

+///////////////////////////////////////////////////////////////////////////////
+// InterpolatedScale
+//
+
+InterpolatedScale::InterpolatedScale(float start_scale,
+                                     float end_scale)
+  : InterpolatedTransform(),
+    start_scale_(start_scale),
+    end_scale_(end_scale) {
+}
+
+InterpolatedScale::InterpolatedScale(float start_scale,
+                                     float end_scale,
+                                     float start_time,
+                                     float end_time)
+  : InterpolatedTransform(start_time, end_time),
+    start_scale_(start_scale),
+    end_scale_(end_scale) {
+}
+
+ui::Transform InterpolatedScale::InterpolateButDoNotCompose(float t) const {
+  ui::Transform result;
+  float interpolated_scale = ValueBetween(t, start_scale_, end_scale_);
+  //TODO(vollick) 3d xforms.
+  result.SetScale(interpolated_scale, interpolated_scale);
+  return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// InterpolatedTranslation
+//
+
+InterpolatedTranslation::InterpolatedTranslation(const gfx::Point& start_pos,
+                                                 const gfx::Point& end_pos)
+  : InterpolatedTransform(),
+    start_pos_(start_pos),
+    end_pos_(end_pos) {
+}
+
+InterpolatedTranslation::InterpolatedTranslation(const gfx::Point& start_pos,
+                                                 const gfx::Point& end_pos,
+                                                 float start_time,
+                                                 float end_time)
+  : InterpolatedTransform(start_time, end_time),
+    start_pos_(start_pos),
+    end_pos_(end_pos) {
+}
+
+ui::Transform
+InterpolatedTranslation::InterpolateButDoNotCompose(float t) const {
+  ui::Transform result;
+  //TODO(vollick) 3d xforms.
+  result.SetTranslate(ValueBetween(t, start_pos_.x(), end_pos_.x()),
+                      ValueBetween(t, start_pos_.y(), end_pos_.y()));
+
+  return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// InterpolatedConstantTransform
+//
+
+InterpolatedConstantTransform::InterpolatedConstantTransform(
+  const ui::Transform& transform)
+  : InterpolatedTransform(),
+    transform_(transform) {
+}
+
+ui::Transform
+InterpolatedConstantTransform::InterpolateButDoNotCompose(float t) const {
+  return transform_;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// InterpolatedTransformAboutPivot
+//
+
+InterpolatedTransformAboutPivot::InterpolatedTransformAboutPivot(
+  const gfx::Point& pivot,
+  InterpolatedTransform* transform)
+  : InterpolatedTransform() {
+  Init(pivot, transform);
+}
+
+InterpolatedTransformAboutPivot::InterpolatedTransformAboutPivot(
+  const gfx::Point& pivot,
+  InterpolatedTransform* transform,
+  float start_time,
+  float end_time)
+  : InterpolatedTransform() {
+  Init(pivot, transform);
+}
+
+ui::Transform
+InterpolatedTransformAboutPivot::InterpolateButDoNotCompose(float t) const {
+  if (transform_.get()) {
+    return transform_->Interpolate(t);
+  }
+  return ui::Transform();
+}
+
+void InterpolatedTransformAboutPivot::Init(const gfx::Point& pivot,
+                                           InterpolatedTransform* xform) {
+  ui::Transform toPivot;

[sky, 2011/06/28 15:39:14]

unix hacker style: to_pivot/from_pivot.

+  ui::Transform fromPivot;
+  toPivot.SetTranslate(-pivot.x(), -pivot.y());
+  fromPivot.SetTranslate(pivot.x(), pivot.y());
+
+  scoped_ptr<InterpolatedTransform> preTransform(

[sky, 2011/06/28 15:39:14]

pre_transform/post_transform.

+    new InterpolatedConstantTransform(toPivot));
+  scoped_ptr<InterpolatedTransform> postTransform(
+    new InterpolatedConstantTransform(fromPivot));
+
+  preTransform->Compose(xform);
+  xform->Compose(postTransform.release());
+  transform_.reset(preTransform.release());
+}
+
+} // namespace ui