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,
-                                       ReversibleTransform* transform) {
+                                       ReversibleTransform* transform,
+                                       float* opacity) {
   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