Interpolated rotations should end cleanly where possible.

ui/gfx/interpolated_transform.cc

 // Copyright (c) 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 "ui/gfx/interpolated_transform.h"
 
 #include <cmath>
 
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
 #endif
 
 #include "base/logging.h"
 #include "ui/base/animation/tween.h"
 
 namespace {
 
 static const float EPSILON = 1e-6f;
 
+bool IsMultipleOfNinetyDegrees(float degrees)
+{

[sky, 2012/04/24 19:43:00]

nit: { on previous line (33 too).

+  float remainder = fabs(fmod(degrees, 90.0f));
+  return remainder < EPSILON || 90.0f - remainder < EPSILON;
+}
+
+// Returns false if |degrees| is not a multiple of ninety degrees or if
+// |rotation| is NULL. It does not affect |rotation| in this case. Otherwise
+// *rotation is set to be the appropriate sanitized rotation matrix. That is,
+// the rotation matrix corresponding to |degrees| which has entries that are all
+// either 0, 1 or -1.
+bool MassageRotationIfMultipleOfNinetyDegrees(ui::Transform* rotation,
+                                              float degrees)
+{
+  if (!IsMultipleOfNinetyDegrees(degrees) || !rotation)
+    return false;
+
+  ui::Transform transform;
+  SkMatrix44& m = transform.matrix();
+  float degrees_by_ninety = degrees / 90.0f;
+
+  int n = static_cast<int>(degrees_by_ninety > 0
+      ? floor(degrees_by_ninety + 0.5f)
+      : ceil(degrees_by_ninety - 0.5f));
+
+  n %= 4;
+  if (n < 0)
+    n += 4;
+
+  // n should now be in the range [0, 3]
+  if (n == 1) {
+    m.set3x3( 0,  1,  0,
+             -1,  0,  0,
+              0,  0,  1);
+  } else if (n == 2) {
+    m.set3x3(-1,  0,  0,
+              0, -1,  0,
+              0,  0,  1);
+  } else if (n == 3) {
+    m.set3x3( 0, -1,  0,
+              1,  0,  0,
+              0,  0,  1);
+  }
+
+  *rotation = transform;
+  return true;
+}
+
 } // namespace
 
 namespace ui {
 
 ///////////////////////////////////////////////////////////////////////////////
 // InterpolatedTransform
 //
 
 InterpolatedTransform::InterpolatedTransform()
     : start_time_(0.0f),
@@ skipping 120 matching lines @@
                                            float end_time)
     : InterpolatedTransform(start_time, end_time),
       start_degrees_(start_degrees),
       end_degrees_(end_degrees) {
 }
 
 InterpolatedRotation::~InterpolatedRotation() {}
 
 ui::Transform InterpolatedRotation::InterpolateButDoNotCompose(float t) const {
   ui::Transform result;
-  result.SetRotate(ValueBetween(t, start_degrees_, end_degrees_));
+  float interpolated_degrees = ValueBetween(t, start_degrees_, end_degrees_);
+  result.SetRotate(interpolated_degrees);
+  if (t == 0.0f || t == 1.0f)
+    MassageRotationIfMultipleOfNinetyDegrees(&result, interpolated_degrees);
   return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // InterpolatedAxisAngleRotation
 //
 
 InterpolatedAxisAngleRotation::InterpolatedAxisAngleRotation(
     gfx::Point3f axis,
     float start_degrees,
@@ skipping 90 matching lines @@
 }
 
 InterpolatedTranslation::~InterpolatedTranslation() {}
 
 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(),
@@ skipping 107 matching lines @@
 
     rotation->SetChild(translation.release());
     scale->SetChild(rotation.release());
     transform_.reset(scale.release());
   } else {
     transform_.reset(new InterpolatedConstantTransform(end_transform));
   }
 }
 
 } // namespace ui