gamepad_pad_state_provider.cc 4.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152
  1. // Copyright 2016 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "device/gamepad/gamepad_pad_state_provider.h"
  5. #include <cmath>
  6. #include <memory>
  7. #include "device/gamepad/gamepad_data_fetcher.h"
  8. #include "device/gamepad/gamepad_provider.h"
  9. #include "device/gamepad/public/cpp/gamepads.h"
  10. namespace device {
  11. namespace {
  12. const float kMinAxisResetValue = 0.1f;
  13. } // namespace
  14. PadState::PadState() = default;
  15. PadState::~PadState() = default;
  16. GamepadPadStateProvider::GamepadPadStateProvider() {
  17. pad_states_ = std::make_unique<PadState[]>(Gamepads::kItemsLengthCap);
  18. for (size_t i = 0; i < Gamepads::kItemsLengthCap; ++i)
  19. ClearPadState(pad_states_.get()[i]);
  20. }
  21. GamepadPadStateProvider::~GamepadPadStateProvider() = default;
  22. PadState* GamepadPadStateProvider::GetPadState(GamepadSource source,
  23. int source_id,
  24. bool new_gamepad_recognized) {
  25. // Check to see if the device already has a reserved slot
  26. PadState* empty_slot = nullptr;
  27. PadState* unrecognized_slot = nullptr;
  28. for (size_t i = 0; i < Gamepads::kItemsLengthCap; ++i) {
  29. PadState& state = pad_states_.get()[i];
  30. if (state.source == source && state.source_id == source_id) {
  31. // Retrieving the pad state marks this gamepad as active.
  32. state.is_active = true;
  33. return &state;
  34. }
  35. if (!empty_slot && state.source == GAMEPAD_SOURCE_NONE)
  36. empty_slot = &state;
  37. if (!state.is_recognized)
  38. unrecognized_slot = &state;
  39. }
  40. if (!empty_slot && unrecognized_slot && new_gamepad_recognized) {
  41. DisconnectUnrecognizedGamepad(unrecognized_slot->source,
  42. unrecognized_slot->source_id);
  43. empty_slot = unrecognized_slot;
  44. }
  45. if (empty_slot) {
  46. empty_slot->source = source;
  47. empty_slot->source_id = source_id;
  48. empty_slot->is_active = true;
  49. empty_slot->is_newly_active = true;
  50. empty_slot->is_initialized = false;
  51. empty_slot->is_recognized = new_gamepad_recognized;
  52. }
  53. return empty_slot;
  54. }
  55. PadState* GamepadPadStateProvider::GetConnectedPadState(uint32_t pad_index) {
  56. if (pad_index >= Gamepads::kItemsLengthCap)
  57. return nullptr;
  58. PadState& pad_state = pad_states_.get()[pad_index];
  59. if (pad_state.source == GAMEPAD_SOURCE_NONE)
  60. return nullptr;
  61. return &pad_state;
  62. }
  63. void GamepadPadStateProvider::ClearPadState(PadState& state) {
  64. memset(&state, 0, sizeof(PadState));
  65. }
  66. void GamepadPadStateProvider::InitializeDataFetcher(
  67. GamepadDataFetcher* fetcher) {
  68. fetcher->InitializeProvider(this);
  69. }
  70. void GamepadPadStateProvider::MapAndSanitizeGamepadData(PadState* pad_state,
  71. Gamepad* pad,
  72. bool sanitize) {
  73. DCHECK(pad_state);
  74. DCHECK(pad);
  75. if (!pad_state->data.connected) {
  76. memset(pad, 0, sizeof(Gamepad));
  77. return;
  78. }
  79. // Copy the current state to the output buffer, using the mapping
  80. // function, if there is one available.
  81. if (pad_state->mapper)
  82. pad_state->mapper(pad_state->data, pad);
  83. else
  84. *pad = pad_state->data;
  85. pad->connected = true;
  86. if (!sanitize)
  87. return;
  88. // About sanitization: Gamepads may report input event if the user is not
  89. // interacting with it, due to hardware problems or environmental ones (pad
  90. // has something heavy leaning against an axis.) This may cause user gestures
  91. // to be detected erroniously, exposing gamepad information when the user had
  92. // no intention of doing so. To avoid this we require that each button or axis
  93. // report being at rest (zero) at least once before exposing its value to the
  94. // Gamepad API. This state is tracked by the axis_mask and button_mask
  95. // bitfields. If the bit for an axis or button is 0 it means the axis has
  96. // never reported being at rest, and the value will be forced to zero.
  97. // We can skip axis sanitation if all available axes have been masked.
  98. uint32_t full_axis_mask = (1 << pad->axes_length) - 1;
  99. if (pad_state->axis_mask != full_axis_mask) {
  100. for (size_t axis = 0; axis < pad->axes_length; ++axis) {
  101. if (!(pad_state->axis_mask & 1 << axis)) {
  102. if (fabs(pad->axes[axis]) < kMinAxisResetValue) {
  103. pad_state->axis_mask |= 1 << axis;
  104. } else {
  105. pad->axes[axis] = 0.0f;
  106. }
  107. }
  108. }
  109. }
  110. // We can skip button sanitation if all available buttons have been masked.
  111. uint32_t full_button_mask = (1 << pad->buttons_length) - 1;
  112. if (pad_state->button_mask != full_button_mask) {
  113. for (size_t button = 0; button < pad->buttons_length; ++button) {
  114. if (!(pad_state->button_mask & 1 << button)) {
  115. if (!pad->buttons[button].pressed) {
  116. pad_state->button_mask |= 1 << button;
  117. } else {
  118. pad->buttons[button].pressed = false;
  119. pad->buttons[button].value = 0.0f;
  120. }
  121. }
  122. }
  123. }
  124. }
  125. } // namespace device