summaryrefslogtreecommitdiffstats
path: root/src/input_common/gcadapter/gc_poller.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/input_common/gcadapter/gc_poller.cpp310
1 files changed, 310 insertions, 0 deletions
diff --git a/src/input_common/gcadapter/gc_poller.cpp b/src/input_common/gcadapter/gc_poller.cpp
new file mode 100644
index 000000000..772bd8890
--- /dev/null
+++ b/src/input_common/gcadapter/gc_poller.cpp
@@ -0,0 +1,310 @@
+#include <atomic>
+#include <list>
+#include <mutex>
+#include <utility>
+#include "input_common/gcadapter/gc_poller.h"
+#include "input_common/gcadapter/gc_adapter.h"
+#include "common/threadsafe_queue.h"
+
+// Using extern as to avoid multply defined symbols.
+extern Common::SPSCQueue<GCPadStatus> pad_queue[4];
+extern struct GCState state[4];
+
+namespace InputCommon {
+
+class GCButton final : public Input::ButtonDevice {
+public:
+ explicit GCButton(int port_, int button_, int axis_)
+ : port(port_), button(button_) {
+ }
+
+ ~GCButton() override;
+
+ bool GetStatus() const override {
+ return state[port].buttons.at(button);
+ }
+
+private:
+ const int port;
+ const int button;
+};
+
+class GCAxisButton final : public Input::ButtonDevice {
+public:
+ explicit GCAxisButton(int port_, int axis_, float threshold_,
+ bool trigger_if_greater_)
+ : port(port_), axis(axis_), threshold(threshold_),
+ trigger_if_greater(trigger_if_greater_) {
+ }
+
+
+ bool GetStatus() const override {
+ const float axis_value = (state[port].axes.at(axis) - 128.0f) / 128.0f;
+ if (trigger_if_greater) {
+ return axis_value > 0.10f; //TODO(ameerj) : Fix threshold.
+ }
+ return axis_value < -0.10f;
+ }
+
+private:
+ const int port;
+ const int axis;
+ float threshold;
+ bool trigger_if_greater;
+};
+
+GCButtonFactory::GCButtonFactory() {
+ GCAdapter::Init();
+}
+
+GCButton::~GCButton() {
+ GCAdapter::Shutdown();
+}
+
+std::unique_ptr<Input::ButtonDevice> GCButtonFactory::Create(const Common::ParamPackage& params) {
+ int button_id = params.Get("button", 0);
+ int port = params.Get("port", 0);
+ // For Axis buttons, used by the binary sticks.
+ if (params.Has("axis")) {
+ const int axis = params.Get("axis", 0);
+ const float threshold = params.Get("threshold", 0.5f);
+ const std::string direction_name = params.Get("direction", "");
+ bool trigger_if_greater;
+ if (direction_name == "+") {
+ trigger_if_greater = true;
+ } else if (direction_name == "-") {
+ trigger_if_greater = false;
+ } else {
+ trigger_if_greater = true;
+ LOG_ERROR(Input, "Unknown direction {}", direction_name);
+ }
+ return std::make_unique<GCAxisButton>(port, axis, threshold, trigger_if_greater);
+ }
+
+ std::unique_ptr<GCButton> button =
+ std::make_unique<GCButton>(port, button_id, params.Get("axis", 0));
+ return std::move(button);
+}
+
+Common::ParamPackage GCButtonFactory::GetNextInput() {
+ Common::ParamPackage params;
+ GCPadStatus pad;
+ for (int i = 0; i < 4; i++) {
+ while (pad_queue[i].Pop(pad)) {
+ // This while loop will break on the earliest detected button
+ params.Set("engine", "gcpad");
+ params.Set("port", i);
+ // I was debating whether to keep these verbose for ease of reading
+ // or to use a while loop shifting the bits to test and set the value.
+ if (pad.button & PAD_BUTTON_A) {
+ params.Set("button", PAD_BUTTON_A);
+ break;
+ }
+ if (pad.button & PAD_BUTTON_B) {
+ params.Set("button", PAD_BUTTON_B);
+ break;
+ }
+ if (pad.button & PAD_BUTTON_X) {
+ params.Set("button", PAD_BUTTON_X);
+ break;
+ }
+ if (pad.button & PAD_BUTTON_Y) {
+ params.Set("button", PAD_BUTTON_Y);
+ break;
+ }
+ if (pad.button & PAD_BUTTON_DOWN) {
+ params.Set("button", PAD_BUTTON_DOWN);
+ break;
+ }
+ if (pad.button & PAD_BUTTON_LEFT) {
+ params.Set("button", PAD_BUTTON_LEFT);
+ break;
+ }
+ if (pad.button & PAD_BUTTON_RIGHT) {
+ params.Set("button", PAD_BUTTON_RIGHT);
+ break;
+ }
+ if (pad.button & PAD_BUTTON_UP) {
+ params.Set("button", PAD_BUTTON_UP);
+ break;
+ }
+ if (pad.button & PAD_TRIGGER_L) {
+ params.Set("button", PAD_TRIGGER_L);
+ break;
+ }
+ if (pad.button & PAD_TRIGGER_R) {
+ params.Set("button", PAD_TRIGGER_R);
+ break;
+ }
+ if (pad.button & PAD_TRIGGER_Z) {
+ params.Set("button", PAD_TRIGGER_Z);
+ break;
+ }
+ if (pad.button & PAD_BUTTON_START) {
+ params.Set("button", PAD_BUTTON_START);
+ break;
+ }
+ // For Axis button implementation
+ if (pad.axis_which != 255) {
+ params.Set("axis", pad.axis_which);
+ params.Set("button", PAD_STICK);
+ if (pad.axis_value > 128) {
+ params.Set("direction", "+");
+ params.Set("threshold", "0.5");
+ } else {
+ params.Set("direction", "-");
+ params.Set("threshold", "-0.5");
+ }
+ break;
+ }
+ }
+ }
+ return params;
+}
+
+void GCButtonFactory::BeginConfiguration() {
+ polling = true;
+ for (int i = 0; i < 4; i++)
+ pad_queue[i].Clear();
+ GCAdapter::BeginConfiguration();
+}
+
+void GCButtonFactory::EndConfiguration() {
+ polling = false;
+
+ for (int i = 0; i < 4; i++)
+ pad_queue[i].Clear();
+ GCAdapter::EndConfiguration();
+}
+
+class GCAnalog final : public Input::AnalogDevice {
+public:
+ GCAnalog(int port_, int axis_x_, int axis_y_, float deadzone_)
+ : port(port_), axis_x(axis_x_), axis_y(axis_y_), deadzone(deadzone_) {
+ }
+
+ float GetAxis(int axis) const {
+ std::lock_guard lock{mutex};
+ // division is not by a perfect 128 to account for some variance in center location
+ // e.g. my device idled at 131 in X, 120 in Y, and full range of motion was in range [20-230]
+ return (state[port].axes.at(axis) - 128.0f) / 95.0f;
+ }
+
+ std::tuple<float, float> GetAnalog(int axis_x, int axis_y) const {
+ float x = GetAxis(axis_x);
+ float y = GetAxis(axis_y);
+
+ // Make sure the coordinates are in the unit circle,
+ // otherwise normalize it.
+ float r = x * x + y * y;
+ if (r > 1.0f) {
+ r = std::sqrt(r);
+ x /= r;
+ y /= r;
+ }
+
+ return std::make_tuple(x, y);
+ }
+
+ std::tuple<float, float> GetStatus() const override {
+ const auto [x, y] = GetAnalog(axis_x, axis_y);
+ const float r = std::sqrt((x * x) + (y * y));
+ if (r > deadzone) {
+ return std::make_tuple(x / r * (r - deadzone) / (1 - deadzone),
+ y / r * (r - deadzone) / (1 - deadzone));
+ }
+ return std::make_tuple<float, float>(0.0f, 0.0f);
+ }
+
+ bool GetAnalogDirectionStatus(Input::AnalogDirection direction) const override {
+ const auto [x, y] = GetStatus();
+ const float directional_deadzone = 0.4f;
+ switch (direction) {
+ case Input::AnalogDirection::RIGHT:
+ return x > directional_deadzone;
+ case Input::AnalogDirection::LEFT:
+ return x < -directional_deadzone;
+ case Input::AnalogDirection::UP:
+ return y > directional_deadzone;
+ case Input::AnalogDirection::DOWN:
+ return y < -directional_deadzone;
+ }
+ return false;
+ }
+
+private:
+ const int port;
+ const int axis_x;
+ const int axis_y;
+ const float deadzone;
+ mutable std::mutex mutex;
+};
+
+
+/// An analog device factory that creates analog devices from GC Adapter
+GCAnalogFactory::GCAnalogFactory() {};
+
+
+/**
+* Creates analog device from joystick axes
+* @param params contains parameters for creating the device:
+* - "port": the nth gcpad on the adapter
+* - "axis_x": the index of the axis to be bind as x-axis
+* - "axis_y": the index of the axis to be bind as y-axis
+*/
+std::unique_ptr<Input::AnalogDevice> GCAnalogFactory::Create(const Common::ParamPackage& params) {
+ const std::string guid = params.Get("guid", "0");
+ const int port = params.Get("port", 0);
+ const int axis_x = params.Get("axis_x", 0);
+ const int axis_y = params.Get("axis_y", 1);
+ const float deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, .99f);
+
+ return std::make_unique<GCAnalog>(port, axis_x, axis_y, deadzone);
+}
+
+void GCAnalogFactory::BeginConfiguration() {
+ polling = true;
+ for (int i = 0; i < 4; i++)
+ pad_queue[i].Clear();
+ GCAdapter::BeginConfiguration();
+}
+
+void GCAnalogFactory::EndConfiguration() {
+ polling = false;
+ for (int i = 0; i < 4; i++)
+ pad_queue[i].Clear();
+ GCAdapter::EndConfiguration();
+}
+
+Common::ParamPackage GCAnalogFactory::GetNextInput() {
+ GCPadStatus pad;
+ for (int i = 0; i < 4; i++) {
+ while (pad_queue[i].Pop(pad)) {
+ if (pad.axis_which == 255 || std::abs((pad.axis_value - 128.0f) / 128.0f) < 0.1) {
+ continue;
+ }
+ // An analog device needs two axes, so we need to store the axis for later and wait for
+ // a second SDL event. The axes also must be from the same joystick.
+ const int axis = pad.axis_which;
+ if (analog_x_axis == -1) {
+ analog_x_axis = axis;
+ controller_number = i;
+ } else if (analog_y_axis == -1 && analog_x_axis != axis && controller_number == i) {
+ analog_y_axis = axis;
+ }
+ }
+ }
+ Common::ParamPackage params;
+ if (analog_x_axis != -1 && analog_y_axis != -1) {
+ params.Set("engine", "gcpad");
+ params.Set("port", controller_number);
+ params.Set("axis_x", analog_x_axis);
+ params.Set("axis_y", analog_y_axis);
+ analog_x_axis = -1;
+ analog_y_axis = -1;
+ controller_number = -1;
+ return params;
+ }
+ return params;
+}
+} // namespace InputCommon
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-14 20:01:52 +0200