Control the VrShell content quad via the HTML UI.

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 20 matching lines @@
 
 using base::android::JavaParamRef;
 
 namespace {
 // Constant taken from treasure_hunt demo.
 static constexpr long kPredictionTimeWithoutVsyncNanos = 50000000;
 
 static constexpr float kZNear = 0.1f;
 static constexpr float kZFar = 1000.0f;
 
-static constexpr gvr::Vec3f kDesktopPositionDefault = {0.0f, 0.0f, -2.0f};
-static constexpr float kDesktopHeightDefault = 1.6f;
-
 // Screen angle in degrees. 0 = vertical, positive = top closer.
 static constexpr float kDesktopScreenTiltDefault = 0;
 
-static constexpr float kScreenHeightRatio = 1.0f;
-static constexpr float kScreenWidthRatio = 16.0f / 9.0f;
-
 static constexpr float kReticleWidth = 0.025f;
 static constexpr float kReticleHeight = 0.025f;
 
 static constexpr float kLaserWidth = 0.01f;
 
 // Angle (radians) the beam down from the controller axis, for wrist comfort.
 static constexpr float kErgoAngleOffset = 0.26f;
 
 static constexpr gvr::Vec3f kOrigin = {0.0f, 0.0f, 0.0f};
 
 // In lieu of an elbow model, we assume a position for the user's hand.
 // TODO(mthiesse): Handedness options.
 static constexpr gvr::Vec3f kHandPosition = {0.2f, -0.5f, -0.2f};
 
+// If there is no content quad, and the reticle isn't hitting another element,
+// draw the reticle at this distance.
+static constexpr float kDefaultReticleDistance = 2.0f;
+
 // Fraction of the distance to the object the cursor is drawn at to avoid
 // rounding errors drawing the cursor behind the object.
 static constexpr float kReticleOffset = 0.99f;
 
 // Limit the rendering distance of the reticle to the distance to a corner of
 // the content quad, times this value. This lets the rendering distance
 // adjust according to content quad placement.
 static constexpr float kReticleDistanceMultiplier = 1.5f;
 
-// UI element 0 is the browser content rectangle.
-static constexpr int kBrowserUiElementId = 0;
-
 static constexpr int kFramePrimaryBuffer = 0;
 static constexpr int kFrameHeadlockedBuffer = 1;
 
 vr_shell::VrShell* g_instance;
 
 static const char kVrShellUIURL[] = "chrome://vr-shell-ui";
 
 float Distance(const gvr::Vec3f& vec1, const gvr::Vec3f& vec2) {
   float xdiff = (vec1.x - vec2.x);
   float ydiff = (vec1.y - vec2.y);
@@ skipping 27 matching lines @@
 
 }  // namespace
 
 namespace vr_shell {
 
 VrShell::VrShell(JNIEnv* env, jobject obj,
                  content::WebContents* main_contents,
                  ui::WindowAndroid* content_window,
                  content::WebContents* ui_contents,
                  ui::WindowAndroid* ui_window)
-    : desktop_screen_tilt_(kDesktopScreenTiltDefault),
-      desktop_height_(kDesktopHeightDefault),
-      main_contents_(main_contents),
+    : main_contents_(main_contents),
       ui_contents_(ui_contents),
       weak_ptr_factory_(this) {
   DCHECK(g_instance == nullptr);
   g_instance = this;
   j_vr_shell_.Reset(env, obj);
   scene_.reset(new UiScene);
   html_interface_.reset(new UiInterface);
   content_compositor_.reset(new VrCompositor(content_window, false));
   ui_compositor_.reset(new VrCompositor(ui_window, true));
 
-  float screen_width = kScreenWidthRatio * desktop_height_;
-  float screen_height = kScreenHeightRatio * desktop_height_;
-  std::unique_ptr<ContentRectangle> rect(new ContentRectangle());
-  rect->id = kBrowserUiElementId;
-  rect->size = {screen_width, screen_height, 1.0f};
-  rect->translation = kDesktopPositionDefault;
-  scene_->AddUiElement(rect);
-
   LoadUIContent();
 
   gvr::Mat4f identity;
   SetIdentityM(identity);
   webvr_head_pose_.resize(kPoseRingBufferSize, identity);
 }
 
 void VrShell::UpdateCompositorLayers(JNIEnv* env,
                                      const JavaParamRef<jobject>& obj) {
   content_compositor_->SetLayer(main_contents_);
@@ skipping 128 matching lines @@
     controller_quat_ = GetRotationFromZAxis(forward_vector);
   } else {
     ergo_neutral_pose = {0.0f, -sin(kErgoAngleOffset), -cos(kErgoAngleOffset)};
     controller_quat_ = controller_->Orientation();
   }
 
   gvr::Mat4f mat = QuatToMatrix(controller_quat_);
   gvr::Vec3f forward = MatrixVectorMul(mat, ergo_neutral_pose);
   gvr::Vec3f origin = kHandPosition;
 
-  target_element_ = nullptr;
-
-  ContentRectangle* content_plane =
-      scene_->GetUiElementById(kBrowserUiElementId);
-
-  float distance = content_plane->GetRayDistance(origin, forward);
-
   // If we place the reticle based on elements intersecting the controller beam,
   // we can end up with the reticle hiding behind elements, or jumping laterally
   // in the field of view. This is physically correct, but hard to use. For
   // usability, do the following instead:
   //
   // - Project the controller laser onto an outer surface, which is the
   //   closer of the desktop plane, or a distance-limiting sphere.
   // - Create a vector between the eyes and the outer surface point.
   // - If any UI elements intersect this vector, choose the closest to the eyes,
   //   and place the reticle at the intersection point.
 
   // Find distance to a corner of the content quad, and limit the cursor
   // distance to a multiple of that distance. This lets us keep the reticle on
   // the content plane near the content window, and on the surface of a sphere
   // in other directions. Note that this approach uses distance from controller,
   // rather than eye, for simplicity. This will make the sphere slightly
   // off-center.
-  gvr::Vec3f corner = {0.5f, 0.5f, 0.0f};
-  corner = MatrixVectorMul(content_plane->transform.to_world, corner);
-  float max_distance = Distance(origin, corner) * kReticleDistanceMultiplier;
-  if (distance > max_distance || distance <= 0.0f) {
-    distance = max_distance;
+  float distance = kDefaultReticleDistance;
+  ContentRectangle* content_plane = scene_->GetContentQuad();
+  if (content_plane) {
+    distance = content_plane->GetRayDistance(origin, forward);
+    gvr::Vec3f corner = {0.5f, 0.5f, 0.0f};
+    corner = MatrixVectorMul(content_plane->transform.to_world, corner);
+    float max_distance = Distance(origin, corner) * kReticleDistanceMultiplier;
+    if (distance > max_distance || distance <= 0.0f) {
+      distance = max_distance;
+    }
   }
+
   target_point_ = GetRayPoint(origin, forward, distance);
   gvr::Vec3f eye_to_target = target_point_;
   NormalizeVector(eye_to_target);
 
   // 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;
   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 || !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;
       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) {
         closest_element_distance = distance_to_plane;
         pixel_x =
             static_cast<int>(plane->copy_rect.width * x + plane->copy_rect.x);
         pixel_y =
             static_cast<int>(plane->copy_rect.height * y + plane->copy_rect.y);
 
         target_point_ = plane_intersection_point;
         target_element_ = plane;
-        input_target = (plane->id == kBrowserUiElementId)
-            ? content_input_manager_.get() : ui_input_manager_.get();
+        input_target = plane->content_quad ? content_input_manager_.get() :
+            ui_input_manager_.get();
       }
     }
   }
   bool new_target = input_target != current_input_target_;
   if (new_target && current_input_target_ != nullptr) {
     // Send a move event indicating that the pointer moved off of an element.
     gesture->type = WebInputEvent::MouseLeave;
     gesture->details.move.delta.x = 0;
     gesture->details.move.delta.y = 0;
     current_input_target_->ProcessUpdatedGesture(*gesture.get());
@@ skipping 54 matching lines @@
     // it. For now, removing it seems working fine.
     gvr_api_->ApplyNeckModel(head_pose, 1.0f);
   }
 
   // Bind the primary framebuffer.
   frame.BindBuffer(kFramePrimaryBuffer);
 
   HandleQueuedTasks();
 
   // Update the render position of all UI elements (including desktop).
