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) {
+  if (!controller_model_)
+    return;
+  gvr::Mat4f mat;
+  SetIdentityM(mat);
+  // TODO(acondor): Placing controller in temporary position before

[cjgrant, 2017/03/29 13:20:54]

Maybe I'm missing something, but in addition to putting the controller where the
hand is, why not rotate the matrix according to the controller orientation as
well?

[acondor_, 2017/03/29 20:13:26]

Done. It will be changed to the elbow model soon, though.

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

Thanks.  From a live demo, this looks really good now.

+  // implementing the elbow model.
+  TranslateM(mat, mat, kControllerPosition.x, kControllerPosition.y,
+             kControllerPosition.z);
+
+  auto transform = MatrixMul(view_proj_matrix, mat);
+
+  VrControllerModel::State state = VrControllerModel::IDLE;

[cjgrant, 2017/03/29 13:20:54]

- Volume buttons?
- Can multiple buttons be pressed simultaneously?

[acondor_, 2017/03/29 20:13:26]

I'm not sure if they can, but the textures provided don't account for that. Here
I'm going in order of preference. The volume buttons are not even present in the
mesh and/or texture.

+  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(*controller_model_, 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) {
+  controller_model_ = std::move(model);
+  vr_shell_renderer_->GetControllerRenderer()->SetUp(*controller_model_);
+  controller_model_->Free();

[cjgrant, 2017/03/29 13:20:54]

Michael already commented on this Free() approach.  It doesn't look healthy to
me either.

[acondor_, 2017/03/29 20:13:26]

The new approach is that the renderer gathers all the information it needs
during setup and then the object is automatically deleted.

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