Avoid duplicate math when computing VR scene hierarchy.

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"
@@ skipping 310 matching lines @@
       case Command::CONFIGURE_SCENE:
         ParseColorf(*data, "backgroundColor", &background_color_);
         ParseFloat(*data, "backgroundDistance", &background_distance_);
         data->GetBoolean("drawWebVr", &webvr_rendering_enabled_);
         break;
     }
   }
 }
 
 void UiScene::UpdateTransforms(int64_t time_in_micro) {
-  // Process all animations before calculating object transforms.
   for (auto& element : ui_elements_) {
+    // Process all animations before calculating object transforms.
     element->Animate(time_in_micro);
+    element->dirty = true;
   }
   for (auto& element : ui_elements_) {
-    Transform transform;
-    transform.MakeIdentity();
-    transform.Scale(element->size.x, element->size.y, element->size.z);
-    element->computed_opacity = 1.0f;
-    element->computed_lock_to_fov = false;
-    ApplyRecursiveTransforms(*element.get(), &transform,
-                             &element->computed_opacity,
-                             &element->computed_lock_to_fov);
-    element->SetTransform(transform);
+    ApplyRecursiveTransforms(element.get());
   }
 }
 
 ContentRectangle* UiScene::GetUiElementById(int element_id) {
   for (auto& element : ui_elements_) {
     if (element->id == element_id) {
       return element.get();
     }
   }
   return nullptr;
@@ skipping 37 matching lines @@
 
 const std::vector<std::unique_ptr<ContentRectangle>>& UiScene::GetUiElements()
     const {
   return ui_elements_;
 }
 
 UiScene::UiScene() = default;
 
 UiScene::~UiScene() = default;
 
-void UiScene::ApplyRecursiveTransforms(const ContentRectangle& element,
-                                       Transform* transform,
-                                       float* opacity,
-                                       bool* lock_to_fov) {
-  transform->Scale(element.scale.x, element.scale.y, element.scale.z);
-  transform->Rotate(element.rotation.x, element.rotation.y, element.rotation.z,
-                    element.rotation.angle);
-  transform->Translate(element.translation.x, element.translation.y,
-                       element.translation.z);
-  *opacity *= element.opacity;
-  // Head-locked state inherited from a parent element.
-  *lock_to_fov = element.lock_to_fov;
+void UiScene::ApplyRecursiveTransforms(ContentRectangle* element) {
+  if (!element->dirty)
+    return;
 
-  if (element.parent_id >= 0) {
-    const ContentRectangle* parent = GetUiElementById(element.parent_id);
+  ContentRectangle* parent = nullptr;
+  if (element->parent_id >= 0) {
+    parent = GetUiElementById(element->parent_id);
     CHECK(parent != nullptr);
-    ApplyAnchoring(*parent, element.x_anchoring, element.y_anchoring,
-                   transform);
-    ApplyRecursiveTransforms(*parent, transform, opacity, lock_to_fov);
   }
+
+  Transform* transform = element->mutable_transform();
+  transform->MakeIdentity();
+  transform->Scale(element->size.x, element->size.y, element->size.z);
+  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);
+  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);
+
+    element->computed_opacity *= parent->opacity;
+    element->computed_lock_to_fov = parent->lock_to_fov;
+  }
+
+  transform->to_world = MatrixMul(inheritable->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;
@@ skipping 57 matching lines @@
         content_element_ = element;
         break;
       default:
         element->fill = Fill::NONE;
         break;
     }
   }
 }
 
 }  // namespace vr_shell