VR: Fix dynamic resizing webVR page, revert FOV calculation changes.

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 <chrono>
 #include <limits>
 #include <utility>
 
@@ skipping 90 matching lines @@
     quat.qw = 0.0f;
   } else {
     quat.qx = vec.y();
     quat.qy = -vec.x();
     quat.qz = 0.0f;
     vr::NormalizeQuat(&quat);
   }
   return quat;
 }
 
+gvr::Mat4f PerspectiveMatrixFromView(const gvr::Rectf& fov,
+                                     float z_near,
+                                     float z_far) {
+  gvr::Mat4f result;
+  const float x_left = -std::tan(fov.left * M_PI / 180.0f) * z_near;
+  const float x_right = std::tan(fov.right * M_PI / 180.0f) * z_near;
+  const float y_bottom = -std::tan(fov.bottom * M_PI / 180.0f) * z_near;
+  const float y_top = std::tan(fov.top * M_PI / 180.0f) * z_near;
+
+  DCHECK(x_left < x_right && y_bottom < y_top && z_near < z_far &&
+         z_near > 0.0f && z_far > 0.0f);
+  const float X = (2 * z_near) / (x_right - x_left);
+  const float Y = (2 * z_near) / (y_top - y_bottom);
+  const float A = (x_right + x_left) / (x_right - x_left);
+  const float B = (y_top + y_bottom) / (y_top - y_bottom);
+  const float C = (z_near + z_far) / (z_near - z_far);
+  const float D = (2 * z_near * z_far) / (z_near - z_far);
+
+  for (int i = 0; i < 4; ++i) {
+    for (int j = 0; j < 4; ++j) {
+      result.m[i][j] = 0.0f;
+    }
+  }
+  result.m[0][0] = X;
+  result.m[0][2] = A;
+  result.m[1][1] = Y;
+  result.m[1][2] = B;
+  result.m[2][2] = C;
+  result.m[2][3] = D;
+  result.m[3][2] = -1;
+
+  return result;
+}
+
 std::unique_ptr<blink::WebMouseEvent> MakeMouseEvent(WebInputEvent::Type type,
                                                      double timestamp,
                                                      float x,
                                                      float y) {
   std::unique_ptr<blink::WebMouseEvent> mouse_event(new blink::WebMouseEvent(
       type, blink::WebInputEvent::kNoModifiers, timestamp));
   mouse_event->pointer_type = blink::WebPointerProperties::PointerType::kMouse;
   mouse_event->SetPositionInWidget(x, y);
   mouse_event->click_count = 1;
 
@@ skipping 22 matching lines @@
 }
 
 void GvrMatToMatf(const gvr::Mat4f& in, vr::Mat4f* out) {
   // If our std::array implementation doesn't have any non-data members, we can
   // just cast the gvr matrix to an std::array.
   static_assert(sizeof(in) == sizeof(*out),
                 "Cannot reinterpret gvr::Mat4f as vr::Matf");
   *out = *reinterpret_cast<vr::Mat4f*>(const_cast<gvr::Mat4f*>(&in));
 }
 
