Remove unnecessary UI element math.

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 <limits>
 #include <utility>
 
 #include "base/android/jni_android.h"
@@ skipping 22 matching lines @@
 namespace vr_shell {
 
 namespace {
 // TODO(mthiesse): If gvr::PlatformInfo().GetPosePredictionTime() is ever
 // exposed, use that instead (it defaults to 50ms on most platforms).
 static constexpr int64_t kPredictionTimeWithoutVsyncNanos = 50000000;
 
 static constexpr float kZNear = 0.1f;
 static constexpr float kZFar = 1000.0f;
 
-// Screen angle in degrees. 0 = vertical, positive = top closer.
-static constexpr float kDesktopScreenTiltDefault = 0;
-
 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};
 
@@ skipping 425 matching lines @@
   // that the sphere is centered at the controller, rather than the eye, for
   // simplicity.
   float distance = scene_->GetBackgroundDistance();
   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 = VectorLength(target_point_);
-  int pixel_x = 0;
-  int pixel_y = 0;
   target_element_ = nullptr;
+  float target_x;
+  float target_y;
 
   for (const auto& plane : scene_->GetUiElements()) {
     if (!plane->IsHitTestable())
       continue;
 
-    float distance_to_plane = plane->GetRayDistance(kOrigin, eye_to_target);
+    float distance_to_plane;
+    if (!plane->GetRayDistance(kOrigin, eye_to_target, &distance_to_plane))
+      continue;
+
+    if (distance_to_plane < 0 || distance_to_plane >= closest_element_distance)
+      continue;
+
     gvr::Vec3f plane_intersection_point =
         GetRayPoint(kOrigin, eye_to_target, distance_to_plane);
+    gvr::Vec2f unit_xy_point =
+        plane->GetUnitRectangleCoordinates(plane_intersection_point);
 
-    gvr::Vec3f rect_2d_point =
-        MatrixVectorMul(plane->transform.from_world, plane_intersection_point);
-    if (distance_to_plane < 0 ||
-        distance_to_plane >= closest_element_distance) {
-      continue;
-    }
-
-    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)
+    float x = 0.5f + unit_xy_point.x;
+    float y = 0.5f - unit_xy_point.y;
+    if (x < 0.0f || x >= 1.0f || y < 0.0f || y >= 1.0f)
       continue;
 
     closest_element_distance = distance_to_plane;
-    Rectf pixel_rect;
-    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();
+    target_x = x;
+    target_y = y;
   }
 
   // Treat UI elements, which do not show web content, as NONE input
   // targets since they cannot make use of the input anyway.
   InputTarget input_target = InputTarget::NONE;
+  int pixel_x = 0;
+  int pixel_y = 0;
+
   if (target_element_ != nullptr) {
+    Rectf pixel_rect;
+    if (target_element_->fill == Fill::CONTENT) {
+      pixel_rect = {0, 0, content_tex_css_width_, content_tex_css_height_};
+    } else {
+      pixel_rect = {target_element_->copy_rect.x, target_element_->copy_rect.y,
+                    target_element_->copy_rect.width,
+                    target_element_->copy_rect.height};
+    }
+    pixel_x = pixel_rect.x + pixel_rect.width * target_x;
+    pixel_y = pixel_rect.y + pixel_rect.height * target_y;
+
     switch (target_element_->fill) {
       case Fill::CONTENT:
         input_target = InputTarget::CONTENT;
         break;
       case Fill::SPRITE:
         input_target = InputTarget::UI;
         break;
       default:
-        input_target = InputTarget::NONE;
         break;
     }
   }
   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 =
@@ skipping 147 matching lines @@
   if (position.x == 0.0f && position.y == 0.0f && position.z == 0.0f) {
     // This appears to be a 3DOF pose without a neck model. Add one.
     // The head pose has redundant data. Assume we're only using the
     // object_from_reference_matrix, we're not updating position_external.
     // TODO: Not sure what object_from_reference_matrix is. The new api removed
     // it. For now, removing it seems working fine.
     gvr_api_->ApplyNeckModel(head_pose, 1.0f);
   }
 
   // Update the render position of all UI elements (including desktop).
-  const float screen_tilt = kDesktopScreenTiltDefault * M_PI / 180.0f;
-  scene_->UpdateTransforms(screen_tilt, TimeInMicroseconds());
+  scene_->UpdateTransforms(TimeInMicroseconds());
 
   UpdateController(GetForwardVector(head_pose));
 
   DrawVrShell(head_pose, frame);
 
   frame.Unbind();
   frame.Submit(*buffer_viewport_list_, head_pose);
 
   // No need to swap buffers for surfaceless rendering.
   if (!surfaceless_rendering_) {
@@ skipping 104 matching lines @@
       DrawCursor(render_matrix);
     }
   }
 }
 
 void VrShellGl::DrawElements(
     const gvr::Mat4f& view_proj_matrix,
     const gvr::Mat4f& view_matrix,
     const std::vector<const ContentRectangle*>& elements) {
   for (const auto* rect : elements) {
-    gvr::Mat4f transform =
-        MatrixMul(view_proj_matrix, rect->transform.to_world);
+    gvr::Mat4f transform = MatrixMul(view_proj_matrix, rect->TransformMatrix());
 
     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 =
@@ skipping 34 matching lines @@
 
 std::vector<const ContentRectangle*> VrShellGl::GetElementsInDrawOrder(
     const gvr::Mat4f& view_matrix,
     const std::vector<const ContentRectangle*>& elements) {
   typedef std::pair<float, const ContentRectangle*> DistanceElementPair;
   std::vector<DistanceElementPair> zOrderedElementPairs;
   zOrderedElementPairs.reserve(elements.size());
 
   for (const auto* element : elements) {
     // Distance is the abs(z) value in view space.
-    gvr::Vec3f element_position = GetTranslation(element->transform.to_world);
+    gvr::Vec3f element_position = GetTranslation(element->TransformMatrix());
     float distance =
         std::fabs(MatrixVectorMul(view_matrix, element_position).z);
     zOrderedElementPairs.push_back(std::make_pair(distance, element));
   }
 
   // Sort elements primarily based on their draw phase (lower draw phase first)
   // and secondarily based on their distance (larger distance first).
   std::sort(
       zOrderedElementPairs.begin(), zOrderedElementPairs.end(),
       [](const DistanceElementPair& first, const DistanceElementPair& second) {
@@ skipping 254 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