Implementation of elbow model for the controller position and rotation.

chrome/browser/android/vr_shell/vr_controller.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_controller.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "chrome/browser/android/vr_shell/vr_math.h"
 #include "third_party/gvr-android-sdk/src/libraries/headers/vr/gvr/capi/include/gvr.h"
 #include "third_party/gvr-android-sdk/src/libraries/headers/vr/gvr/capi/include/gvr_controller.h"
 
 namespace vr_shell {
 
 namespace {
 
 constexpr float kDisplacementScaleFactor = 300.0f;
@@ skipping 12 matching lines @@
 // not equal. Also, minimum time distance needed to call two timestamps
 // not equal.
 constexpr float kDelta = 1.0e-7f;
 
 constexpr float kCutoffHz = 10.0f;
 constexpr float kRC = static_cast<float>(1.0 / (2.0 * M_PI * kCutoffHz));
 constexpr float kNanoSecondsPerSecond = 1.0e9f;
 
 constexpr int kMaxNumOfExtrapolations = 2;
 
-static constexpr gvr::Vec3f kControllerPosition = {0.2f, -0.5f, -0.15f};
-
 class Vector {
  public:
   static inline void ClampTouchpadPosition(gvr::Vec2f* position) {
     position->x = std::min(std::max(0.0f, position->x), 1.0f);
     position->y = std::min(std::max(0.0f, position->y), 1.0f);
   }
 
   static inline void SetZero(gvr::Vec2f* v) {
     v->x = 0;
     v->y = 0;
@@ skipping 24 matching lines @@
     return vect_prod;
   }
 
 };  // Vector
 
 }  // namespace
 
 VrController::VrController(gvr_context* vr_context) {
   DVLOG(1) << __FUNCTION__ << "=" << this;
   Initialize(vr_context);
+  elbow_model_ = base::MakeUnique<ElbowModel>(handedness_);
   Reset();
+  last_timestamp_nanos_ =
+      gvr::GvrApi::GetTimePointNow().monotonic_system_time_nanos;
 }
 
 VrController::~VrController() {
   DVLOG(1) << __FUNCTION__ << "=" << this;
 }
 
 void VrController::OnResume() {
   if (controller_api_)
     controller_api_->Resume();
 }
@@ skipping 29 matching lines @@
 
 float VrController::TouchPosY() {
   return controller_state_->GetTouchPos().y;
 }
 
 gvr::Quatf VrController::Orientation() const {
   return controller_state_->GetOrientation();
 }
 
 gvr::Mat4f VrController::GetTransform() const {
-  // TODO(acondor): Position and orientation needs to be obtained
-  // from an elbow model.
-  // Placing the controller in a fixed position for now.
-  gvr::Mat4f mat;
-  SetIdentityM(mat);
-  // Changing rotation point.
-  TranslateM(mat, mat, 0, 0, 0.05);
-  mat = MatrixMul(QuatToMatrix(Orientation()), mat);
-  TranslateM(mat, mat, kControllerPosition.x, kControllerPosition.y,
-             kControllerPosition.z - 0.05);
+  auto mat = QuatToMatrix(elbow_model_->GetControllerRotation());
+  auto position = elbow_model_->GetControllerPosition();
+  TranslateM(mat, mat, position.x, position.y, position.z);
   return mat;
 }
 
+float VrController::GetOpacity() const {
+  return elbow_model_->GetAlphaValue();
+}
+
+gvr::Vec3f VrController::GetPointerStart() const {
+  return elbow_model_->GetControllerPosition();
+}
+
 VrControllerModel::State VrController::GetModelState() const {
   if (ButtonState(gvr::ControllerButton::GVR_CONTROLLER_BUTTON_CLICK))
     return VrControllerModel::TOUCHPAD;
   if (ButtonState(gvr::ControllerButton::GVR_CONTROLLER_BUTTON_APP))
     return VrControllerModel::APP;
   if (ButtonState(gvr::ControllerButton::GVR_CONTROLLER_BUTTON_HOME))
     return VrControllerModel::SYSTEM;
   return VrControllerModel::IDLE;
 }
 
@@ skipping 14 matching lines @@
 }
 
 bool VrController::ButtonState(gvr::ControllerButton button) const {
   return controller_state_->GetButtonState(button);
 }
 
 bool VrController::IsConnected() {
   return controller_state_->GetConnectionState() == gvr::kControllerConnected;
 }
 
-void VrController::UpdateState() {
+void VrController::UpdateState(const gvr::Vec3f& head_direction) {
   const int32_t old_status = controller_state_->GetApiStatus();
   const int32_t old_connection_state = controller_state_->GetConnectionState();
   // Read current controller state.
   controller_state_->Update(*controller_api_);
   // Print new API status and connection state, if they changed.
   if (controller_state_->GetApiStatus() != old_status ||
       controller_state_->GetConnectionState() != old_connection_state) {
     VLOG(1) << "Controller Connection status: "
             << gvr_controller_connection_state_to_string(
                    controller_state_->GetConnectionState());
   }
+
+  float delta_time_seconds =

[asimjour1, 2017/04/19 18:58:12]

this conversion is repeated a few times, could you please use a function for
this.

[acondor_, 2017/04/21 21:04:32]

Done.

+      (gvr::GvrApi::GetTimePointNow().monotonic_system_time_nanos -
+       last_timestamp_nanos_) /
+      kNanoSecondsPerSecond;
+  elbow_model_->Update({IsConnected(), Orientation(),
+                        controller_state_->GetGyro(), head_direction,
+                        delta_time_seconds});
 }
 
 void VrController::UpdateTouchInfo() {
   CHECK(touch_info_ != nullptr) << "touch_info_ not initialized properly.";
   if (IsTouching() && state_ == SCROLLING &&
       (controller_state_->GetLastTouchTimestamp() == last_touch_timestamp_ ||
        (Vector::Equal(cur_touch_point_->position,
                       prev_touch_point_->position) &&
         extrapolated_touch_ < kMaxNumOfExtrapolations))) {
     extrapolated_touch_++;
@@ skipping 246 matching lines @@
   gvr::Vec2f velocity = Vector::ScalarMult(displacement, 1 / duration);
 
   float weight = duration / (kRC + duration);
 
   overall_velocity_ =
       Vector::Add(Vector::ScalarMult(overall_velocity_, 1 - weight),
                   Vector::ScalarMult(velocity, weight));
 }
 
 }  // namespace vr_shell