Refactor VR math off of GVR types, onto gfx types where possible.

chrome/browser/android/vr_shell/ui_scene.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_scene.h"
 
 #include <string>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/android/vr_shell/animation.h"
 #include "chrome/browser/android/vr_shell/easing.h"
 #include "chrome/browser/android/vr_shell/ui_elements.h"
+#include "device/vr/vr_math.h"
 
 namespace vr_shell {
 
 namespace {
 
 // Parse an integer to an int or enum value.
 template <typename T>
 bool ParseInt(const base::DictionaryValue& dict,
               const std::string& key,
               T* output) {
@@ skipping 13 matching lines @@
   double value;
   if (!dict.GetDouble(key, &value)) {
     return false;
   }
   *output = value;
   return true;
 }
 
 bool ParseColorf(const base::DictionaryValue& dict,
                  const std::string& key,
-                 Colorf* output) {
+                 vr::Colorf* output) {
   const base::DictionaryValue* item_dict;
   if (dict.GetDictionary(key, &item_dict)) {
     double value;
     CHECK(item_dict->GetDouble("r", &value));
     output->r = value;
     CHECK(item_dict->GetDouble("g", &value));
     output->g = value;
     CHECK(item_dict->GetDouble("b", &value));
     output->b = value;
     CHECK(item_dict->GetDouble("a", &value));
@@ skipping 82 matching lines @@
 }
 
 void ApplyAnchoring(const ContentRectangle& parent,
                     XAnchoring x_anchoring,
                     YAnchoring y_anchoring,
                     Transform* transform) {
   // To anchor a child, use the parent's size to find its edge.
   float x_offset;
   switch (x_anchoring) {
     case XLEFT:
-      x_offset = -0.5f * parent.size.x;
+      x_offset = -0.5f * parent.size.x();
       break;
     case XRIGHT:
-      x_offset = 0.5f * parent.size.x;
+      x_offset = 0.5f * parent.size.x();
       break;
     case XNONE:
       x_offset = 0.0f;
       break;
   }
   float y_offset;
   switch (y_anchoring) {
     case YTOP:
-      y_offset = 0.5f * parent.size.y;
+      y_offset = 0.5f * parent.size.y();
       break;
     case YBOTTOM:
-      y_offset = -0.5f * parent.size.y;
+      y_offset = -0.5f * parent.size.y();
       break;
     case YNONE:
       y_offset = 0.0f;
       break;
   }
-  transform->Translate(x_offset, y_offset, 0);
+  transform->Translate(gfx::Vector3dF(x_offset, y_offset, 0));
 }
 
 }  // namespace
 
 void UiScene::AddUiElement(std::unique_ptr<ContentRectangle> element) {
   CHECK_GE(element->id, 0);
   CHECK_EQ(GetUiElementById(element->id), nullptr);
   if (element->parent_id >= 0) {
     CHECK_NE(GetUiElementById(element->parent_id), nullptr);
   } else {
@@ skipping 182 matching lines @@
       elements.push_back(element.get());
     }
   }
   return elements;
 }
 
 bool UiScene::HasVisibleHeadLockedElements() const {
   return !GetHeadLockedElements().empty();
 }
 
-const Colorf& UiScene::GetBackgroundColor() const {
+const vr::Colorf& UiScene::GetBackgroundColor() const {
   return background_color_;
 }
 
 float UiScene::GetBackgroundDistance() const {
   return background_distance_;
 }
 
 bool UiScene::GetWebVrRenderingEnabled() const {
   return webvr_rendering_enabled_;
 }
@@ skipping 12 matching lines @@
     return;
 
   ContentRectangle* parent = nullptr;
   if (element->parent_id >= 0) {
     parent = GetUiElementById(element->parent_id);
     CHECK(parent != nullptr);
   }
 
   Transform* transform = element->mutable_transform();
   transform->MakeIdentity();
-  transform->Scale(element->size.x, element->size.y, element->size.z);
+  transform->Scale(element->size);
   element->computed_opacity = element->opacity;
   element->computed_lock_to_fov = element->lock_to_fov;
 
   // Compute an inheritable transformation that can be applied to this element,
   // and it's children, if applicable.
   Transform* inheritable = &element->inheritable_transform;
   inheritable->MakeIdentity();
-  inheritable->Scale(element->scale.x, element->scale.y, element->scale.z);
-  inheritable->Rotate(element->rotation.x, element->rotation.y,
-                      element->rotation.z, element->rotation.angle);
-  inheritable->Translate(element->translation.x, element->translation.y,
-                         element->translation.z);
+  inheritable->Scale(element->scale);
+  inheritable->Rotate(element->rotation);
+  inheritable->Translate(element->translation);
   if (parent) {
     ApplyAnchoring(*parent, element->x_anchoring, element->y_anchoring,
                    inheritable);
     ApplyRecursiveTransforms(parent);
-    inheritable->to_world = MatrixMul(parent->inheritable_transform.to_world,
-                                      inheritable->to_world);
+    vr::MatrixMul(parent->inheritable_transform.to_world, inheritable->to_world,
+                  &inheritable->to_world);
 
     element->computed_opacity *= parent->opacity;
     element->computed_lock_to_fov = parent->lock_to_fov;
   }
 
-  transform->to_world = MatrixMul(inheritable->to_world, transform->to_world);
+  vr::MatrixMul(inheritable->to_world, transform->to_world,
+                &transform->to_world);
   element->dirty = false;
 }
 
 void UiScene::ApplyDictToElement(const base::DictionaryValue& dict,
                                  ContentRectangle* element) {
   int parent_id;
 
   if (ParseInt(dict, "parentId", &parent_id)) {
     CHECK_GE(parent_id, 0);
     CHECK_NE(GetUiElementById(parent_id), nullptr);
     element->parent_id = parent_id;
   }
 
   dict.GetString("name", &element->name);
   dict.GetBoolean("visible", &element->visible);
   dict.GetBoolean("hitTestable", &element->hit_testable);
   dict.GetBoolean("lockToFov", &element->lock_to_fov);
   ParseInt(dict, "drawPhase", &element->draw_phase);
   ParseFloat(dict, "opacity", &element->opacity);
 
   DCHECK(!(element->lock_to_fov && element->parent_id != -1));
-
-  ParseFloat(dict, "sizeX", &element->size.x);
-  ParseFloat(dict, "sizeY", &element->size.y);
-  ParseFloat(dict, "scaleX", &element->scale.x);
-  ParseFloat(dict, "scaleY", &element->scale.y);
-  ParseFloat(dict, "scaleZ", &element->scale.z);
+  float val;
+  ParseFloat(dict, "sizeX", &val);
+  element->size.set_x(val);
+  ParseFloat(dict, "sizeY", &val);
+  element->size.set_y(val);
+  ParseFloat(dict, "scaleX", &val);
+  element->scale.set_x(val);
+  ParseFloat(dict, "scaleY", &val);
+  element->scale.set_y(val);
+  ParseFloat(dict, "scaleZ", &val);
+  element->scale.set_z(val);
+  ParseFloat(dict, "translationX", &val);
+  element->translation.set_x(val);
+  ParseFloat(dict, "translationY", &val);
+  element->translation.set_y(val);
+  ParseFloat(dict, "translationZ", &val);
+  element->translation.set_z(val);
   ParseFloat(dict, "rotationX", &element->rotation.x);
   ParseFloat(dict, "rotationY", &element->rotation.y);
   ParseFloat(dict, "rotationZ", &element->rotation.z);
   ParseFloat(dict, "rotationAngle", &element->rotation.angle);
-  ParseFloat(dict, "translationX", &element->translation.x);
-  ParseFloat(dict, "translationY", &element->translation.y);
-  ParseFloat(dict, "translationZ", &element->translation.z);
 
   if (ParseInt(dict, "xAnchoring", &element->x_anchoring)) {
     CHECK_GE(element->parent_id, 0);
   }
   if (ParseInt(dict, "yAnchoring", &element->y_anchoring)) {
     CHECK_GE(element->parent_id, 0);
   }
 
   // Parse the element fill.
   if (ParseInt(dict, "fillType", &element->fill)) {
     // If the previous content element has a new filling now make sure this is
     // tracked correctly.
     if (content_element_ == element && element->fill != Fill::CONTENT) {
       content_element_ = nullptr;
     }
 
+    int val;
     switch (element->fill) {
       case Fill::SPRITE:
-        CHECK(ParseInt(dict, "copyRectX", &element->copy_rect.x));
-        CHECK(ParseInt(dict, "copyRectY", &element->copy_rect.y));
-        CHECK(ParseInt(dict, "copyRectWidth", &element->copy_rect.width));
-        CHECK(ParseInt(dict, "copyRectHeight", &element->copy_rect.height));
+        CHECK(ParseInt(dict, "copyRectX", &val));
+        element->copy_rect.set_x(val);
+        CHECK(ParseInt(dict, "copyRectY", &val));
+        element->copy_rect.set_y(val);
+        CHECK(ParseInt(dict, "copyRectWidth", &val));
+        element->copy_rect.set_width(val);
+        CHECK(ParseInt(dict, "copyRectHeight", &val));
+        element->copy_rect.set_height(val);
         break;
       case Fill::OPAQUE_GRADIENT:
         CHECK(ParseColorf(dict, "edgeColor", &element->edge_color));
         CHECK(ParseColorf(dict, "centerColor", &element->center_color));
         break;
       case Fill::GRID_GRADIENT:
         CHECK(ParseColorf(dict, "edgeColor", &element->edge_color));
         CHECK(ParseColorf(dict, "centerColor", &element->center_color));
         CHECK(ParseInt(dict, "gridlineCount", &element->gridline_count));
         CHECK_GE(element->gridline_count, 0);
         break;
       case Fill::CONTENT:
         CHECK_EQ(content_element_, nullptr);
         content_element_ = element;
         break;
       default:
         element->fill = Fill::NONE;
         break;
     }
   }
 }
 
 }  // namespace vr_shell