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);
+  // Assume that epsilon is nonzero since it's a compile-time constant
+  // provided by the caller.
+  double epsilon_seconds = epsilon_nanos * 1e-9;
+  pose->angularVelocity.value()[0] =

[billorr, 2017/03/24 22:52:51]

can you explain the math here in a comment?  Looking at
https://en.wikipedia.org/wiki/Rotation_matrix#Determining_the_axis, the formula
you have isn't quite the same.

We are basically trying to find the axis of the rotation part of
(head_mat_2-head_mat), which is a rotation matrix (ignoring the translation
component).

[klausw, 2017/03/27 02:25:52]

I'm using
https://en.wikipedia.org/wiki/Angular_velocity#Calculation_from_the_orientati...
, I added a link to that in a comment.

My original calculation wasn't quite correct, it was missing a multiplication
with the inverse of the first matrix. I added that, in addition to an additional
rotation to transform it into seated space.

+      (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