Updated to GVR 1.0 SDK

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 114 matching lines @@
                            const JavaParamRef<jobject>& obj,
                            jint texture_data_handle) {
   CHECK(gl::GetGLImplementation() != gl::kGLImplementationNone ||
         gl::init::InitializeGLOneOff());
 
   content_texture_id_ = texture_data_handle;
   gvr_api_->InitializeGl();
   std::vector<gvr::BufferSpec> specs;
   specs.push_back(gvr_api_->CreateBufferSpec());
   render_size_ = specs[0].GetSize();
-  swap_chain_.reset(new gvr::SwapChain(gvr_api_->CreateSwapchain(specs)));
+  swap_chain_.reset(new gvr::SwapChain(gvr_api_->CreateSwapChain(specs)));
 
   vr_shell_renderer_.reset(new VrShellRenderer());
   buffer_viewport_list_.reset(
       new gvr::BufferViewportList(gvr_api_->CreateEmptyBufferViewportList()));
   buffer_viewport_.reset(
       new gvr::BufferViewport(gvr_api_->CreateBufferViewport()));
 }
 
 void VrShell::UpdateController() {
   if (!controller_active_) {
@@ skipping 30 matching lines @@
     translation.y += kHandPosition.y;
     translation.z += kHandPosition.z;
   }
 
   // We can only be intersecting the desktop plane at the moment.
   float distance_to_plane = desktop_plane_->GetRayDistance(translation,
                                                            forward);
   look_at_vector_ = GetRayPoint(translation, forward, distance_to_plane);
 }
 
-void ApplyNeckModel(gvr::Mat4f& mat_forward) {
-  // This assumes that the input matrix is a pure rotation matrix. The
-  // input object_from_reference matrix has the inverse rotation of
-  // the head rotation. Invert it (this is just a transpose).
-  gvr::Mat4f mat = MatrixTranspose(mat_forward);
-
-  // Position of the point between the eyes, relative to the neck pivot:
-  const float kNeckHorizontalOffset = -0.080f;  // meters in Z
-  const float kNeckVerticalOffset = 0.075f;     // meters in Y
-
-  std::array<float, 4> neckOffset = {
-      {0.0f, kNeckVerticalOffset, kNeckHorizontalOffset, 1.0f}};
-
-  // Rotate eyes around neck pivot point.
-  auto offset = MatrixVectorMul(mat, neckOffset);
-
-  // Measure new position relative to original center of head, because
-  // applying a neck model should not elevate the camera.
-  offset[1] -= kNeckVerticalOffset;
-
-  // Right-multiply the inverse translation onto the
-  // object_from_reference_matrix.
-  TranslateMRight(mat_forward, mat_forward, -offset[0], -offset[1], -offset[2]);
-}
-
 void VrShell::DrawFrame(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   buffer_viewport_list_->SetToRecommendedBufferViewports();
 
   gvr::Frame frame = swap_chain_->AcquireFrame();
   gvr::ClockTimePoint target_time = gvr::GvrApi::GetTimePointNow();
   target_time.monotonic_system_time_nanos += kPredictionTimeWithoutVsyncNanos;
-  head_pose_ = gvr_api_->GetHeadPoseInStartSpace(target_time);
+  head_pose_ = gvr_api_->GetHeadSpaceFromStartSpaceRotation(target_time);
+  head_pose_ = gvr_api_->ApplyNeckModel(head_pose_, 1.0f);
 
   // Bind back to the default framebuffer.
   frame.BindBuffer(0);
 
   if (webvr_mode_) {
     DrawWebVr();
   } else {
     DrawVrShell(target_time.monotonic_system_time_nanos);
   }
 
   frame.Unbind();
   frame.Submit(*buffer_viewport_list_, head_pose_);
 }
 
 void VrShell::DrawVrShell(int64_t time) {
   float screen_tilt = desktop_screen_tilt_ * M_PI / 180.0f;
 
   forward_vector_ = getForwardVector(head_pose_);
 
-  gvr::Vec3f headPos = getTranslation(head_pose_);
-  if (headPos.x == 0.0f && headPos.y == 0.0f && headPos.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.
-    ApplyNeckModel(head_pose_);
-  }
-
   desktop_plane_->translation.x = desktop_position_.x;
   desktop_plane_->translation.y = desktop_position_.y;
   desktop_plane_->translation.z = desktop_position_.z;
 
   // Update the render position of all UI elements (including desktop).
   scene_.UpdateTransforms(screen_tilt, time);
 
   UpdateController();
 
   // Everything should be positioned now, ready for drawing.
@@ skipping 115 matching lines @@
 
 void VrShell::DrawWebVr() {
   // Don't need face culling, depth testing, blending, etc. Turn it all off.
   glDisable(GL_CULL_FACE);
   glDepthMask(GL_FALSE);
   glDisable(GL_DEPTH_TEST);
   glDisable(GL_SCISSOR_TEST);
   glDisable(GL_BLEND);
   glDisable(GL_POLYGON_OFFSET_FILL);
 
   // Don't need to clear, since we're drawing over the entire render target.

[billorr, 2016/09/23 17:26:24]

comment is now out of date

+  glClear(GL_COLOR_BUFFER_BIT);
 
   glViewport(0, 0, render_size_.width, render_size_.height);
   vr_shell_renderer_->GetWebVrRenderer()->Draw(content_texture_id_);
 }
 
 void VrShell::OnPause(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   if (gvr_api_ == nullptr)
     return;
   gvr_api_->PauseTracking();
 }
@@ skipping 47 matching lines @@
            const JavaParamRef<jobject>& content_web_contents,
            jlong content_window_android) {
   content::ContentViewCore* c_core = content::ContentViewCore::FromWebContents(
       content::WebContents::FromJavaWebContents(content_web_contents));
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, c_core,
       reinterpret_cast<ui::WindowAndroid*>(content_window_android)));
 }
 
 }  // namespace vr_shell