VR: Improve scrolling

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 <cmath>
 
 #include "base/logging.h"
 #include "base/time/time.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;
 
 // A slop represents a small rectangular region around the first touch point of
 // a gesture.
 // If the user does not move outside of the slop, no gesture is detected.
 // Gestures start to be detected when the user moves outside of the slop.
 // Vertical distance from the border to the center of slop.
 constexpr float kSlopVertical = 0.165f;
 
 // Horizontal distance from the border to the center of slop.
-constexpr float kSlopHorizontal = 0.125f;
+constexpr float kSlopHorizontal = 0.15f;
 
 // Minimum distance needed in at least one direction to call two vectors
 // 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;
+
 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 90 matching lines @@
   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());
   }
 }
 
 void VrController::UpdateTouchInfo() {
   CHECK(touch_info_ != nullptr) << "touch_info_ not initialized properly.";
-  gvr::Vec2f position;
-  position.x = TouchPosX();
-  position.y = TouchPosY();
+  touch_point_->position.x = TouchPosX();
+  touch_point_->position.y = TouchPosY();
   touch_info_->touch_up = TouchUpHappened();
   touch_info_->touch_down = TouchDownHappened();
   touch_info_->is_touching = IsTouching();
-  touch_info_->touch_point.position = position;
+  touch_info_->touch_point.position = touch_point_->position;
   Vector::ClampTouchpadPosition(&touch_info_->touch_point.position);
   touch_info_->touch_point.timestamp =
       gvr::GvrApi::GetTimePointNow().monotonic_system_time_nanos;
-  if (controller_state_->GetLastTouchTimestamp() == last_touch_timestamp_) {
+  touch_point_->timestamp = touch_info_->touch_point.timestamp;
+
+  if (IsTouching() && state_ == SCROLLING &&
+      (controller_state_->GetLastTouchTimestamp() == last_touch_timestamp_ ||
+       (touch_point_->position.x == cur_touch_point_->position.x &&
+        touch_point_->position.y == cur_touch_point_->position.y &&

[bshe, 2017/01/09 19:38:54]

Vector::Equal(touch_point_->position, cur_touch_point_->position)?
Also, should this compared with pre_touch_point_ since cur_touch_point_ hasn't
updated for this frame IIUC?

[asimjour1, 2017/01/11 21:59:45]

Used Vector::Equal

touch_point_ is the point that VrController just received from the controller.
The extrapolation and fixing the touch_point_ happens before cur_touch_point_
and pre_touch_point_ get new values for this cycle. As a result, the comparing
the cur_touch_point_ and touch_point_ is correct.

+        extrapolated_touch_ < kMaxNumOfExtrapolations))) {
+    extrapolated_touch_++;
     // Fill the touch_info
     float duration =
         (gvr::GvrApi::GetTimePointNow().monotonic_system_time_nanos -
          last_timestamp_nanos_) /
         kNanoSecondsPerSecond;
 
-    position.x += overall_velocity_.x * duration;
-    position.y += overall_velocity_.y * duration;
-    touch_info_->touch_point.position.x = position.x;
-    touch_info_->touch_point.position.y = position.y;
+    touch_info_->touch_point.position.x =
+        touch_point_->position.x + overall_velocity_.x * duration;
+    touch_info_->touch_point.position.y =
+        touch_point_->position.y + overall_velocity_.y * duration;
+  } else {
+    if (extrapolated_touch_ == kMaxNumOfExtrapolations) {
+      Vector::SetZero(&overall_velocity_);
+    }
+    extrapolated_touch_ = 0;
   }
   last_touch_timestamp_ = controller_state_->GetLastTouchTimestamp();
   last_timestamp_nanos_ =
       gvr::GvrApi::GetTimePointNow().monotonic_system_time_nanos;
+  touch_position_changed_ = UpdateCurrentTouchpoint();
 }
 
 void VrController::Initialize(gvr_context* gvr_context) {
   CHECK(gvr_context != nullptr) << "invalid gvr_context";
   controller_api_.reset(new gvr::ControllerApi);
   controller_state_.reset(new gvr::ControllerState);
   int32_t options = gvr::ControllerApi::DefaultOptions();
 
   // Enable non-default options, if you need them:
   // options |= GVR_CONTROLLER_ENABLE_GYRO;
   CHECK(controller_api_->Init(options, gvr_context));
   controller_api_->Resume();
 }
 
 std::vector<std::unique_ptr<WebGestureEvent>> VrController::DetectGestures() {
   std::vector<std::unique_ptr<WebGestureEvent>> gesture_list;
   std::unique_ptr<WebGestureEvent> gesture(new WebGestureEvent());
+  touch_point_.reset(new TouchPoint);
 
   if (controller_state_->GetConnectionState() != gvr::kControllerConnected) {
     gesture_list.push_back(std::move(gesture));
     return gesture_list;
   }
   UpdateTouchInfo();
   UpdateGestureFromTouchInfo(gesture.get());
 
   if (gesture->type == WebInputEvent::Undefined &&
       ButtonUpHappened(gvr::kControllerButtonClick)) {
     gesture->type = WebInputEvent::GestureTapDown;
     gesture->x = 0;
     gesture->y = 0;
   }
   gesture->sourceDevice = blink::WebGestureDeviceTouchpad;
   gesture_list.push_back(std::move(gesture));
 
   if (gesture_list.back()->type == WebInputEvent::GestureScrollEnd) {
-    if (!ButtonDownHappened(gvr::kControllerButtonClick)) {
+    if (!ButtonDownHappened(gvr::kControllerButtonClick) &&
+        (last_velocity_.x != 0.0 || last_velocity_.y != 0.0)) {
       std::unique_ptr<WebGestureEvent> fling(new WebGestureEvent());
       fling->timeStampSeconds = gesture_list.back()->timeStampSeconds;
       fling->sourceDevice = blink::WebGestureDeviceTouchpad;
       fling->type = WebInputEvent::GestureFlingStart;
       if (IsHorizontalGesture()) {
         fling->data.flingStart.velocityX =
-            overall_velocity_.x * kDisplacementScaleFactor;
+            last_velocity_.x * kDisplacementScaleFactor;
       } else {
         fling->data.flingStart.velocityY =
-            overall_velocity_.y * kDisplacementScaleFactor;
+            last_velocity_.y * kDisplacementScaleFactor;
       }
       gesture_list.push_back(std::move(fling));
     }
     Reset();
   }
 
   return gesture_list;
 }
 
 void VrController::UpdateGestureFromTouchInfo(WebGestureEvent* gesture) {
@@ skipping 35 matching lines @@
 
 void VrController::HandleDetectingState(WebGestureEvent* gesture) {
   // User lifts up finger from touch pad.
   if (touch_info_->touch_up || !(touch_info_->is_touching)) {
     Reset();
     return;
   }
 
   // Touch position is changed, the touch point moves outside of slop,
   // and the Controller's button is not down.
-  if (UpdateCurrentTouchpoint() && touch_info_->is_touching &&
+  if (touch_position_changed_ && touch_info_->is_touching &&
       !InSlop(touch_info_->touch_point.position) &&
       !ButtonDownHappened(gvr::kControllerButtonClick)) {
     state_ = SCROLLING;
     gesture->type = WebInputEvent::GestureScrollBegin;
     UpdateGesture(gesture);
     gesture->data.scrollBegin.deltaXHint =
         displacement_.x * kDisplacementScaleFactor;
     gesture->data.scrollBegin.deltaYHint =
         displacement_.y * kDisplacementScaleFactor;
   }
 }
 
 void VrController::HandleScrollingState(WebGestureEvent* gesture) {
   // Update current touch point.

[bshe, 2017/01/09 19:38:54]

nit: remove the above comment

[asimjour1, 2017/01/11 21:59:45]

Done.

-  bool touch_position_changed = UpdateCurrentTouchpoint();
   if (touch_info_->touch_up || !(touch_info_->is_touching) ||
       ButtonDownHappened(gvr::kControllerButtonClick)) {
     // Gesture ends.
     gesture->type = WebInputEvent::GestureScrollEnd;
     UpdateGesture(gesture);
-  } else if (touch_position_changed) {
+  } else if (touch_position_changed_) {
     // User continues scrolling and there is a change in touch position.
     gesture->type = WebInputEvent::GestureScrollUpdate;
     UpdateGesture(gesture);
     if (IsHorizontalGesture()) {
       gesture->data.scrollUpdate.deltaX =
           displacement_.x * kDisplacementScaleFactor;
     } else {
       gesture->data.scrollUpdate.deltaY =
           displacement_.y * kDisplacementScaleFactor;
     }
+    last_velocity_ = overall_velocity_;
   }
 }
 
 bool VrController::IsHorizontalGesture() {
-  return std::abs(overall_velocity_.x) > std::abs(overall_velocity_.y);
+  return std::abs(last_velocity_.x) > std::abs(last_velocity_.y);
 }
 
 bool VrController::InSlop(const gvr::Vec2f touch_position) {
   return (std::abs(touch_position.x - init_touch_point_->position.x) <
           kSlopHorizontal) &&
          (std::abs(touch_position.y - init_touch_point_->position.y) <
           kSlopVertical);
 }
 
 void VrController::Reset() {
   // Reset state.
   state_ = WAITING;
 
   // Reset the pointers.
   prev_touch_point_.reset(new TouchPoint);
   cur_touch_point_.reset(new TouchPoint);
   init_touch_point_.reset(new TouchPoint);
   touch_info_.reset(new TouchInfo);
   Vector::SetZero(&overall_velocity_);
+  Vector::SetZero(&last_velocity_);
 }
 
 void VrController::UpdateGesture(WebGestureEvent* gesture) {
   if (!gesture)
     LOG(ERROR) << "The gesture pointer is not initiated properly.";
-  displacement_ =
-      Vector::Subtract(cur_touch_point_->position, prev_touch_point_->position);
+  displacement_ = Vector::Subtract(touch_info_->touch_point.position,
+                                   prev_touch_point_->position);

[bshe, 2017/01/09 19:38:54]

IIUC, should prev_touch_point save previous extropolated value to match the old
behavior? Or it doesnt' matter?

[asimjour1, 2017/01/11 21:59:45]

It shouldn't be the previous extrapolated point. if we keep the extrapolated
points instead of the actual reported points then it won't be possible to detect
a steady finger. It means there will be a small fling at the end of the moves.
we can measure the displacement from the extrapolated points if we add two more
variables to also keep track of the actual points.

 }
 
 bool VrController::UpdateCurrentTouchpoint() {
   if (touch_info_->is_touching || touch_info_->touch_up) {
     // Update the touch point when the touch position has changed.
     if (!Vector::Equal(cur_touch_point_->position,
                        touch_info_->touch_point.position)) {
       prev_touch_point_.swap(cur_touch_point_);
-      *cur_touch_point_ = touch_info_->touch_point;
+      cur_touch_point_ = std::move(touch_point_);
       UpdateOverallVelocity();
       return true;
     }
   }
   return false;
 }
 
 void VrController::UpdateOverallVelocity() {
   float duration =
-      (cur_touch_point_->timestamp - prev_touch_point_->timestamp) /
+      (touch_info_->touch_point.timestamp - prev_touch_point_->timestamp) /
       kNanoSecondsPerSecond;
 
   // If the timestamp does not change, do not update velocity.
   if (duration < kDelta)
     return;
 
-  gvr::Vec2f displacement =
-      Vector::Subtract(cur_touch_point_->position, prev_touch_point_->position);
+  gvr::Vec2f displacement = Vector::Subtract(touch_info_->touch_point.position,
+                                             prev_touch_point_->position);
 
   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