Add passive and FOV-locked properties to UI elements.

chrome/browser/android/vr_shell/vr_shell.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.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "chrome/browser/android/vr_shell/ui_elements.h"
 #include "chrome/browser/android/vr_shell/ui_interface.h"
 #include "chrome/browser/android/vr_shell/ui_scene.h"
@@ skipping 308 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;
   VrInputManager* input_target = nullptr;
 
   for (std::size_t i = 0; i < scene_->GetUiElements().size(); ++i) {
     const ContentRectangle* plane = scene_->GetUiElements()[i].get();
-    if (!plane->visible) {
+    if (!plane->visible || !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 109 matching lines @@
 void VrShell::DrawVrShell(const gvr::Mat4f& head_pose) {
   float screen_tilt = desktop_screen_tilt_ * M_PI / 180.0f;
 
   HandleQueuedTasks();
 
   // Update the render position of all UI elements (including desktop).
   scene_->UpdateTransforms(screen_tilt, UiScene::TimeInMicroseconds());
 
   UpdateController(GetForwardVector(head_pose));
 
-  // Everything should be positioned now, ready for drawing.
-  gvr::Mat4f left_eye_view_matrix =
-    MatrixMul(gvr_api_->GetEyeFromHeadMatrix(GVR_LEFT_EYE), head_pose);
-  gvr::Mat4f right_eye_view_matrix =
-      MatrixMul(gvr_api_->GetEyeFromHeadMatrix(GVR_RIGHT_EYE), head_pose);
-
   // Use culling to remove back faces.
   glEnable(GL_CULL_FACE);
 
   // Enable depth testing.
   glEnable(GL_DEPTH_TEST);
   glEnable(GL_SCISSOR_TEST);
 
   glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
 
   buffer_viewport_list_->GetBufferViewport(GVR_LEFT_EYE,
                                            buffer_viewport_.get());
-  DrawEye(left_eye_view_matrix, *buffer_viewport_);
+  DrawEye(GVR_LEFT_EYE, head_pose, *buffer_viewport_);
   buffer_viewport_list_->GetBufferViewport(GVR_RIGHT_EYE,
                                            buffer_viewport_.get());
-  DrawEye(right_eye_view_matrix, *buffer_viewport_);
+  DrawEye(GVR_RIGHT_EYE, head_pose, *buffer_viewport_);
 }
 
-void VrShell::DrawEye(const gvr::Mat4f& view_matrix,
+void VrShell::DrawEye(gvr::Eye eye,
+                      const gvr::Mat4f& head_pose,
                       const gvr::BufferViewport& params) {
+  gvr::Mat4f eye_matrix = gvr_api_->GetEyeFromHeadMatrix(eye);
+  gvr::Mat4f view_matrix = MatrixMul(eye_matrix, head_pose);
+
   gvr::Recti pixel_rect =
       CalculatePixelSpaceRect(render_size_, params.GetSourceUv());
   glViewport(pixel_rect.left, pixel_rect.bottom,
              pixel_rect.right - pixel_rect.left,
              pixel_rect.top - pixel_rect.bottom);
   glScissor(pixel_rect.left, pixel_rect.bottom,
             pixel_rect.right - pixel_rect.left,
             pixel_rect.top - pixel_rect.bottom);
 
-  gvr::Mat4f render_matrix = MatrixMul(
+  const gvr::Mat4f fov_render_matrix = MatrixMul(
+      PerspectiveMatrixFromView(params.GetSourceFov(), kZNear, kZFar),
+      eye_matrix);
+  const gvr::Mat4f world_render_matrix = MatrixMul(
       PerspectiveMatrixFromView(params.GetSourceFov(), kZNear, kZFar),
       view_matrix);
 
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
   // TODO(mthiesse): Draw order for transparency.
-  DrawUI(render_matrix);
-  DrawCursor(render_matrix);
+  DrawUI(world_render_matrix, fov_render_matrix);
+  DrawCursor(world_render_matrix);
 }
 
 bool VrShell::IsUiTextureReady() {
   return ui_tex_width_ > 0 && ui_tex_height_ > 0;
 }
 
 Rectf VrShell::MakeUiGlCopyRect(Recti pixel_rect) {
   CHECK(IsUiTextureReady());
   return Rectf({
       static_cast<float>(pixel_rect.x) / ui_tex_width_,
       static_cast<float>(pixel_rect.y) / ui_tex_height_,
       static_cast<float>(pixel_rect.width) / ui_tex_width_,
       static_cast<float>(pixel_rect.height) / ui_tex_height_});
 }
 
-void VrShell::DrawUI(const gvr::Mat4f& render_matrix) {
+void VrShell::DrawUI(const gvr::Mat4f& world_matrix,
+                     const gvr::Mat4f& fov_matrix) {
   for (const auto& rect : scene_->GetUiElements()) {
     if (!rect->visible) {
       continue;
     }
 
     Rectf copy_rect;
     jint texture_handle;
     if (rect->id == kBrowserUiElementId) {
       copy_rect = {0, 0, 1, 1};
       texture_handle = content_texture_id_;
     } else {
       copy_rect.x = static_cast<float>(rect->copy_rect.x) / ui_tex_width_;
       copy_rect.y = static_cast<float>(rect->copy_rect.y) / ui_tex_height_;
       copy_rect.width = static_cast<float>(rect->copy_rect.width) /
           ui_tex_width_;
       copy_rect.height = static_cast<float>(rect->copy_rect.height) /
           ui_tex_height_;
       texture_handle = ui_texture_id_;
     }
 
-    gvr::Mat4f transform = MatrixMul(render_matrix, rect->transform.to_world);
+    const gvr::Mat4f& view_matrix =
+        rect->lock_to_fov ? fov_matrix : world_matrix;
+    gvr::Mat4f transform = MatrixMul(view_matrix, rect->transform.to_world);
     vr_shell_renderer_->GetTexturedQuadRenderer()->Draw(
         texture_handle, transform, copy_rect);
   }
 }
 
 void VrShell::DrawCursor(const gvr::Mat4f& render_matrix) {
   gvr::Mat4f mat;
   SetIdentityM(mat);
 
   // Draw the reticle.
@@ skipping 327 matching lines @@
            const JavaParamRef<jobject>& ui_web_contents,
            jlong ui_window_android) {
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, content::WebContents::FromJavaWebContents(content_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(content_window_android),
       content::WebContents::FromJavaWebContents(ui_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(ui_window_android)));
 }
 
 }  // namespace vr_shell