VrShell: Allow native control of UI element opacity.

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 "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"
@@ skipping 78 matching lines @@
       break;
     case Animation::Property::SCALE:
       ParseFloats(dict, {"x", "y", "z"}, vec);
       break;
     case Animation::Property::ROTATION:
       ParseFloats(dict, {"x", "y", "z", "a"}, vec);
       break;
     case Animation::Property::TRANSLATION:
       ParseFloats(dict, {"x", "y", "z"}, vec);
       break;
+    case Animation::Property::OPACITY:
+      ParseFloats(dict, {"x"}, vec);
+      break;
   }
 }
 
 std::unique_ptr<easing::Easing> ParseEasing(
     const base::DictionaryValue& dict) {
   easing::EasingType easingType;
   CHECK(dict.GetInteger("type", reinterpret_cast<int*>(&easingType)));
   std::unique_ptr<easing::Easing> result;
 
   switch (easingType) {
@@ skipping 208 matching lines @@
 }
 
 void UiScene::UpdateTransforms(float screen_tilt, int64_t time_in_micro) {
   // Process all animations before calculating object transforms.
   for (auto& element : ui_elements_) {
     element->Animate(time_in_micro);
   }
   for (auto& element : ui_elements_) {
     element->transform.MakeIdentity();
     element->transform.Scale(element->size.x, element->size.y, element->size.z);
-    ApplyRecursiveTransforms(*element.get(), &element->transform);
+    element->computed_opacity = 1.0f;
+    ApplyRecursiveTransforms(*element.get(), &element->transform,
+                             &element->computed_opacity);
     element->transform.Rotate(1.0f, 0.0f, 0.0f, screen_tilt);
   }
 }
 
 ContentRectangle* UiScene::GetUiElementById(int element_id) {
   for (auto& element : ui_elements_) {
     if (element->id == element_id) {
       return element.get();
     }
   }
   return nullptr;
 }
 
 ContentRectangle* UiScene::GetContentQuad() {
   return content_element_;
 }
 
 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,

[mthiesse, 2017/01/11 18:33:04]

Unrelated, but can you add a TODO to be smarter about how we compute these
transforms? We could theoretically be doing a single pass.

[cjgrant, 2017/01/11 18:53:07]

Agreed.  There are multiple bits to this though:
1. Don't recompute parent transforms multiple times in the render loop.
2. Don't recompute transforms (other than pose-related) for elements that
haven't changed (animation or explicit update).

In lieu of shuffling the whole implementation to a tree structure, we could put
a dirty bit on the computed transform, and keep the recursive approach.  Dirty
bits would be cleared once per render cycle.  That addresses (1).  To achieve
(2), I think we need element changes to clear dirty bits of child elements as
well, and currently parents aren't aware of their kids (sounds blissful).

Thoughts?

[mthiesse, 2017/01/11 19:02:49]

Speaking as someone who's never had children, a dirty bit sounds like a good
idea.

[cjgrant, 2017/01/11 20:58:42]

Done.  Filed crbug/680253.

-                                       ReversibleTransform* transform) {
+                                       ReversibleTransform* transform,
+                                       float *opacity) {

[mthiesse, 2017/01/11 18:33:04]

float*

[cjgrant, 2017/01/11 20:58:42]

Done.

   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;
 
   if (element.parent_id >= 0) {
     const ContentRectangle* parent = GetUiElementById(element.parent_id);
     CHECK(parent != nullptr);
     ApplyAnchoring(*parent, element.x_anchoring, element.y_anchoring,
                    transform);
-    ApplyRecursiveTransforms(*parent, transform);
+    ApplyRecursiveTransforms(*parent, transform, opacity);
   }
 }
 
 void UiScene::ApplyDictToElement(const base::DictionaryValue& dict,
                                  ContentRectangle *element) {
   int parent_id;
   if (dict.GetInteger("parentId", &parent_id)) {
     CHECK_GE(parent_id, 0);
     CHECK_NE(GetUiElementById(parent_id), nullptr);
     element->parent_id = parent_id;
   }
 
   dict.GetBoolean("visible", &element->visible);
   dict.GetBoolean("hitTestable", &element->hit_testable);
   dict.GetBoolean("lockToFov", &element->lock_to_fov);
   ParseRecti(dict, "copyRect", &element->copy_rect);
   Parse2DVec3f(dict, "size", &element->size);
   ParseVec3f(dict, "scale", &element->scale);
   ParseRotationAxisAngle(dict, "rotation", &element->rotation);
   ParseVec3f(dict, "translation", &element->translation);
+  double opacity;
+  if (dict.GetDouble("opacity", &opacity)) {
+    element->opacity = opacity;
+  }
 
   if (dict.GetBoolean("contentQuad", &element->content_quad)) {
     if (element->content_quad) {
       CHECK_EQ(content_element_, nullptr);
       content_element_ = element;
     } else {
       if (content_element_ == element) {
         content_element_ = nullptr;
       }
     }
   }
 
   if (dict.GetInteger("xAnchoring",
                       reinterpret_cast<int*>(&element->x_anchoring))) {
     CHECK_GE(element->parent_id, 0);
   }
   if (dict.GetInteger("yAnchoring",
                       reinterpret_cast<int*>(&element->y_anchoring))) {
     CHECK_GE(element->parent_id, 0);
   }
 }
 
 }  // namespace vr_shell