Implementation of elbow model for the controller position and rotation.

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 <chrono>
 #include <limits>
 #include <utility>
 
@@ skipping 29 matching lines @@
 
 namespace {
 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;
-
 static constexpr gfx::Point3F 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 gfx::Point3F 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;
 
 // GVR buffer indices for use with viewport->SetSourceBufferIndex
 // or frame.BindBuffer. We use one for world content (with reprojection)
 // including main VrShell and WebVR content plus world-space UI.
 // The headlocked buffer is for UI that should not use reprojection.
 static constexpr int kFramePrimaryBuffer = 0;
 static constexpr int kFrameHeadlockedBuffer = 1;
@@ skipping 438 matching lines @@
   webvr_right_viewport_.reset(
       new gvr::BufferViewport(gvr_api_->CreateBufferViewport()));
   buffer_viewport_list_->GetBufferViewport(GVR_RIGHT_EYE,
                                            webvr_right_viewport_.get());
   webvr_right_viewport_->SetSourceBufferIndex(kFramePrimaryBuffer);
 
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VrShell::GvrDelegateReady, weak_vr_shell_));
 }
 
-void VrShellGl::UpdateController() {
-  controller_->UpdateState();
+void VrShellGl::UpdateController(const gfx::Vector3dF& head_direction) {
+  controller_->UpdateState(head_direction);
+  pointer_start_ = controller_->GetPointerStart();
 
   device::GvrGamepadData pad = controller_->GetGamepadData();
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VrShell::UpdateGamepadData, weak_vr_shell_, pad));
 }
 
