WebVR: add angular velocity estimate to pose

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 17 matching lines @@
 #include "ui/gl/android/scoped_java_surface.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/init/gl_factory.h"
 
 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;
 
 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;
@@ skipping 748 matching lines @@
   // used in the WebVR app for drawing this frame and supply it when
   // submitting. Technically we don't need a pose if not reprojecting,
   // but keeping it uninitialized seems likely to cause problems down
   // the road. Copying it is cheaper than fetching a new one.
   if (ShouldDrawWebVr()) {
     static_assert(!((kPoseRingBufferSize - 1) & kPoseRingBufferSize),
                   "kPoseRingBufferSize must be a power of 2");
     head_pose = webvr_head_pose_[frame_index % kPoseRingBufferSize];
   } else {
     gvr::ClockTimePoint target_time = gvr::GvrApi::GetTimePointNow();
-    target_time.monotonic_system_time_nanos += kPredictionTimeWithoutVsyncNanos;
+    target_time.monotonic_system_time_nanos +=
+        VrShell::kPredictionTimeWithoutVsyncNanos;
     head_pose = gvr_api_->GetHeadSpaceFromStartSpaceRotation(target_time);
   }
 
   gvr::Vec3f position = GetTranslation(head_pose);
   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.
@@ skipping 436 matching lines @@
   scene_->HandleCommands(std::move(commands), TimeInMicroseconds());
 }
 
 void VrShellGl::SendVSync(base::TimeDelta time,
                           const GetVSyncCallback& callback) {
   uint8_t frame_index = frame_index_++;
 
   TRACE_EVENT1("input", "VrShellGl::SendVSync", "frame", frame_index);
 
   gvr::ClockTimePoint target_time = gvr::GvrApi::GetTimePointNow();
-  target_time.monotonic_system_time_nanos += kPredictionTimeWithoutVsyncNanos;
+  target_time.monotonic_system_time_nanos +=
+      VrShell::kPredictionTimeWithoutVsyncNanos;

[mthiesse, 2017/04/05 18:43:18]

Instead of moving this constant to the header, and using it in 4 different
spots, can we add a static function that gets the predicted head pose with neck
model?

(Will be easier after my refactor in the cq lands
(https://codereview.chromium.org/2787873002/))

[mthiesse, 2017/04/05 18:57:00]

Actually, don't worry about this for your CL. I'll do some refactoring in a
followup.

[klausw, 2017/04/05 22:38:22]

Done, now there's just one place that applies the neck model.

 
   gvr::Mat4f head_mat =
       gvr_api_->GetHeadSpaceFromStartSpaceRotation(target_time);
   head_mat = gvr_api_->ApplyNeckModel(head_mat, 1.0f);
 
+  target_time.monotonic_system_time_nanos +=
+      VrShell::kAngularVelocityEpsilonNanos;
+  gvr::Mat4f head_mat_2 =
+      gvr_api_->GetHeadSpaceFromStartSpaceRotation(target_time);
+
   webvr_head_pose_[frame_index % kPoseRingBufferSize] = head_mat;
 
-  callback.Run(VrShell::VRPosePtrFromGvrPose(head_mat), time, frame_index,
+  callback.Run(VrShell::VRPosePtrFromGvrPose(
+                   head_mat, head_mat_2, VrShell::kAngularVelocityEpsilonNanos),
+               time, frame_index,
                device::mojom::VRVSyncProvider::Status::SUCCESS);
 }
 
 void VrShellGl::ResetPose() {
   // Should never call RecenterTracking when using with Daydream viewers. On
   // those devices recentering should only be done via the controller.
   if (gvr_api_ && gvr_api_->GetViewerType() == GVR_VIEWER_TYPE_CARDBOARD)
     gvr_api_->RecenterTracking();
 }
 
 void VrShellGl::CreateVRDisplayInfo(
     const base::Callback<void(device::mojom::VRDisplayInfoPtr)>& callback,
     uint32_t device_id) {
   // This assumes that the initial webvr_surface_size_ was set to the
   // appropriate recommended render resolution as the default size during
   // InitializeGl. Revisit if the initialization order changes.
   device::mojom::VRDisplayInfoPtr info = VrShell::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