-  float screen_tilt = desktop_screen_tilt_ * M_PI / 180.0f;
+  const float screen_tilt = kDesktopScreenTiltDefault * M_PI / 180.0f;
   scene_->UpdateTransforms(screen_tilt, UiScene::TimeInMicroseconds());
 
   UpdateController(GetForwardVector(head_pose));
 
   if (webvr_mode_) {
     DrawWebVr();
 
     // When using async reprojection, we need to know which pose was used in
     // the WebVR app for drawing this frame. Due to unknown amounts of
     // buffering in the compositor and SurfaceTexture, we read the pose number
@@ skipping 14 matching lines @@
 }
 
 void VrShell::DrawVrShell(const gvr::Mat4f& head_pose,
                           gvr::Frame &frame) {
   std::vector<const ContentRectangle*> head_locked_elements;
   std::vector<const ContentRectangle*> world_elements;
   for (const auto& rect : scene_->GetUiElements()) {
     if (!rect->visible) {
       continue;
     }
-    if (webvr_mode_ && rect->id == kBrowserUiElementId) {
-      continue;
-    }
     if (rect->lock_to_fov) {
       head_locked_elements.push_back(rect.get());
     } else {
       world_elements.push_back(rect.get());
     }
   }
 
   if (!webvr_mode_) {
     glEnable(GL_CULL_FACE);
     glEnable(GL_DEPTH_TEST);
@@ skipping 55 matching lines @@
     }
   }
 }
 
 void VrShell::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->id == kBrowserUiElementId) {
+    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_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_;
@@ skipping 165 matching lines @@
 gvr::GvrApi* VrShell::gvr_api() {
   return gvr_api_.get();
 }
 
 void VrShell::ContentSurfaceChanged(JNIEnv* env,
                                     const JavaParamRef<jobject>& object,
                                     jint width,
                                     jint height,
                                     const JavaParamRef<jobject>& surface) {
   content_compositor_->SurfaceChanged((int)width, (int)height, surface);
-  content::ScreenInfo result;
-  main_contents_->GetRenderWidgetHostView()->GetRenderWidgetHost()->
-      GetScreenInfo(&result);
-  float dpr = result.device_scale_factor;
-  scene_->GetUiElementById(kBrowserUiElementId)->copy_rect =
-      { 0, 0, width / dpr, height / dpr };
 }
 
 void VrShell::UiSurfaceChanged(JNIEnv* env,
                                const JavaParamRef<jobject>& object,
                                jint width,
                                jint height,
                                const JavaParamRef<jobject>& surface) {
   ui_compositor_->SurfaceChanged((int)width, (int)height, surface);
   content::ScreenInfo result;
   ui_contents_->GetRenderWidgetHostView()->GetRenderWidgetHost()->GetScreenInfo(
@@ skipping 65 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