-void VrShellGl::HandleControllerInput(const gfx::Vector3dF& forward_vector) {
+void VrShellGl::HandleControllerInput(const gfx::Vector3dF& head_direction) {
   if (ShouldDrawWebVr()) {
     // Process screen touch events for Cardboard button compatibility.
     // Also send tap events for controller "touchpad click" events.
     if (touch_pending_ ||
         controller_->ButtonUpHappened(
             gvr::ControllerButton::GVR_CONTROLLER_BUTTON_CLICK)) {
       touch_pending_ = false;
       std::unique_ptr<WebGestureEvent> gesture(new WebGestureEvent(
           WebInputEvent::kGestureTapDown, WebInputEvent::kNoModifiers,
           (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF()));
       gesture->source_device = blink::kWebGestureDeviceTouchpad;
       gesture->x = 0;
       gesture->y = 0;
       SendGesture(InputTarget::CONTENT, std::move(gesture));
       DVLOG(1) << __FUNCTION__ << ": sent CLICK gesture";
     }
   }
 
   gfx::Vector3dF 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);
+    controller_quat_ = GetRotationFromZAxis(head_direction);
   } else {
     ergo_neutral_pose = {0.0f, -sin(kErgoAngleOffset), -cos(kErgoAngleOffset)};
     controller_quat_ = controller_->Orientation();
   }
 
   vr::Mat4f mat;
   QuatToMatrix(controller_quat_, &mat);
   gfx::Vector3dF controller_direction =
       vr::MatrixVectorMul(mat, ergo_neutral_pose);
 
@@ skipping 12 matching lines @@
   // - Create a vector between the eyes and the outer surface point.
   // - If any UI elements intersect this vector, and is within the bounding
   //   sphere, choose the closest to the eyes, and place the reticle at the
   //   intersection point.
 
   // Compute the distance from the eyes to the distance limiting sphere. Note
   // that the sphere is centered at the controller, rather than the eye, for
   // simplicity.
   float distance = scene_->GetBackgroundDistance();
   target_point_ =
-      vr::GetRayPoint(kHandPosition, controller_direction, distance);
+      vr::GetRayPoint(pointer_start_, controller_direction, distance);
   gfx::Vector3dF eye_to_target = target_point_ - kOrigin;
   vr::NormalizeVector(&eye_to_target);
 
   // Determine which UI element (if any) intersects the line between the eyes
   // and the controller target position.
   float closest_element_distance = (target_point_ - kOrigin).Length();
   target_element_ = nullptr;
   float target_x;
   float target_y;
 
@@ skipping 266 matching lines @@
     device::GvrDelegate::GetGvrPoseWithNeckModel(gvr_api_.get(), &head_pose);
   }
 
   // Update the render position of all UI elements (including desktop).
   scene_->UpdateTransforms(current_time);
 
   {
     // TODO(crbug.com/704690): Acquire controller state in a way that's timely
     // for both the gamepad API and UI input handling.
     TRACE_EVENT0("gpu", "VrShellGl::UpdateController");
-    UpdateController();
-    HandleControllerInput(vr::GetForwardVector(head_pose));
+    auto head_direction = vr::GetForwardVector(head_pose);
+    UpdateController(head_direction);
+    HandleControllerInput(head_direction);
   }
 
   DrawWorldElements(head_pose);
 
   frame.Unbind();
 
   // Draw head-locked elements to a separate, non-reprojected buffer.
   if (scene_->HasVisibleHeadLockedElements()) {
     frame.BindBuffer(kFrameHeadlockedBuffer);
     DrawHeadLockedElements();
@@ skipping 95 matching lines @@
     vr::Mat4f render_matrix;
     vr::Mat4f perspective_matrix;
     GvrMatToMatf(PerspectiveMatrixFromView(buffer_viewport_->GetSourceFov(),
                                            kZNear, kZFar),
                  &perspective_matrix);
 
     vr::MatrixMul(perspective_matrix, eye_view_matrix, &render_matrix);
 
     DrawElements(render_matrix, elementsInDrawOrder);
     if (draw_cursor) {
+      DrawController(render_matrix);
       DrawCursor(render_matrix);
-      DrawController(render_matrix);
     }
   }
 }
 
 void VrShellGl::DrawElements(const vr::Mat4f& view_proj_matrix,
                              const std::vector<const UiElement*>& elements) {
   for (const auto* rect : elements) {
     vr::Mat4f transform;
     vr::MatrixMul(view_proj_matrix, rect->TransformMatrix(), &transform);
 
@@ skipping 95 matching lines @@
   vr::TranslateM(mat, target_point - kOrigin, &mat);
 
   vr::Mat4f transform;
   vr::MatrixMul(render_matrix, mat, &transform);
   vr_shell_renderer_->GetReticleRenderer()->Draw(transform);
 
   // Draw the laser.
 
   // Find the length of the beam (from hand to target).
   const float laser_length =
-      std::sqrt(kHandPosition.SquaredDistanceTo(target_point));
+      std::sqrt(pointer_start_.SquaredDistanceTo(target_point));
 
   // Build a beam, originating from the origin.
   vr::SetIdentityM(&mat);
 
   // Move the beam half its height so that its end sits on the origin.
   vr::TranslateM(mat, {0.0f, 0.5f, 0.0f}, &mat);
   vr::ScaleM(mat, {kLaserWidth, laser_length, 1}, &mat);
 
   // Tip back 90 degrees to flat, pointing at the scene.
   const vr::Quatf quat = vr::QuatFromAxisAngle({1.0f, 0.0f, 0.0f, -M_PI / 2});
   vr::QuatToMatrix(quat, &rotation_mat);
   vr::MatrixMul(rotation_mat, mat, &mat);
 
-  const gfx::Vector3dF beam_direction = target_point_ - kHandPosition;
+  const gfx::Vector3dF beam_direction = target_point_ - pointer_start_;
 
   vr::Mat4f beam_direction_mat;
   vr::QuatToMatrix(GetRotationFromZAxis(beam_direction), &beam_direction_mat);
 
+  float opacity = controller_->GetOpacity();
   // 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 vr::Quatf rot = vr::QuatFromAxisAngle({0.0f, 0.0f, 1.0f, angle});
     vr::Mat4f face_transform;
     vr::QuatToMatrix(rot, &face_transform);
     vr::MatrixMul(face_transform, mat, &face_transform);
     // Orient according to target direction.
     vr::MatrixMul(beam_direction_mat, face_transform, &face_transform);
 
     // Move the beam origin to the hand.
-    vr::TranslateM(face_transform, kHandPosition - kOrigin, &face_transform);
+    vr::TranslateM(face_transform, pointer_start_ - kOrigin, &face_transform);
 
     vr::MatrixMul(render_matrix, face_transform, &transform);
-    vr_shell_renderer_->GetLaserRenderer()->Draw(transform);
+    vr_shell_renderer_->GetLaserRenderer()->Draw(opacity, transform);
   }
 }
 
 void VrShellGl::DrawController(const vr::Mat4f& view_proj_matrix) {
   if (!vr_shell_renderer_->GetControllerRenderer()->IsSetUp())
     return;
+  auto state = controller_->GetModelState();
+  auto opacity = controller_->GetOpacity();
   vr::Mat4f controller_transform;
   controller_->GetTransform(&controller_transform);
   vr::Mat4f transform;
   vr::MatrixMul(view_proj_matrix, controller_transform, &transform);
-  auto state = controller_->GetModelState();
-  vr_shell_renderer_->GetControllerRenderer()->Draw(state, transform);
+  vr_shell_renderer_->GetControllerRenderer()->Draw(state, opacity, transform);
 }
 
 bool VrShellGl::ShouldDrawWebVr() {
   return web_vr_mode_ && scene_->GetWebVrRenderingEnabled();
 }
 
 void VrShellGl::DrawWebVr() {
   TRACE_EVENT0("gpu", "VrShellGl::DrawWebVr");
   // Don't need face culling, depth testing, blending, etc. Turn it all off.
   glDisable(GL_CULL_FACE);
@@ skipping 164 matching lines @@
   // InitializeGl. Revisit if the initialization order changes.
   device::mojom::VRDisplayInfoPtr info =
       device::GvrDelegate::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