Incorporate 15 degree laser beam angle on pointer.

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 "chrome/browser/android/vr_shell/ui_scene.h"
 #include "chrome/browser/android/vr_shell/vr_compositor.h"
 #include "chrome/browser/android/vr_shell/vr_controller.h"
 #include "chrome/browser/android/vr_shell/vr_gl_util.h"
@@ skipping 31 matching lines @@
 static constexpr float kDesktopScreenTiltDefault = 0;
 
 static constexpr float kScreenHeightRatio = 1.0f;
 static constexpr float kScreenWidthRatio = 16.0f / 9.0f;
 
 static constexpr float kReticleWidth = 0.025f;
 static constexpr float kReticleHeight = 0.025f;
 
 static constexpr float kLaserWidth = 0.01f;
 
-// The neutral direction is fixed in world space, this is the
-// reference angle pointing forward towards the horizon when the
-// controller orientation is reset. This should match the yaw angle
-// where the main screen is placed.
-static constexpr gvr::Vec3f kNeutralPose = {0.0f, 0.0f, -1.0f};
+// Angle (radians) the beam down from the controller axis, for wrist comfort.
+static constexpr float kErgoAngleOffset = 0.26f;
 
 static constexpr gvr::Vec3f kOrigin = {0.0f, 0.0f, 0.0f};
 
 // In lieu of an elbow model, we assume a position for the user's hand.
 // TODO(mthiesse): Handedness options.
 static constexpr gvr::Vec3f kHandPosition = {0.2f, -0.5f, -0.2f};
 
 // Fraction of the distance to the object the cursor is drawn at to avoid
 // rounding errors drawing the cursor behind the object.
 static constexpr float kReticleOffset = 0.99f;
@@ skipping 165 matching lines @@
   std::unique_ptr<VrGesture> gesture = controller_->DetectGesture();
 
   // TODO(asimjour) for now, scroll is sent to the main content.
   if (gesture->type == WebInputEvent::GestureScrollBegin ||
       gesture->type == WebInputEvent::GestureScrollUpdate ||
       gesture->type == WebInputEvent::GestureScrollEnd) {
     content_input_manager_->ProcessUpdatedGesture(*gesture.get());
   }
 
   WebInputEvent::Type original_type = gesture->type;
+  gvr::Vec3f ergo_neutral_pose;
   if (!controller_->IsConnected()) {
     // No controller detected, set up a gaze cursor that tracks the
     // forward direction.
+    ergo_neutral_pose = {0.0f, 0.0f, -1.0f};
     controller_quat_ = GetRotationFromZAxis(forward_vector);
   } else {
+    ergo_neutral_pose = {0.0f, -sin(kErgoAngleOffset), -cos(kErgoAngleOffset)};
     controller_quat_ = controller_->Orientation();
   }
 
   gvr::Mat4f mat = QuatToMatrix(controller_quat_);
-  gvr::Vec3f forward = MatrixVectorMul(mat, kNeutralPose);
+  gvr::Vec3f forward = MatrixVectorMul(mat, ergo_neutral_pose);
   gvr::Vec3f origin = kHandPosition;
 
   target_element_ = nullptr;
   float distance = scene_.GetUiElementById(kBrowserUiElementId)
       ->GetRayDistance(origin, forward);
 
   // If we place the reticle based on elements intersecting the controller beam,
   // we can end up with the reticle hiding behind elements, or jumping laterally
   // in the field of view. This is physically correct, but hard to use. For
   // usability, do the following instead:
@@ skipping 240 matching lines @@
   TranslateM(mat, mat, target_point_.x * kReticleOffset,
              target_point_.y * kReticleOffset,
              target_point_.z * kReticleOffset);
 
   gvr::Mat4f transform = MatrixMul(render_matrix, mat);
   vr_shell_renderer_->GetReticleRenderer()->Draw(transform);
 
   // Draw the laser.
 
   // Find the length of the beam (from hand to target).
-  float laser_length = Distance(kHandPosition, target_point_);
+  const float laser_length = Distance(kHandPosition, target_point_);
 
   // Build a beam, originating from the origin.
   SetIdentityM(mat);
 
   // Move the beam half its height so that its end sits on the origin.
   TranslateM(mat, mat, 0.0f, 0.5f, 0.0f);
   ScaleM(mat, mat, kLaserWidth, laser_length, 1);
 
   // Tip back 90 degrees to flat, pointing at the scene.
-  auto q = QuatFromAxisAngle({1.0f, 0.0f, 0.0f}, -M_PI / 2);
-  auto m = QuatToMatrix(q);
-  mat = MatrixMul(m, mat);
+  const gvr::Quatf q = QuatFromAxisAngle({1.0f, 0.0f, 0.0f}, -M_PI / 2);
+  mat = MatrixMul(QuatToMatrix(q), mat);
 
-  // Orient according to controller position.
-  mat = MatrixMul(QuatToMatrix(controller_quat_), mat);
+  const gvr::Vec3f beam_direction = {
+    target_point_.x - kHandPosition.x,
+    target_point_.y - kHandPosition.y,
+    target_point_.z - kHandPosition.z
+  };
+  const gvr::Mat4f beam_direction_mat =

[cjgrant, 2016/10/06 15:07:51]

I was recomputing the matrix in the loop (needless).

+      QuatToMatrix(GetRotationFromZAxis(beam_direction));
 
-  // Move the beam origin to the hand.
-  TranslateM(mat, mat, kHandPosition.x, kHandPosition.y, kHandPosition.z);
 
-  transform = MatrixMul(render_matrix, mat);
-  vr_shell_renderer_->GetLaserRenderer()->Draw(transform);
+  // Render multiple faces to make the laser appear cylindrical.
+  const int faces = 4;
+  for (int i = 0; i < faces; i++) {
+    // Rotate around Z.
+    const float angle = M_PI * 2 * i / faces;
+    const gvr::Quatf rot = QuatFromAxisAngle({0.0f, 0.0f, 1.0f}, angle);
+    gvr::Mat4f face_transform = MatrixMul(QuatToMatrix(rot), mat);
+
+    // Orient according to target direction.
+    face_transform = MatrixMul(beam_direction_mat, face_transform);
+
+    // Move the beam origin to the hand.
+    TranslateM(face_transform, face_transform, kHandPosition.x, kHandPosition.y,
+               kHandPosition.z);
+
+    transform = MatrixMul(render_matrix, face_transform);
+    vr_shell_renderer_->GetLaserRenderer()->Draw(transform);
+  }
 }
 
 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);
@@ skipping 248 matching lines @@
       content::WebContents::FromJavaWebContents(content_web_contents));
   content::ContentViewCore* ui_core = content::ContentViewCore::FromWebContents(
       content::WebContents::FromJavaWebContents(ui_web_contents));
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, c_core,
       reinterpret_cast<ui::WindowAndroid*>(content_window_android), ui_core,
       reinterpret_cast<ui::WindowAndroid*>(ui_window_android)));
 }
 
 }  // namespace vr_shell