VrShell: Allow native control of UI element opacity.

chrome/browser/android/vr_shell/vr_shell_gl.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/vr_shell_gl.h"
 
 #include "base/android/jni_android.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 469 matching lines @@
 
   // Determine which UI element (if any) intersects the line between the eyes
   // and the controller target position.
   float closest_element_distance = std::numeric_limits<float>::infinity();
   int pixel_x = 0;
   int pixel_y = 0;
   target_element_ = nullptr;
   InputTarget input_target = InputTarget::NONE;
 
   for (const auto& plane : scene_->GetUiElements()) {
-    if (!plane->visible || !plane->hit_testable) {
+    if (!plane->visible || plane->computed_opacity == 0.0f ||

[cjgrant, 2017/01/11 16:45:47]

Checking opacity here relieves the HTML UI of having to manage both visibility
and opacity (it can use one or the other).  I stopped short of removing the
visibility toggle though, because in most cases, the toggle is more analogous to
"enabled".

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

Maybe add a function IsVisible() to ContentRectangle?

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

Done.

+        !plane->hit_testable) {
       continue;
     }
     float distance_to_plane = plane->GetRayDistance(kOrigin, eye_to_target);
     gvr::Vec3f plane_intersection_point =
         GetRayPoint(kOrigin, eye_to_target, distance_to_plane);
 
     gvr::Vec3f rect_2d_point =
         MatrixVectorMul(plane->transform.from_world, plane_intersection_point);
     if (distance_to_plane > 0 && distance_to_plane < closest_element_distance) {
       float x = rect_2d_point.x + 0.5f;
@@ skipping 193 matching lines @@
     ScheduleNextDrawFrame();
   }
 }
 
 void VrShellGl::DrawVrShell(const gvr::Mat4f& head_pose,
                             gvr::Frame &frame) {
   TRACE_EVENT0("gpu", "VrShellGl::DrawVrShell");
   std::vector<const ContentRectangle*> head_locked_elements;
   std::vector<const ContentRectangle*> world_elements;
   for (const auto& rect : scene_->GetUiElements()) {
-    if (!rect->visible) {
+    if (!rect->visible || rect->computed_opacity == 0.0f) {
       continue;
     }
     if (rect->lock_to_fov) {
       head_locked_elements.push_back(rect.get());
     } else {
       world_elements.push_back(rect.get());
     }
   }
 
   if (web_vr_mode_) {
@@ skipping 91 matching lines @@
       copy_rect.x = static_cast<float>(rect->copy_rect.x) / ui_tex_css_width_;
       copy_rect.y = static_cast<float>(rect->copy_rect.y) / ui_tex_css_height_;
       copy_rect.width = static_cast<float>(rect->copy_rect.width) /
           ui_tex_css_width_;
       copy_rect.height = static_cast<float>(rect->copy_rect.height) /
           ui_tex_css_height_;
       texture_handle = ui_texture_id_;
     }
     gvr::Mat4f transform = MatrixMul(render_matrix, rect->transform.to_world);
     vr_shell_renderer_->GetTexturedQuadRenderer()->Draw(
-        texture_handle, transform, copy_rect);
+        texture_handle, transform, copy_rect, rect->computed_opacity);
   }
 }
 
 void VrShellGl::DrawCursor(const gvr::Mat4f& render_matrix) {
   gvr::Mat4f mat;
   SetIdentityM(mat);
 
   // Draw the reticle.
 
   // Scale the pointer to have a fixed FOV size at any distance.
@@ skipping 170 matching lines @@
 void VrShellGl::ForceExitVr() {
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VrShell::ForceExitVr, weak_vr_shell_));
 }
 
 void VrShellGl::UpdateScene(std::unique_ptr<base::ListValue> commands) {
   scene_->HandleCommands(std::move(commands), TimeInMicroseconds());
 }
 
 }  // namespace vr_shell