WebVR: add angular velocity estimate to pose

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 <android/native_window_jni.h>
 
 #include <string>
 #include <utility>
@@ skipping 637 matching lines @@
   }
 }
 
 void VrShell::RegisterGamepadDataFetcher(
     device::GvrGamepadDataFetcher* fetcher) {
   DVLOG(1) << __FUNCTION__ << "(" << fetcher << ")";
   gamepad_data_fetcher_ = fetcher;
 }
 
 /* static */
-device::mojom::VRPosePtr VrShell::VRPosePtrFromGvrPose(gvr::Mat4f head_mat) {
+device::mojom::VRPosePtr VrShell::VRPosePtrFromGvrPose(gvr::Mat4f head_mat,
+                                                       gvr::Mat4f head_mat_2,
+                                                       int64_t epsilon_nanos) {
   device::mojom::VRPosePtr pose = device::mojom::VRPose::New();
 
   pose->orientation.emplace(4);
 
   gfx::Transform inv_transform(
       head_mat.m[0][0], head_mat.m[0][1], head_mat.m[0][2], head_mat.m[0][3],
       head_mat.m[1][0], head_mat.m[1][1], head_mat.m[1][2], head_mat.m[1][3],
       head_mat.m[2][0], head_mat.m[2][1], head_mat.m[2][2], head_mat.m[2][3],
       head_mat.m[3][0], head_mat.m[3][1], head_mat.m[3][2], head_mat.m[3][3]);
 
   gfx::Transform transform;
   if (inv_transform.GetInverse(&transform)) {
     gfx::DecomposedTransform decomposed_transform;
     gfx::DecomposeTransform(&decomposed_transform, transform);
 
     pose->orientation.value()[0] = decomposed_transform.quaternion[0];
     pose->orientation.value()[1] = decomposed_transform.quaternion[1];
     pose->orientation.value()[2] = decomposed_transform.quaternion[2];
     pose->orientation.value()[3] = decomposed_transform.quaternion[3];
 
     pose->position.emplace(3);
     pose->position.value()[0] = decomposed_transform.translate[0];
     pose->position.value()[1] = decomposed_transform.translate[1];
     pose->position.value()[2] = decomposed_transform.translate[2];
   }
 
+  // The angular velocity is a 3-element vector pointing along the
+  // rotation axis with magnitude equal to rotation speed in
+  // radians/second.
+  //
+  // The spec isn't very clear on details, clarification requested in
+  // https://github.com/w3c/webvr/issues/212 .
+  //
+  // Assume we're using right-hand rule for direction and a
+  // headset-attached frame of reference with +X to the right, +Y up,
+  // and +Z backwards (towards back of head).
+  //
+  // Examples:
+  // - "look up" motion: (positive, 0, 0)
+  // - "turn left" motion: (0, positive, 0)
+  // - "lean head left" motion: (0, 0, positive)
+  //
+  // Assuming that pose prediction is simply based on adding a time *
+  // angular velocity rotation to the pose, we can approximate the
+  // angular velocity from the difference between two successive
+  // poses. This is a first order estimate that assumes small enough
+  // rotations so that we can do linear approximation.
+  pose->angularVelocity.emplace(3);
+  double epsilon_seconds = epsilon_nanos * 1e-9;

[cjgrant, 2017/03/24 21:15:40]

Should protect against epsilon_nanos being 0 to avoid a possible div-by-zero if
input is bad (on startup, shutdown, corner case, etc).

[klausw, 2017/03/24 22:13:29]

That can't happen accidentally since it's a compile-time constant we pick.
Adding a comment to clarify.

+  pose->angularVelocity.value()[0] =
+      (head_mat_2.m[1][2] - head_mat.m[1][2]) / epsilon_seconds;
+  pose->angularVelocity.value()[1] =
+      -(head_mat_2.m[0][2] - head_mat.m[0][2]) / epsilon_seconds;
+  pose->angularVelocity.value()[2] =
+      (head_mat_2.m[0][1] - head_mat.m[0][1]) / epsilon_seconds;
+
   return pose;
 }
 
 /* static */
 gvr::Sizei VrShell::GetRecommendedWebVrSize(gvr::GvrApi* gvr_api) {
   // Pick a reasonable default size for the WebVR transfer surface
   // based on a downscaled 1:1 render resolution. This size will also
   // be reported to the client via CreateVRDisplayInfo as the
   // client-recommended renderWidth/renderHeight and for the GVR
   // framebuffer. If the client chooses a different size or resizes it
@@ skipping 84 matching lines @@
            jboolean reprojected_rendering) {
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, reinterpret_cast<ui::WindowAndroid*>(content_window_android),
       content::WebContents::FromJavaWebContents(ui_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(ui_window_android), for_web_vr,
       VrShellDelegate::GetNativeVrShellDelegate(env, delegate),
       reinterpret_cast<gvr_context*>(gvr_api), reprojected_rendering));
 }
 
 }  // namespace vr_shell