VrShell: Restore smooth reticle positioning in the user FOV.

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 <thread>
 
 #include "chrome/browser/android/vr_shell/ui_scene.h"
 #include "chrome/browser/android/vr_shell/vr_compositor.h"
@@ skipping 49 matching lines @@
 
 // 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};
 
 // 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
+// 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;
 
 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);
   float zdiff = (vec1.z - vec2.z);
   float scale = xdiff * xdiff + ydiff * ydiff + zdiff * zdiff;
   return std::sqrt(scale);
 }
 
 // Generate a quaternion representing the rotation from the negative Z axis
-// (0, 0, -1) to a specified vector.  This is an optimized version of a more
+// (0, 0, -1) to a specified vector. This is an optimized version of a more
 // general vector-to-vector calculation.
 gvr::Quatf GetRotationFromZAxis(gvr::Vec3f vec) {
   vr_shell::NormalizeVector(vec);
   gvr::Quatf quat;
   quat.qw = 1.0f - vec.z;
   if (quat.qw < 1e-6f) {
     // Degenerate case: vectors are exactly opposite. Replace by an
     // arbitrary 180 degree rotation to avoid invalid normalization.
     quat.qx = 1.0f;
     quat.qy = 0.0f;
@@ skipping 132 matching lines @@
   }
 
   gvr::Mat4f mat = QuatToMatrix(controller_quat_);
   gvr::Vec3f forward = MatrixVectorMul(mat, kNeutralPose);
   gvr::Vec3f origin = kHandPosition;
 
   target_element_ = nullptr;
   float distance = scene_.GetUiElementById(kBrowserUiElementId)
       ->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
+  // 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.
-  // TODO(cjgrant): Note that this approach uses distance from controller,
-  // rather than eye, for simplicity.  This will make the sphere slightly
+  // 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(desktop_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) the cursor is pointing to.
+  // 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) {
       continue;
     }
-    float distance_to_plane = plane.GetRayDistance(origin, forward);
+    float distance_to_plane = plane.GetRayDistance(kOrigin, eye_to_target);
     gvr::Vec3f plane_intersection_point =
-        GetRayPoint(origin, forward, distance_to_plane);
+        GetRayPoint(kOrigin, eye_to_target, distance_to_plane);
 
     gvr::Vec3f rect_2d_point =
         MatrixVectorMul(plane.transform.from_world, plane_intersection_point);
-    float x = rect_2d_point.x + 0.5f;
-    float y = 0.5f - rect_2d_point.y;
     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;
@@ skipping 365 matching lines @@
       content::WebContents::FromJavaWebContents(content_web_contents));
   content::ContentViewCore* ui_core = content::ContentViewCore::FromWebContents(
       content::WebContents::FromJavaWebContents(ui_web_contents));
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, c_core,
       reinterpret_cast<ui::WindowAndroid*>(content_window_android), ui_core,
       reinterpret_cast<ui::WindowAndroid*>(ui_window_android)));
 }
 
 }  // namespace vr_shell