VrShell background implemented in JS.

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 <utility>
 
 #include "base/android/jni_android.h"
 #include "base/callback_helpers.h"
@@ skipping 499 matching lines @@
         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;
       float y = 0.5f - rect_2d_point.y;
       bool is_inside = x >= 0.0f && x < 1.0f && y >= 0.0f && y < 1.0f;
       if (!is_inside)
         continue;
 
       closest_element_distance = distance_to_plane;
       Rectf pixel_rect;
-      if (plane->content_quad) {
+      if (plane->fill == Fill::CONTENT) {
         pixel_rect = {0, 0, content_tex_css_width_, content_tex_css_height_};
       } else {
         pixel_rect = {plane->copy_rect.x, plane->copy_rect.y,
                       plane->copy_rect.width, plane->copy_rect.height};
       }
       pixel_x = pixel_rect.width * x + pixel_rect.x;
       pixel_y = pixel_rect.height * y + pixel_rect.y;
 
       target_point_ = plane_intersection_point;
       target_element_ = plane.get();
-      input_target = plane->content_quad ? InputTarget::CONTENT
-                                         : InputTarget::UI;
+      input_target = (plane->fill == Fill::CONTENT) ? InputTarget::CONTENT
+                                                    : InputTarget::UI;
     }
   }
   SendEventsToTarget(input_target, pixel_x, pixel_y);
 }
 
 void VrShellGl::SendEventsToTarget(InputTarget input_target,
                                    int pixel_x,
                                    int pixel_y) {
   std::vector<std::unique_ptr<WebGestureEvent>> gesture_list =
       controller_->DetectGestures();
@@ skipping 176 matching lines @@
     // existing content in place in the primary buffer without
     // clearing. Currently, there aren't any world elements in WebVR
     // mode, this will need further testing if those get added
     // later.
   } else {
     // Non-WebVR mode, enable depth testing and clear the primary buffers.
     glEnable(GL_CULL_FACE);
     glEnable(GL_DEPTH_TEST);
     glDepthMask(GL_TRUE);
 
-    glClearColor(BackgroundRenderer::kFogBrightness,
-                 BackgroundRenderer::kFogBrightness,
-                 BackgroundRenderer::kFogBrightness, 1.0f);
+    glClearColor(kFogBrightness, kFogBrightness, kFogBrightness, 1.0f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   }
   if (!world_elements.empty()) {
     DrawUiView(&head_pose, world_elements, render_size_primary_,
                kViewportListPrimaryOffset);
   }
 
   if (!head_locked_elements.empty()) {
     // Add head-locked viewports. The list gets reset to just
     // the recommended viewports (for the primary buffer) each frame.
@@ skipping 40 matching lines @@
         CalculatePixelSpaceRect(render_size, buffer_viewport_->GetSourceUv());
     glViewport(pixel_rect.left, pixel_rect.bottom,
                pixel_rect.right - pixel_rect.left,
                pixel_rect.top - pixel_rect.bottom);
 
     const gvr::Mat4f render_matrix = MatrixMul(
         PerspectiveMatrixFromView(
             buffer_viewport_->GetSourceFov(), kZNear, kZFar),
         view_matrix);
 
-    if (!web_vr_mode_) {
-      // TODO(tiborg): Enable through the UI API.
-      // DrawBackground(render_matrix);
-    }
     DrawElements(render_matrix, elements);
     if (head_pose != nullptr && !web_vr_mode_) {
       DrawCursor(render_matrix);
     }
   }
 }
 
 void VrShellGl::DrawElements(
     const gvr::Mat4f& render_matrix,
     const std::vector<const ContentRectangle*>& elements) {
   for (const auto& rect : elements) {
-    Rectf copy_rect;
-    jint texture_handle;
-    if (rect->content_quad) {
-      copy_rect = {0, 0, 1, 1};
-      texture_handle = content_texture_id_;
-    } else {
-      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);
+    switch (rect->fill) {
+      case Fill::SPRITE: {
+        Rectf copy_rect;
+        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_;
+        jint texture_handle = ui_texture_id_;
+        vr_shell_renderer_->GetTexturedQuadRenderer()->Draw(
+            texture_handle, transform, copy_rect, rect->computed_opacity);
+        break;
+      }
+      case Fill::OPAQUE_GRADIENT: {
+        vr_shell_renderer_->GetGradientQuadRenderer()->Draw(
+            transform, rect->edge_color, rect->center_color,
+            rect->computed_opacity);
+        break;
+      }
+      case Fill::GRID_GRADIENT: {
+        vr_shell_renderer_->GetGradientGridRenderer()->Draw(
+            transform, rect->edge_color, rect->center_color,
+            rect->gridline_count, rect->computed_opacity);
+        break;
+      }
+      case Fill::CONTENT: {
+        Rectf copy_rect = {0, 0, 1, 1};
+        jint texture_handle = content_texture_id_;
+        vr_shell_renderer_->GetTexturedQuadRenderer()->Draw(
+            texture_handle, transform, copy_rect, rect->computed_opacity);
+        break;
+      }
+      default:
+        break;
     }
-    gvr::Mat4f transform = MatrixMul(render_matrix, rect->transform.to_world);
-    vr_shell_renderer_->GetTexturedQuadRenderer()->Draw(
-        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 70 matching lines @@
   glDepthMask(GL_FALSE);
   glDisable(GL_DEPTH_TEST);
   glDisable(GL_SCISSOR_TEST);
   glDisable(GL_BLEND);
   glDisable(GL_POLYGON_OFFSET_FILL);
 
   glViewport(0, 0, render_size_primary_.width, render_size_primary_.height);
   vr_shell_renderer_->GetWebVrRenderer()->Draw(webvr_texture_id_);
 }
 
-void VrShellGl::DrawBackground(const gvr::Mat4f& render_matrix) {
-  vr_shell_renderer_->GetBackgroundRenderer()->Draw(render_matrix);
-}
-
 void VrShellGl::OnTriggerEvent() {
   // Set a flag to handle this on the render thread at the next frame.
   touch_pending_ = true;
 }
 
 void VrShellGl::OnPause() {
   vsync_task_.Cancel();
   controller_->OnPause();
   gvr_api_->PauseTracking();
 }
@@ skipping 142 matching lines @@
     const base::Callback<void(device::mojom::VRDisplayInfoPtr)>& callback,
     uint32_t device_id) {
   device::mojom::VRDisplayInfoPtr info = VrShell::CreateVRDisplayInfo(
       gvr_api_.get(), content_tex_physical_size_, device_id);
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RunVRDisplayInfoCallback, callback, base::Passed(&info)));
 }
 
 }  // namespace vr_shell