1 files changed, 50 insertions, 34 deletions

diff --git a/src/input_common/gcadapter/gc_poller.cpp b/src/input_common/gcadapter/gc_poller.cpp
index 385ce8430..92e9e8e89 100644
--- a/src/input_common/gcadapter/gc_poller.cpp
+++ b/src/input_common/gcadapter/gc_poller.cpp
@@ -6,6 +6,7 @@
 #include <list>
 #include <mutex>
 #include <utility>
+#include "common/assert.h"
 #include "common/threadsafe_queue.h"
 #include "input_common/gcadapter/gc_adapter.h"
 #include "input_common/gcadapter/gc_poller.h"
@@ -14,42 +15,44 @@ namespace InputCommon {
 
 class GCButton final : public Input::ButtonDevice {
 public:
-    explicit GCButton(int port_, int button_, GCAdapter::Adapter* adapter)
+    explicit GCButton(int port_, int button_, const GCAdapter::Adapter* adapter)
         : port(port_), button(button_), gcadapter(adapter) {}
 
     ~GCButton() override;
 
     bool GetStatus() const override {
-        return gcadapter->GetPadState()[port].buttons.at(button);
+        if (gcadapter->DeviceConnected(port)) {
+            return gcadapter->GetPadState()[port].buttons.at(button);
+        }
+        return false;
     }
 
 private:
     const int port;
     const int button;
-    GCAdapter::Adapter* gcadapter;
+    const GCAdapter::Adapter* gcadapter;
 };
 
 class GCAxisButton final : public Input::ButtonDevice {
 public:
     explicit GCAxisButton(int port_, int axis_, float threshold_, bool trigger_if_greater_,
-                          GCAdapter::Adapter* adapter)
+                          const GCAdapter::Adapter* adapter)
         : port(port_), axis(axis_), threshold(threshold_), trigger_if_greater(trigger_if_greater_),
-          gcadapter(adapter) {
-        // L/R triggers range is only in positive direction beginning near 0
-        // 0.0 threshold equates to near half trigger press, but threshold accounts for variability.
-        if (axis > 3) {
-            threshold *= -0.5;
-        }
-    }
+          gcadapter(adapter),
+          origin_value(static_cast<float>(adapter->GetOriginValue(port_, axis_))) {}
 
     bool GetStatus() const override {
-        const float axis_value = (gcadapter->GetPadState()[port].axes.at(axis) - 128.0f) / 128.0f;
-        if (trigger_if_greater) {
-            // TODO: Might be worthwile to set a slider for the trigger threshold. It is currently
-            // always set to 0.5 in configure_input_player.cpp ZL/ZR HandleClick
-            return axis_value > threshold;
+        if (gcadapter->DeviceConnected(port)) {
+            const float current_axis_value = gcadapter->GetPadState()[port].axes.at(axis);
+            const float axis_value = (current_axis_value - origin_value) / 128.0f;
+            if (trigger_if_greater) {
+                // TODO: Might be worthwile to set a slider for the trigger threshold. It is
+                // currently always set to 0.5 in configure_input_player.cpp ZL/ZR HandleClick
+                return axis_value > threshold;
+            }
+            return axis_value < -threshold;
         }
-        return axis_value < -threshold;
+        return false;
     }
 
 private:
@@ -57,7 +60,8 @@ private:
     const int axis;
     float threshold;
     bool trigger_if_greater;
-    GCAdapter::Adapter* gcadapter;
+    const GCAdapter::Adapter* gcadapter;
+    const float origin_value;
 };
 
 GCButtonFactory::GCButtonFactory(std::shared_ptr<GCAdapter::Adapter> adapter_)
@@ -73,8 +77,7 @@ std::unique_ptr<Input::ButtonDevice> GCButtonFactory::Create(const Common::Param
 
     // button is not an axis/stick button
     if (button_id != PAD_STICK_ID) {
-        auto button = std::make_unique<GCButton>(port, button_id, adapter.get());
-        return std::move(button);
+        return std::make_unique<GCButton>(port, button_id, adapter.get());
     }
 
     // For Axis buttons, used by the binary sticks.
@@ -94,9 +97,12 @@ std::unique_ptr<Input::ButtonDevice> GCButtonFactory::Create(const Common::Param
         return std::make_unique<GCAxisButton>(port, axis, threshold, trigger_if_greater,
                                               adapter.get());
     }
+
+    UNREACHABLE();
+    return nullptr;
 }
 
-Common::ParamPackage GCButtonFactory::GetNextInput() {
+Common::ParamPackage GCButtonFactory::GetNextInput() const {
     Common::ParamPackage params;
     GCAdapter::GCPadStatus pad;
     auto& queue = adapter->GetPadQueue();
@@ -143,15 +149,20 @@ void GCButtonFactory::EndConfiguration() {
 
 class GCAnalog final : public Input::AnalogDevice {
 public:
-    GCAnalog(int port_, int axis_x_, int axis_y_, float deadzone_, GCAdapter::Adapter* adapter)
-        : port(port_), axis_x(axis_x_), axis_y(axis_y_), deadzone(deadzone_), gcadapter(adapter) {}
+    GCAnalog(int port_, int axis_x_, int axis_y_, float deadzone_,
+             const GCAdapter::Adapter* adapter, float range_)
+        : port(port_), axis_x(axis_x_), axis_y(axis_y_), deadzone(deadzone_), gcadapter(adapter),
+          origin_value_x(static_cast<float>(adapter->GetOriginValue(port_, axis_x_))),
+          origin_value_y(static_cast<float>(adapter->GetOriginValue(port_, axis_y_))),
+          range(range_) {}
 
     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 (gcadapter->GetPadState()[port].axes.at(axis) - 128.0f) / 95.0f;
+        if (gcadapter->DeviceConnected(port)) {
+            std::lock_guard lock{mutex};
+            const auto origin_value = axis % 2 == 0 ? origin_value_x : origin_value_y;
+            return (gcadapter->GetPadState()[port].axes.at(axis) - origin_value) / (100.0f * range);
+        }
+        return 0.0f;
     }
 
     std::pair<float, float> GetAnalog(int axis_x, int axis_y) const {
@@ -182,7 +193,7 @@ public:
 
     bool GetAnalogDirectionStatus(Input::AnalogDirection direction) const override {
         const auto [x, y] = GetStatus();
-        const float directional_deadzone = 0.4f;
+        const float directional_deadzone = 0.5f;
         switch (direction) {
         case Input::AnalogDirection::RIGHT:
             return x > directional_deadzone;
@@ -201,8 +212,11 @@ private:
     const int axis_x;
     const int axis_y;
     const float deadzone;
+    const GCAdapter::Adapter* gcadapter;
+    const float origin_value_x;
+    const float origin_value_y;
+    const float range;
     mutable std::mutex mutex;
-    GCAdapter::Adapter* gcadapter;
 };
 
 /// An analog device factory that creates analog devices from GC Adapter
@@ -220,9 +234,10 @@ std::unique_ptr<Input::AnalogDevice> GCAnalogFactory::Create(const Common::Param
     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);
+    const float deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, 1.0f);
+    const float range = std::clamp(params.Get("range", 1.0f), 0.50f, 1.50f);
 
-    return std::make_unique<GCAnalog>(port, axis_x, axis_y, deadzone, adapter.get());
+    return std::make_unique<GCAnalog>(port, axis_x, axis_y, deadzone, adapter.get(), range);
 }
 
 void GCAnalogFactory::BeginConfiguration() {
@@ -249,8 +264,9 @@ Common::ParamPackage GCAnalogFactory::GetNextInput() {
             const u8 axis = static_cast<u8>(pad.axis);
             if (analog_x_axis == -1) {
                 analog_x_axis = axis;
-                controller_number = port;
-            } else if (analog_y_axis == -1 && analog_x_axis != axis && controller_number == port) {
+                controller_number = static_cast<int>(port);
+            } else if (analog_y_axis == -1 && analog_x_axis != axis &&
+                       controller_number == static_cast<int>(port)) {
                 analog_y_axis = axis;
             }
         }