Rendering Daydream controller in a fixed position.

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 38 matching lines @@
 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 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};
+static constexpr gvr::Vec3f kControllerPosition = {0.2f, -0.5f, -0.15f};
 
 // 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;
@@ skipping 859 matching lines @@
                pixel_rect.top - pixel_rect.bottom);
 
     const gvr::Mat4f render_matrix =
         MatrixMul(PerspectiveMatrixFromView(buffer_viewport_->GetSourceFov(),
                                             kZNear, kZFar),
                   eye_view_matrix);
 
     DrawElements(render_matrix, elementsInDrawOrder);
     if (draw_cursor) {
       DrawCursor(render_matrix);
+      DrawController(render_matrix);
     }
   }
 }
 
 void VrShellGl::DrawElements(
     const gvr::Mat4f& view_proj_matrix,
     const std::vector<const ContentRectangle*>& elements) {
   for (const auto* rect : elements) {
     gvr::Mat4f transform = MatrixMul(view_proj_matrix, rect->TransformMatrix());
 
@@ skipping 140 matching lines @@
 
     // 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 VrShellGl::DrawController(const gvr::Mat4f& view_proj_matrix) {

[asimjour1, 2017/03/29 20:40:44]

I think this method also doesn't belong here. it should be inside VrController

+  if (!vr_shell_renderer_->GetControllerRenderer()->IsSetUp())
+    return;
+  // TODO(acondor): Placing the controller in a fixed position before

[amp, 2017/03/29 20:54:56]

Format the TODO's as what needs to be done next, not what the current state is
(but having another comment after the TODO explaining the current state can be
useful to).

[acondor_, 2017/03/29 22:46:44]

Done.

+  // implementing the elbow model.
+  gvr::Mat4f mat;
+  SetIdentityM(mat);
+  // Changing rotation point.
+  TranslateM(mat, mat, 0, 0, 0.05);

[cjgrant, 2017/03/29 20:22:38]

Normally you'd want a constant for 0.05, but assuming the elbow model CL
addresses this, it's cool.

[acondor_, 2017/03/29 22:46:45]

Acknowledged.

+  mat = MatrixMul(QuatToMatrix(controller_->Orientation()), mat);
+  TranslateM(mat, mat, kControllerPosition.x, kControllerPosition.y,
+             kControllerPosition.z - 0.05);
+
+  auto transform = MatrixMul(view_proj_matrix, mat);
+
+  VrControllerModel::State state = VrControllerModel::IDLE;
+  if (controller_->ButtonState(
+          gvr::ControllerButton::GVR_CONTROLLER_BUTTON_CLICK))
+    state = VrControllerModel::TOUCHPAD;
+  else if (controller_->ButtonState(
+               gvr::ControllerButton::GVR_CONTROLLER_BUTTON_APP))
+    state = VrControllerModel::APP;
+  else if (controller_->ButtonState(
+               gvr::ControllerButton::GVR_CONTROLLER_BUTTON_HOME))
+    state = VrControllerModel::SYSTEM;
+
+  vr_shell_renderer_->GetControllerRenderer()->Draw(state, 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);
   glDepthMask(GL_FALSE);
   glDisable(GL_DEPTH_TEST);
@@ skipping 74 matching lines @@
   if (ui_surface_texture_.get())
     ui_surface_texture_->SetDefaultBufferSize(width, height);
   ui_tex_physical_size_.width = width;
   ui_tex_physical_size_.height = height;
 }
 
 base::WeakPtr<VrShellGl> VrShellGl::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
+void VrShellGl::SetControllerModel(std::unique_ptr<VrControllerModel> model) {
+  vr_shell_renderer_->GetControllerRenderer()->SetUp(std::move(model));
+}
+
 void VrShellGl::OnVSync() {
   while (premature_received_frames_ > 0) {
     TRACE_EVENT0("gpu", "VrShellGl::OnWebVRFrameAvailableRetry");
     --premature_received_frames_;
     OnWebVRFrameAvailable();
   }
 
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeTicks target;
 
@@ skipping 89 matching lines @@
   // 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