Add VR Shell animation classes and unit test.

chrome/browser/android/vr_shell/ui_elements.cc

 // Copyright 2016 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 "chrome/browser/android/vr_shell/ui_elements.h"
 
 #include <cmath>
-#include <vector>
+
+#include "chrome/browser/android/vr_shell/animation.h"
 
 namespace vr_shell {
 
 namespace {
 
 float GetRayPlaneIntersection(gvr::Vec3f ray_origin,
                               gvr::Vec3f ray_vector,
                               gvr::Vec3f plane_origin,
                               gvr::Vec3f plane_normal) {
   float denom = vr_shell::VectorDot(ray_vector, plane_normal);
@@ skipping 60 matching lines @@
 float WorldRectangle::GetRayDistance(gvr::Vec3f ray_origin,
                                      gvr::Vec3f ray_vector) const {
   return GetRayPlaneIntersection(ray_origin, ray_vector, GetCenter(),
                                  GetNormal());
 }
 
 ContentRectangle::ContentRectangle() = default;
 
 ContentRectangle::~ContentRectangle() = default;
 
+void ContentRectangle::Animate(int64_t time) {
+  for (auto& it : animations) {
+    Animation& animation = *it;

[David Trainor- moved to gerrit, 2016/09/14 21:43:30]

Does it make sense to push this logic into Animation?

Random thoughts on this:
Could you build an Animation that knew how to modify a gvr::Vec3 or a Rectf? 
Then you could just call Animation::Animate(time) and let it do the magic
internally?

There are a lot of ways to flesh that out.  Just a thought.

[mthiesse, 2016/09/14 22:15:21]

(Full disclosure, I wrote this code originally :P)

There are various problems with various ways of doing this. We want to avoid
circular dependencies between Animation and ContentRectangle, and we want
ContentRectangle to manage the lifetime of the Animation.

Animation::Animate(time) suggests that we have either many Animation
constructors, many Animation subclasses, or Animation depends on
ContentRectangle, and that we also maintain pointers to the things we're
animating in Animation, which seems like a major pain.

Animation::Animate(time, gvr::Vec3&/Rectf&/etc.) with a few overloads could
work, with Animation being constructed with from/to vectors, though I'm not sure
how much better the code would look as we'd still need a switch statement here
to figure out which property is being animated.

[cjgrant, 2016/09/16 17:47:08]

Personally, I'd like to keep Animation as basically descriptor, leaving the
application to clients.  Later on, if we start duplicating application code,
we'll have a better sense of how to best generalize it here.  Is that okay?

+    if (time < animation.start)
+      continue;
+
+    // If |from| is not specified, start at the current values.
+    if (animation.from.size() == 0) {
+      switch (animation.property) {
+        case Animation::COPYRECT:
+          animation.from.push_back(copy_rect.x);
+          animation.from.push_back(copy_rect.y);
+          animation.from.push_back(copy_rect.width);
+          animation.from.push_back(copy_rect.height);
+          break;
+        case Animation::SIZE:
+          animation.from.push_back(size.x);
+          animation.from.push_back(size.y);
+          animation.from.push_back(size.z);
+          break;
+        case Animation::TRANSLATION:
+          animation.from.push_back(translation.x);
+          animation.from.push_back(translation.y);
+          animation.from.push_back(translation.z);
+          break;
+        case Animation::ROTATION:
+          animation.from.push_back(rotation_axis_angle[0]);
+          animation.from.push_back(rotation_axis_angle[1]);
+          animation.from.push_back(rotation_axis_angle[2]);
+          animation.from.push_back(rotation_axis_angle[3]);
+          break;
+        case Animation::UNUSED:
+          break;
+      }
+    }
+    DCHECK_EQ(animation.from.size(), animation.to.size());
+
+    std::vector<float> values(animation.from.size());
+    for (std::size_t i = 0; i < animation.from.size(); ++i) {
+      if (animation.to[i] == animation.from[i] ||
+          time >= (animation.start + animation.duration)) {
+        values[i] = animation.to[i];
+        continue;
+      }
+      double value = animation.easing->CalculateValue(
+          (double)(time - animation.start) / (double)animation.duration);
+      values[i] =
+          animation.from[i] + (value * (animation.to[i] - animation.from[i]));
+    }
+    switch (animation.property) {
+      case Animation::COPYRECT:
+        DCHECK_EQ(animation.from.size(), 4u);
+        copy_rect.x = values[0];
+        copy_rect.y = values[1];
+        copy_rect.width = values[2];
+        copy_rect.height = values[3];
+        break;
+      case Animation::SIZE:
+        DCHECK_EQ(animation.from.size(), 3u);
+        size.x = values[0];
+        size.y = values[1];
+        size.z = values[2];
+        break;
+      case Animation::TRANSLATION:
+        DCHECK_EQ(animation.from.size(), 3u);
+        translation.x = values[0];
+        translation.y = values[1];
+        translation.z = values[2];
+        break;
+      case Animation::ROTATION:
+        DCHECK_EQ(animation.from.size(), 4u);
+        rotation_axis_angle[0] = values[0];
+        rotation_axis_angle[1] = values[1];
+        rotation_axis_angle[2] = values[2];
+        rotation_axis_angle[3] = values[3];
+        break;
+      case Animation::UNUSED:
+        break;
+    }
+  }
+  for (auto it = animations.begin(); it != animations.end();) {
+    const Animation& animation = **it;
+    if (time >= (animation.start + animation.duration)) {
+      it = animations.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
 }  // namespace vr_shell