-gvr::Rectf GvrRectFromGfxRect(gfx::RectF rect) {
-  // gvr::Rectf bottom/top are reverse of gfx::RectF bottom/top.
-  return {rect.x(), rect.x() + rect.width(), rect.y(), rect.bottom()};
+gvr::Rectf UVFromGfxRect(gfx::RectF rect) {
+  return {rect.x(), rect.x() + rect.width(), 1.0f - rect.bottom(),
+          1.0f - rect.y()};
 }
 
-gfx::RectF GfxRectFromGvrRect(gvr::Rectf rect) {
-  return gfx::RectF(rect.left, rect.bottom, rect.right - rect.left,
+gfx::RectF GfxRectFromUV(gvr::Rectf rect) {
+  return gfx::RectF(rect.left, 1.0 - rect.top, rect.right - rect.left,
                     rect.top - rect.bottom);
 }
 
 }  // namespace
 
 VrShellGl::VrShellGl(
     const base::WeakPtr<VrShell>& weak_vr_shell,
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
     gvr_context* gvr_api,
     bool initially_web_vr,
@@ skipping 608 matching lines @@
       if (index < frame_index)
         index += max;
       // If the pending bounds change is for an upcoming frame
       // within our buffer size, wait to apply it. Otherwise, apply
       // it immediately. This guarantees that even if we miss many
       // frames, the queue can't fill up with stale bounds.
       if (index > frame_index && index <= frame_index + kPoseRingBufferSize)
         break;
 
       const WebVrBounds& bounds = pending_bounds_.front().second;
-      webvr_left_viewport_->SetSourceUv(GvrRectFromGfxRect(bounds.left_bounds));
-      webvr_right_viewport_->SetSourceUv(
-          GvrRectFromGfxRect(bounds.right_bounds));
+      webvr_left_viewport_->SetSourceUv(UVFromGfxRect(bounds.left_bounds));
+      webvr_right_viewport_->SetSourceUv(UVFromGfxRect(bounds.right_bounds));
       DVLOG(1) << __FUNCTION__ << ": resize from pending_bounds to "
                << bounds.source_size.width() << "x"
                << bounds.source_size.height();
       CreateOrResizeWebVRSurface(bounds.source_size);
       pending_bounds_.pop();
     }
     buffer_viewport_list_->SetBufferViewport(GVR_LEFT_EYE,
                                              *webvr_left_viewport_);
     buffer_viewport_list_->SetBufferViewport(GVR_RIGHT_EYE,
                                              *webvr_right_viewport_);
@@ skipping 81 matching lines @@
   if (!surfaceless_rendering_) {
     // TODO(mthiesse): Support asynchronous SwapBuffers.
     TRACE_EVENT0("gpu", "VrShellGl::SwapBuffers");
     surface_->SwapBuffers();
   }
 
 #if DCHECK_IS_ON()
   // After saving the timestamp, fps will be available via GetFPS().
   // TODO(vollick): enable rendering of this framerate in a HUD.
   fps_meter_->AddFrame(current_time);
-  LOG(ERROR) << "fps: " << fps_meter_->GetFPS();
+  DVLOG(1) << "fps: " << fps_meter_->GetFPS();
 #endif
 }
 
 void VrShellGl::DrawWorldElements(const vr::Mat4f& head_pose) {
   TRACE_EVENT0("gpu", "VrShellGl::DrawWorldElements");
 
   if (ShouldDrawWebVr()) {
     // WebVR is incompatible with 3D world compositing since the
     // depth buffer was already populated with unknown scaling - the
     // WebVR app has full control over zNear/zFar. Just leave the
@@ skipping 48 matching lines @@
 
   for (auto eye : {GVR_LEFT_EYE, GVR_RIGHT_EYE}) {
     buffer_viewport_list_->GetBufferViewport(eye + viewport_offset,
                                              buffer_viewport_.get());
 
     vr::Mat4f eye_view_matrix;
     vr::Mat4f eye_matrix;
     GvrMatToMatf(gvr_api_->GetEyeFromHeadMatrix(eye), &eye_matrix);
     vr::MatrixMul(eye_matrix, head_pose, &eye_view_matrix);
 
-    const gfx::RectF& rect =
-        GfxRectFromGvrRect(buffer_viewport_->GetSourceUv());
+    const gfx::RectF& rect = GfxRectFromUV(buffer_viewport_->GetSourceUv());
     const gfx::Rect& pixel_rect = CalculatePixelSpaceRect(render_size, rect);
     glViewport(pixel_rect.x(), pixel_rect.y(), pixel_rect.width(),
                pixel_rect.height());
 
     vr::Mat4f render_matrix;
     vr::Mat4f perspective_matrix;
-    vr::PerspectiveMatrixFromView(
-        GfxRectFromGvrRect(buffer_viewport_->GetSourceFov()), kZNear, kZFar,
-        &perspective_matrix);
+    GvrMatToMatf(PerspectiveMatrixFromView(buffer_viewport_->GetSourceFov(),
+                                           kZNear, kZFar),
+                 &perspective_matrix);
+
     vr::MatrixMul(perspective_matrix, eye_view_matrix, &render_matrix);
 
     DrawElements(render_matrix, elementsInDrawOrder);
     if (draw_cursor) {
       DrawCursor(render_matrix);
       DrawController(render_matrix);
     }
   }
 }
 
@@ skipping 218 matching lines @@
 
 void VrShellGl::SetWebVrMode(bool enabled) {
   web_vr_mode_ = enabled;
 }
 
 void VrShellGl::UpdateWebVRTextureBounds(int16_t frame_index,
                                          const gfx::RectF& left_bounds,
                                          const gfx::RectF& right_bounds,
                                          const gfx::Size& source_size) {
   if (frame_index < 0) {
-    webvr_left_viewport_->SetSourceUv(GvrRectFromGfxRect(left_bounds));
-    webvr_right_viewport_->SetSourceUv(GvrRectFromGfxRect(right_bounds));
+    webvr_left_viewport_->SetSourceUv(UVFromGfxRect(left_bounds));
+    webvr_right_viewport_->SetSourceUv(UVFromGfxRect(right_bounds));
     CreateOrResizeWebVRSurface(source_size);
   } else {
     pending_bounds_.emplace(
         frame_index, WebVrBounds(left_bounds, right_bounds, source_size));
   }
 }
 
 void VrShellGl::ContentBoundsChanged(int width, int height) {
   TRACE_EVENT0("gpu", "VrShellGl::ContentBoundsChanged");
   content_tex_css_width_ = width;
@@ skipping 120 matching lines @@
   // InitializeGl. Revisit if the initialization order changes.
   device::mojom::VRDisplayInfoPtr info =
       device::GvrDelegate::CreateVRDisplayInfo(gvr_api_.get(),
                                                webvr_surface_size_, device_id);
   main_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RunVRDisplayInfoCallback, callback, base::Passed(&info)));
 }
 
 }  // namespace vr_shell