6 files changed, 950 insertions, 1757 deletions

diff --git a/src/input_common/CMakeLists.txt b/src/input_common/CMakeLists.txt
index 9c0c82138..8cdcd315b 100644
--- a/src/input_common/CMakeLists.txt
+++ b/src/input_common/CMakeLists.txt
@@ -5,6 +5,8 @@ add_library(input_common STATIC
     drivers/keyboard.h
     drivers/mouse.cpp
     drivers/mouse.h
+    drivers/sdl_driver.cpp
+    drivers/sdl_driver.h
     drivers/tas_input.cpp
     drivers/tas_input.h
     drivers/touch_screen.cpp
@@ -29,8 +31,6 @@ add_library(input_common STATIC
     motion_from_button.h
     motion_input.cpp
     motion_input.h
-    sdl/sdl.cpp
-    sdl/sdl.h
 )
 
 if (MSVC)
@@ -57,8 +57,8 @@ endif()
 
 if (ENABLE_SDL2)
     target_sources(input_common PRIVATE
-        sdl/sdl_impl.cpp
-        sdl/sdl_impl.h
+        drivers/sdl_driver.cpp
+        drivers/sdl_driver.h
     )
     target_link_libraries(input_common PRIVATE SDL2)
     target_compile_definitions(input_common PRIVATE HAVE_SDL2)
diff --git a/src/input_common/drivers/sdl_driver.cpp b/src/input_common/drivers/sdl_driver.cpp
new file mode 100644
index 000000000..efb4a2106
--- /dev/null
+++ b/src/input_common/drivers/sdl_driver.cpp
@@ -0,0 +1,915 @@
+// Copyright 2018 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/logging/log.h"
+#include "common/math_util.h"
+#include "common/param_package.h"
+#include "common/settings.h"
+#include "common/thread.h"
+#include "common/vector_math.h"
+#include "input_common/drivers/sdl_driver.h"
+
+namespace InputCommon {
+
+namespace {
+std::string GetGUID(SDL_Joystick* joystick) {
+    const SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick);
+    char guid_str[33];
+    SDL_JoystickGetGUIDString(guid, guid_str, sizeof(guid_str));
+    return guid_str;
+}
+} // Anonymous namespace
+
+static int SDLEventWatcher(void* user_data, SDL_Event* event) {
+    auto* const sdl_state = static_cast<SDLDriver*>(user_data);
+
+    sdl_state->HandleGameControllerEvent(*event);
+
+    return 0;
+}
+
+class SDLJoystick {
+public:
+    SDLJoystick(std::string guid_, int port_, SDL_Joystick* joystick,
+                SDL_GameController* game_controller)
+        : guid{std::move(guid_)}, port{port_}, sdl_joystick{joystick, &SDL_JoystickClose},
+          sdl_controller{game_controller, &SDL_GameControllerClose} {
+        EnableMotion();
+    }
+
+    void EnableMotion() {
+        if (sdl_controller) {
+            SDL_GameController* controller = sdl_controller.get();
+            if (SDL_GameControllerHasSensor(controller, SDL_SENSOR_ACCEL) && !has_accel) {
+                SDL_GameControllerSetSensorEnabled(controller, SDL_SENSOR_ACCEL, SDL_TRUE);
+                has_accel = true;
+            }
+            if (SDL_GameControllerHasSensor(controller, SDL_SENSOR_GYRO) && !has_gyro) {
+                SDL_GameControllerSetSensorEnabled(controller, SDL_SENSOR_GYRO, SDL_TRUE);
+                has_gyro = true;
+            }
+        }
+    }
+
+    bool HasGyro() const {
+        return has_gyro;
+    }
+
+    bool HasAccel() const {
+        return has_accel;
+    }
+
+    bool UpdateMotion(SDL_ControllerSensorEvent event) {
+        constexpr float gravity_constant = 9.80665f;
+        std::lock_guard lock{mutex};
+        const u64 time_difference = event.timestamp - last_motion_update;
+        last_motion_update = event.timestamp;
+        switch (event.sensor) {
+        case SDL_SENSOR_ACCEL: {
+            motion.accel_x = -event.data[0] / gravity_constant;
+            motion.accel_y = event.data[2] / gravity_constant;
+            motion.accel_z = -event.data[1] / gravity_constant;
+            break;
+        }
+        case SDL_SENSOR_GYRO: {
+            motion.gyro_x = event.data[0] / (Common::PI * 2);
+            motion.gyro_y = -event.data[2] / (Common::PI * 2);
+            motion.gyro_z = event.data[1] / (Common::PI * 2);
+            break;
+        }
+        }
+
+        // Ignore duplicated timestamps
+        if (time_difference == 0) {
+            return false;
+        }
+        motion.delta_timestamp = time_difference * 1000;
+        return true;
+    }
+
+    BasicMotion GetMotion() {
+        return motion;
+    }
+
+    bool RumblePlay(const Input::VibrationStatus vibration) {
+        constexpr u32 rumble_max_duration_ms = 1000;
+
+        if (sdl_controller) {
+            return SDL_GameControllerRumble(
+                       sdl_controller.get(), static_cast<u16>(vibration.low_amplitude),
+                       static_cast<u16>(vibration.high_amplitude), rumble_max_duration_ms) != -1;
+        } else if (sdl_joystick) {
+            return SDL_JoystickRumble(sdl_joystick.get(), static_cast<u16>(vibration.low_amplitude),
+                                      static_cast<u16>(vibration.high_amplitude),
+                                      rumble_max_duration_ms) != -1;
+        }
+
+        return false;
+    }
+    /**
+     * The Pad identifier of the joystick
+     */
+    const PadIdentifier GetPadIdentifier() const {
+        return {
+            .guid = Common::UUID{guid},
+            .port = static_cast<std::size_t>(port),
+            .pad = 0,
+        };
+    }
+
+    /**
+     * The guid of the joystick
+     */
+    const std::string& GetGUID() const {
+        return guid;
+    }
+
+    /**
+     * The number of joystick from the same type that were connected before this joystick
+     */
+    int GetPort() const {
+        return port;
+    }
+
+    SDL_Joystick* GetSDLJoystick() const {
+        return sdl_joystick.get();
+    }
+
+    SDL_GameController* GetSDLGameController() const {
+        return sdl_controller.get();
+    }
+
+    void SetSDLJoystick(SDL_Joystick* joystick, SDL_GameController* controller) {
+        sdl_joystick.reset(joystick);
+        sdl_controller.reset(controller);
+    }
+
+    bool IsJoyconLeft() const {
+        const std::string controller_name = GetControllerName();
+        if (std::strstr(controller_name.c_str(), "Joy-Con Left") != nullptr) {
+            return true;
+        }
+        if (std::strstr(controller_name.c_str(), "Joy-Con (L)") != nullptr) {
+            return true;
+        }
+        return false;
+    }
+
+    bool IsJoyconRight() const {
+        const std::string controller_name = GetControllerName();
+        if (std::strstr(controller_name.c_str(), "Joy-Con Right") != nullptr) {
+            return true;
+        }
+        if (std::strstr(controller_name.c_str(), "Joy-Con (R)") != nullptr) {
+            return true;
+        }
+        return false;
+    }
+
+    BatteryLevel GetBatteryLevel() {
+        const auto level = SDL_JoystickCurrentPowerLevel(sdl_joystick.get());
+        switch (level) {
+        case SDL_JOYSTICK_POWER_EMPTY:
+            return BatteryLevel::Empty;
+        case SDL_JOYSTICK_POWER_LOW:
+            return BatteryLevel::Critical;
+        case SDL_JOYSTICK_POWER_MEDIUM:
+            return BatteryLevel::Low;
+        case SDL_JOYSTICK_POWER_FULL:
+            return BatteryLevel::Medium;
+        case SDL_JOYSTICK_POWER_MAX:
+            return BatteryLevel::Full;
+        case SDL_JOYSTICK_POWER_UNKNOWN:
+        case SDL_JOYSTICK_POWER_WIRED:
+        default:
+            return BatteryLevel::Charging;
+        }
+    }
+
+    std::string GetControllerName() const {
+        if (sdl_controller) {
+            switch (SDL_GameControllerGetType(sdl_controller.get())) {
+            case SDL_CONTROLLER_TYPE_XBOX360:
+                return "XBox 360 Controller";
+            case SDL_CONTROLLER_TYPE_XBOXONE:
+                return "XBox One Controller";
+            default:
+                break;
+            }
+            const auto name = SDL_GameControllerName(sdl_controller.get());
+            if (name) {
+                return name;
+            }
+        }
+
+        if (sdl_joystick) {
+            const auto name = SDL_JoystickName(sdl_joystick.get());
+            if (name) {
+                return name;
+            }
+        }
+
+        return "Unknown";
+    }
+
+    bool IsYAxis(u8 index) {
+        if (!sdl_controller) {
+            return false;
+        }
+
+        const auto& binding_left_y =
+            SDL_GameControllerGetBindForAxis(sdl_controller.get(), SDL_CONTROLLER_AXIS_LEFTY);
+        const auto& binding_right_y =
+            SDL_GameControllerGetBindForAxis(sdl_controller.get(), SDL_CONTROLLER_AXIS_RIGHTY);
+        if (index == binding_left_y.value.axis) {
+            return true;
+        }
+        if (index == binding_right_y.value.axis) {
+            return true;
+        }
+        return false;
+    }
+
+private:
+    std::string guid;
+    int port;
+    std::unique_ptr<SDL_Joystick, decltype(&SDL_JoystickClose)> sdl_joystick;
+    std::unique_ptr<SDL_GameController, decltype(&SDL_GameControllerClose)> sdl_controller;
+    mutable std::mutex mutex;
+
+    u64 last_motion_update{};
+    bool has_gyro{false};
+    bool has_accel{false};
+    BasicMotion motion;
+};
+
+std::shared_ptr<SDLJoystick> SDLDriver::GetSDLJoystickByGUID(const std::string& guid, int port) {
+    std::lock_guard lock{joystick_map_mutex};
+    const auto it = joystick_map.find(guid);
+
+    if (it != joystick_map.end()) {
+        while (it->second.size() <= static_cast<std::size_t>(port)) {
+            auto joystick = std::make_shared<SDLJoystick>(guid, static_cast<int>(it->second.size()),
+                                                          nullptr, nullptr);
+            it->second.emplace_back(std::move(joystick));
+        }
+
+        return it->second[static_cast<std::size_t>(port)];
+    }
+
+    auto joystick = std::make_shared<SDLJoystick>(guid, 0, nullptr, nullptr);
+
+    return joystick_map[guid].emplace_back(std::move(joystick));
+}
+
+std::shared_ptr<SDLJoystick> SDLDriver::GetSDLJoystickBySDLID(SDL_JoystickID sdl_id) {
+    auto sdl_joystick = SDL_JoystickFromInstanceID(sdl_id);
+    const std::string guid = GetGUID(sdl_joystick);
+
+    std::lock_guard lock{joystick_map_mutex};
+    const auto map_it = joystick_map.find(guid);
+
+    if (map_it == joystick_map.end()) {
+        return nullptr;
+    }
+
+    const auto vec_it = std::find_if(map_it->second.begin(), map_it->second.end(),
+                                     [&sdl_joystick](const auto& joystick) {
+                                         return joystick->GetSDLJoystick() == sdl_joystick;
+                                     });
+
+    if (vec_it == map_it->second.end()) {
+        return nullptr;
+    }
+
+    return *vec_it;
+}
+
+void SDLDriver::InitJoystick(int joystick_index) {
+    SDL_Joystick* sdl_joystick = SDL_JoystickOpen(joystick_index);
+    SDL_GameController* sdl_gamecontroller = nullptr;
+
+    if (SDL_IsGameController(joystick_index)) {
+        sdl_gamecontroller = SDL_GameControllerOpen(joystick_index);
+    }
+
+    if (!sdl_joystick) {
+        LOG_ERROR(Input, "Failed to open joystick {}", joystick_index);
+        return;
+    }
+
+    const std::string guid = GetGUID(sdl_joystick);
+
+    std::lock_guard lock{joystick_map_mutex};
+    if (joystick_map.find(guid) == joystick_map.end()) {
+        auto joystick = std::make_shared<SDLJoystick>(guid, 0, sdl_joystick, sdl_gamecontroller);
+        PreSetController(joystick->GetPadIdentifier());
+        joystick_map[guid].emplace_back(std::move(joystick));
+        return;
+    }
+
+    auto& joystick_guid_list = joystick_map[guid];
+    const auto joystick_it =
+        std::find_if(joystick_guid_list.begin(), joystick_guid_list.end(),
+                     [](const auto& joystick) { return !joystick->GetSDLJoystick(); });
+
+    if (joystick_it != joystick_guid_list.end()) {
+        (*joystick_it)->SetSDLJoystick(sdl_joystick, sdl_gamecontroller);
+        return;
+    }
+
+    const int port = static_cast<int>(joystick_guid_list.size());
+    auto joystick = std::make_shared<SDLJoystick>(guid, port, sdl_joystick, sdl_gamecontroller);
+    PreSetController(joystick->GetPadIdentifier());
+    joystick_guid_list.emplace_back(std::move(joystick));
+}
+
+void SDLDriver::CloseJoystick(SDL_Joystick* sdl_joystick) {
+    const std::string guid = GetGUID(sdl_joystick);
+
+    std::lock_guard lock{joystick_map_mutex};
+    // This call to guid is safe since the joystick is guaranteed to be in the map
+    const auto& joystick_guid_list = joystick_map[guid];
+    const auto joystick_it = std::find_if(joystick_guid_list.begin(), joystick_guid_list.end(),
+                                          [&sdl_joystick](const auto& joystick) {
+                                              return joystick->GetSDLJoystick() == sdl_joystick;
+                                          });
+
+    if (joystick_it != joystick_guid_list.end()) {
+        (*joystick_it)->SetSDLJoystick(nullptr, nullptr);
+    }
+}
+
+void SDLDriver::HandleGameControllerEvent(const SDL_Event& event) {
+    switch (event.type) {
+    case SDL_JOYBUTTONUP: {
+        if (const auto joystick = GetSDLJoystickBySDLID(event.jbutton.which)) {
+            const PadIdentifier identifier = joystick->GetPadIdentifier();
+            SetButton(identifier, event.jbutton.button, false);
+        }
+        break;
+    }
+    case SDL_JOYBUTTONDOWN: {
+        if (const auto joystick = GetSDLJoystickBySDLID(event.jbutton.which)) {
+            const PadIdentifier identifier = joystick->GetPadIdentifier();
+            SetButton(identifier, event.jbutton.button, true);
+        }
+        break;
+    }
+    case SDL_JOYHATMOTION: {
+        if (const auto joystick = GetSDLJoystickBySDLID(event.jhat.which)) {
+            const PadIdentifier identifier = joystick->GetPadIdentifier();
+            SetHatButton(identifier, event.jhat.hat, event.jhat.value);
+        }
+        break;
+    }
+    case SDL_JOYAXISMOTION: {
+        if (const auto joystick = GetSDLJoystickBySDLID(event.jaxis.which)) {
+            const PadIdentifier identifier = joystick->GetPadIdentifier();
+            // Vertical axis is inverted on nintendo compared to SDL
+            if (joystick->IsYAxis(event.jaxis.axis)) {
+                SetAxis(identifier, event.jaxis.axis, -event.jaxis.value / 32767.0f);
+                break;
+            }
+            SetAxis(identifier, event.jaxis.axis, event.jaxis.value / 32767.0f);
+        }
+        break;
+    }
+    case SDL_CONTROLLERSENSORUPDATE: {
+        if (auto joystick = GetSDLJoystickBySDLID(event.csensor.which)) {
+            if (joystick->UpdateMotion(event.csensor)) {
+                const PadIdentifier identifier = joystick->GetPadIdentifier();
+                SetMotion(identifier, 0, joystick->GetMotion());
+            };
+        }
+        break;
+    }
+    case SDL_JOYDEVICEREMOVED:
+        LOG_DEBUG(Input, "Controller removed with Instance_ID {}", event.jdevice.which);
+        CloseJoystick(SDL_JoystickFromInstanceID(event.jdevice.which));
+        break;
+    case SDL_JOYDEVICEADDED:
+        LOG_DEBUG(Input, "Controller connected with device index {}", event.jdevice.which);
+        InitJoystick(event.jdevice.which);
+        break;
+    }
+}
+
+void SDLDriver::CloseJoysticks() {
+    std::lock_guard lock{joystick_map_mutex};
+    joystick_map.clear();
+}
+
+SDLDriver::SDLDriver(const std::string& input_engine_) : InputEngine(input_engine_) {
+    Common::SetCurrentThreadName("yuzu:input:SDL");
+
+    if (!Settings::values.enable_raw_input) {
+        // Disable raw input. When enabled this setting causes SDL to die when a web applet opens
+        SDL_SetHint(SDL_HINT_JOYSTICK_RAWINPUT, "0");
+    }
+
+    // Prevent SDL from adding undesired axis
+    SDL_SetHint(SDL_HINT_ACCELEROMETER_AS_JOYSTICK, "0");
+
+    // Enable HIDAPI rumble. This prevents SDL from disabling motion on PS4 and PS5 controllers
+    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE, "1");
+    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE, "1");
+    SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1");
+
+    // Use hidapi driver for joycons. This will allow joycons to be detected as a GameController and
+    // not a generic one
+    SDL_SetHint("SDL_JOYSTICK_HIDAPI_JOY_CONS", "1");
+
+    // Turn off Pro controller home led
+    SDL_SetHint("SDL_JOYSTICK_HIDAPI_SWITCH_HOME_LED", "0");
+
+    // If the frontend is going to manage the event loop, then we don't start one here
+    start_thread = SDL_WasInit(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) == 0;
+    if (start_thread && SDL_Init(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) < 0) {
+        LOG_CRITICAL(Input, "SDL_Init failed with: {}", SDL_GetError());
+        return;
+    }
+
+    SDL_AddEventWatch(&SDLEventWatcher, this);
+
+    initialized = true;
+    if (start_thread) {
+        poll_thread = std::thread([this] {
+            using namespace std::chrono_literals;
+            while (initialized) {
+                SDL_PumpEvents();
+                std::this_thread::sleep_for(1ms);
+            }
+        });
+    }
+    // Because the events for joystick connection happens before we have our event watcher added, we
+    // can just open all the joysticks right here
+    for (int i = 0; i < SDL_NumJoysticks(); ++i) {
+        InitJoystick(i);
+    }
+}
+
+SDLDriver::~SDLDriver() {
+    CloseJoysticks();
+    SDL_DelEventWatch(&SDLEventWatcher, this);
+
+    initialized = false;
+    if (start_thread) {
+        poll_thread.join();
+        SDL_QuitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER);
+    }
+}
+
+std::vector<Common::ParamPackage> SDLDriver::GetInputDevices() const {
+    std::vector<Common::ParamPackage> devices;
+    std::unordered_map<int, std::shared_ptr<SDLJoystick>> joycon_pairs;
+    for (const auto& [key, value] : joystick_map) {
+        for (const auto& joystick : value) {
+            if (!joystick->GetSDLJoystick()) {
+                continue;
+            }
+            const std::string name =
+                fmt::format("{} {}", joystick->GetControllerName(), joystick->GetPort());
+            devices.emplace_back(Common::ParamPackage{
+                {"engine", "sdl"},
+                {"display", std::move(name)},
+                {"guid", joystick->GetGUID()},
+                {"port", std::to_string(joystick->GetPort())},
+            });
+            if (joystick->IsJoyconLeft()) {
+                joycon_pairs.insert_or_assign(joystick->GetPort(), joystick);
+            }
+        }
+    }
+
+    // Add dual controllers
+    for (const auto& [key, value] : joystick_map) {
+        for (const auto& joystick : value) {
+            if (joystick->IsJoyconRight()) {
+                if (!joycon_pairs.contains(joystick->GetPort())) {
+                    continue;
+                }
+                const auto joystick2 = joycon_pairs.at(joystick->GetPort());
+
+                const std::string name =
+                    fmt::format("{} {}", "Nintendo Dual Joy-Con", joystick->GetPort());
+                devices.emplace_back(Common::ParamPackage{
+                    {"engine", "sdl"},
+                    {"display", std::move(name)},
+                    {"guid", joystick->GetGUID()},
+                    {"guid2", joystick2->GetGUID()},
+                    {"port", std::to_string(joystick->GetPort())},
+                });
+            }
+        }
+    }
+    return devices;
+}
+bool SDLDriver::SetRumble(const PadIdentifier& identifier, const Input::VibrationStatus vibration) {
+    const auto joystick =
+        GetSDLJoystickByGUID(identifier.guid.Format(), static_cast<int>(identifier.port));
+    const auto process_amplitude = [](f32 amplitude) {
+        return (amplitude + std::pow(amplitude, 0.3f)) * 0.5f * 0xFFFF;
+    };
+    const Input::VibrationStatus new_vibration{
+        .low_amplitude = process_amplitude(vibration.low_amplitude),
+        .low_frequency = vibration.low_frequency,
+        .high_amplitude = process_amplitude(vibration.high_amplitude),
+        .high_frequency = vibration.high_frequency,
+    };
+
+    return joystick->RumblePlay(new_vibration);
+}
+Common::ParamPackage SDLDriver::BuildAnalogParamPackageForButton(int port, std::string guid,
+                                                                 s32 axis, float value) const {
+    Common::ParamPackage params({{"engine", "sdl"}});
+    params.Set("port", port);
+    params.Set("guid", std::move(guid));
+    params.Set("axis", axis);
+    params.Set("threshold", "0.5");
+    params.Set("invert", value < 0 ? "-" : "+");
+    return params;
+}
+
+Common::ParamPackage SDLDriver::BuildButtonParamPackageForButton(int port, std::string guid,
+                                                                 s32 button) const {
+    Common::ParamPackage params({{"engine", "sdl"}});
+    params.Set("port", port);
+    params.Set("guid", std::move(guid));
+    params.Set("button", button);
+    return params;
+}
+
+Common::ParamPackage SDLDriver::BuildHatParamPackageForButton(int port, std::string guid, s32 hat,
+                                                              u8 value) const {
+    Common::ParamPackage params({{"engine", "sdl"}});
+
+    params.Set("port", port);
+    params.Set("guid", std::move(guid));
+    params.Set("hat", hat);
+    params.Set("direction", GetHatButtonName(value));
+    return params;
+}
+
+Common::ParamPackage SDLDriver::BuildMotionParam(int port, std::string guid) const {
+    Common::ParamPackage params({{"engine", "sdl"}, {"motion", "0"}});
+    params.Set("port", port);
+    params.Set("guid", std::move(guid));
+    return params;
+}
+
+Common::ParamPackage SDLDriver::BuildParamPackageForBinding(
+    int port, const std::string& guid, const SDL_GameControllerButtonBind& binding) const {
+    switch (binding.bindType) {
+    case SDL_CONTROLLER_BINDTYPE_NONE:
+        break;
+    case SDL_CONTROLLER_BINDTYPE_AXIS:
+        return BuildAnalogParamPackageForButton(port, guid, binding.value.axis);
+    case SDL_CONTROLLER_BINDTYPE_BUTTON:
+        return BuildButtonParamPackageForButton(port, guid, binding.value.button);
+    case SDL_CONTROLLER_BINDTYPE_HAT:
+        return BuildHatParamPackageForButton(port, guid, binding.value.hat.hat,
+                                             static_cast<u8>(binding.value.hat.hat_mask));
+    }
+    return {};
+}
+
+Common::ParamPackage SDLDriver::BuildParamPackageForAnalog(PadIdentifier identifier, int axis_x,
+                                                           int axis_y, float offset_x,
+                                                           float offset_y) const {
+    Common::ParamPackage params;
+    params.Set("engine", "sdl");
+    params.Set("port", static_cast<int>(identifier.port));
+    params.Set("guid", identifier.guid.Format());
+    params.Set("axis_x", axis_x);
+    params.Set("axis_y", axis_y);
+    params.Set("offset_x", offset_x);
+    params.Set("offset_y", offset_y);
+    params.Set("invert_x", "+");
+    params.Set("invert_y", "+");
+    return params;
+}
+
+ButtonMapping SDLDriver::GetButtonMappingForDevice(const Common::ParamPackage& params) {
+    if (!params.Has("guid") || !params.Has("port")) {
+        return {};
+    }
+    const auto joystick = GetSDLJoystickByGUID(params.Get("guid", ""), params.Get("port", 0));
+
+    auto* controller = joystick->GetSDLGameController();
+    if (controller == nullptr) {
+        return {};
+    }
+
+    // This list is missing ZL/ZR since those are not considered buttons in SDL GameController.
+    // We will add those afterwards
+    // This list also excludes Screenshot since theres not really a mapping for that
+    ButtonBindings switch_to_sdl_button;
+
+    if (SDL_GameControllerGetType(controller) == SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO) {
+        switch_to_sdl_button = GetNintendoButtonBinding(joystick);
+    } else {
+        switch_to_sdl_button = GetDefaultButtonBinding();
+    }
+
+    // Add the missing bindings for ZL/ZR
+    static constexpr ZButtonBindings switch_to_sdl_axis{{
+        {Settings::NativeButton::ZL, SDL_CONTROLLER_AXIS_TRIGGERLEFT},
+        {Settings::NativeButton::ZR, SDL_CONTROLLER_AXIS_TRIGGERRIGHT},
+    }};
+
+    // Parameters contain two joysticks return dual
+    if (params.Has("guid2")) {
+        const auto joystick2 = GetSDLJoystickByGUID(params.Get("guid2", ""), params.Get("port", 0));
+
+        if (joystick2->GetSDLGameController() != nullptr) {
+            return GetDualControllerMapping(joystick, joystick2, switch_to_sdl_button,
+                                            switch_to_sdl_axis);
+        }
+    }
+
+    return GetSingleControllerMapping(joystick, switch_to_sdl_button, switch_to_sdl_axis);
+}
+
+ButtonBindings SDLDriver::GetDefaultButtonBinding() const {
+    return {
+        std::pair{Settings::NativeButton::A, SDL_CONTROLLER_BUTTON_B},
+        {Settings::NativeButton::B, SDL_CONTROLLER_BUTTON_A},
+        {Settings::NativeButton::X, SDL_CONTROLLER_BUTTON_Y},
+        {Settings::NativeButton::Y, SDL_CONTROLLER_BUTTON_X},
+        {Settings::NativeButton::LStick, SDL_CONTROLLER_BUTTON_LEFTSTICK},
+        {Settings::NativeButton::RStick, SDL_CONTROLLER_BUTTON_RIGHTSTICK},
+        {Settings::NativeButton::L, SDL_CONTROLLER_BUTTON_LEFTSHOULDER},
+        {Settings::NativeButton::R, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER},
+        {Settings::NativeButton::Plus, SDL_CONTROLLER_BUTTON_START},
+        {Settings::NativeButton::Minus, SDL_CONTROLLER_BUTTON_BACK},
+        {Settings::NativeButton::DLeft, SDL_CONTROLLER_BUTTON_DPAD_LEFT},
+        {Settings::NativeButton::DUp, SDL_CONTROLLER_BUTTON_DPAD_UP},
+        {Settings::NativeButton::DRight, SDL_CONTROLLER_BUTTON_DPAD_RIGHT},
+        {Settings::NativeButton::DDown, SDL_CONTROLLER_BUTTON_DPAD_DOWN},
+        {Settings::NativeButton::SL, SDL_CONTROLLER_BUTTON_LEFTSHOULDER},
+        {Settings::NativeButton::SR, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER},
+        {Settings::NativeButton::Home, SDL_CONTROLLER_BUTTON_GUIDE},
+    };
+}
+
+ButtonBindings SDLDriver::GetNintendoButtonBinding(
+    const std::shared_ptr<SDLJoystick>& joystick) const {
+    // Default SL/SR mapping for pro controllers
+    auto sl_button = SDL_CONTROLLER_BUTTON_LEFTSHOULDER;
+    auto sr_button = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;
+
+    if (joystick->IsJoyconLeft()) {
+        sl_button = SDL_CONTROLLER_BUTTON_PADDLE2;
+        sr_button = SDL_CONTROLLER_BUTTON_PADDLE4;
+    }
+    if (joystick->IsJoyconRight()) {
+        sl_button = SDL_CONTROLLER_BUTTON_PADDLE3;
+        sr_button = SDL_CONTROLLER_BUTTON_PADDLE1;
+    }
+
+    return {
+        std::pair{Settings::NativeButton::A, SDL_CONTROLLER_BUTTON_A},
+        {Settings::NativeButton::B, SDL_CONTROLLER_BUTTON_B},
+        {Settings::NativeButton::X, SDL_CONTROLLER_BUTTON_X},
+        {Settings::NativeButton::Y, SDL_CONTROLLER_BUTTON_Y},
+        {Settings::NativeButton::LStick, SDL_CONTROLLER_BUTTON_LEFTSTICK},
+        {Settings::NativeButton::RStick, SDL_CONTROLLER_BUTTON_RIGHTSTICK},
+        {Settings::NativeButton::L, SDL_CONTROLLER_BUTTON_LEFTSHOULDER},
+        {Settings::NativeButton::R, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER},
+        {Settings::NativeButton::Plus, SDL_CONTROLLER_BUTTON_START},
+        {Settings::NativeButton::Minus, SDL_CONTROLLER_BUTTON_BACK},
+        {Settings::NativeButton::DLeft, SDL_CONTROLLER_BUTTON_DPAD_LEFT},
+        {Settings::NativeButton::DUp, SDL_CONTROLLER_BUTTON_DPAD_UP},
+        {Settings::NativeButton::DRight, SDL_CONTROLLER_BUTTON_DPAD_RIGHT},
+        {Settings::NativeButton::DDown, SDL_CONTROLLER_BUTTON_DPAD_DOWN},
+        {Settings::NativeButton::SL, sl_button},
+        {Settings::NativeButton::SR, sr_button},
+        {Settings::NativeButton::Home, SDL_CONTROLLER_BUTTON_GUIDE},
+    };
+}
+
+ButtonMapping SDLDriver::GetSingleControllerMapping(
+    const std::shared_ptr<SDLJoystick>& joystick, const ButtonBindings& switch_to_sdl_button,
+    const ZButtonBindings& switch_to_sdl_axis) const {
+    ButtonMapping mapping;
+    mapping.reserve(switch_to_sdl_button.size() + switch_to_sdl_axis.size());
+    auto* controller = joystick->GetSDLGameController();
+
+    for (const auto& [switch_button, sdl_button] : switch_to_sdl_button) {
+        const auto& binding = SDL_GameControllerGetBindForButton(controller, sdl_button);
+        mapping.insert_or_assign(
+            switch_button,
+            BuildParamPackageForBinding(joystick->GetPort(), joystick->GetGUID(), binding));
+    }
+    for (const auto& [switch_button, sdl_axis] : switch_to_sdl_axis) {
+        const auto& binding = SDL_GameControllerGetBindForAxis(controller, sdl_axis);
+        mapping.insert_or_assign(
+            switch_button,
+            BuildParamPackageForBinding(joystick->GetPort(), joystick->GetGUID(), binding));
+    }
+
+    return mapping;
+}
+
+ButtonMapping SDLDriver::GetDualControllerMapping(const std::shared_ptr<SDLJoystick>& joystick,
+                                                  const std::shared_ptr<SDLJoystick>& joystick2,
+                                                  const ButtonBindings& switch_to_sdl_button,
+                                                  const ZButtonBindings& switch_to_sdl_axis) const {
+    ButtonMapping mapping;
+    mapping.reserve(switch_to_sdl_button.size() + switch_to_sdl_axis.size());
+    auto* controller = joystick->GetSDLGameController();
+    auto* controller2 = joystick2->GetSDLGameController();
+
+    for (const auto& [switch_button, sdl_button] : switch_to_sdl_button) {
+        if (IsButtonOnLeftSide(switch_button)) {
+            const auto& binding = SDL_GameControllerGetBindForButton(controller2, sdl_button);
+            mapping.insert_or_assign(
+                switch_button,
+                BuildParamPackageForBinding(joystick2->GetPort(), joystick2->GetGUID(), binding));
+            continue;
+        }
+        const auto& binding = SDL_GameControllerGetBindForButton(controller, sdl_button);
+        mapping.insert_or_assign(
+            switch_button,
+            BuildParamPackageForBinding(joystick->GetPort(), joystick->GetGUID(), binding));
+    }
+    for (const auto& [switch_button, sdl_axis] : switch_to_sdl_axis) {
+        if (IsButtonOnLeftSide(switch_button)) {
+            const auto& binding = SDL_GameControllerGetBindForAxis(controller2, sdl_axis);
+            mapping.insert_or_assign(
+                switch_button,
+                BuildParamPackageForBinding(joystick2->GetPort(), joystick2->GetGUID(), binding));
+            continue;
+        }
+        const auto& binding = SDL_GameControllerGetBindForAxis(controller, sdl_axis);
+        mapping.insert_or_assign(
+            switch_button,
+            BuildParamPackageForBinding(joystick->GetPort(), joystick->GetGUID(), binding));
+    }
+
+    return mapping;
+}
+
+bool SDLDriver::IsButtonOnLeftSide(Settings::NativeButton::Values button) const {
+    switch (button) {
+    case Settings::NativeButton::DDown:
+    case Settings::NativeButton::DLeft:
+    case Settings::NativeButton::DRight:
+    case Settings::NativeButton::DUp:
+    case Settings::NativeButton::L:
+    case Settings::NativeButton::LStick:
+    case Settings::NativeButton::Minus:
+    case Settings::NativeButton::Screenshot:
+    case Settings::NativeButton::ZL:
+        return true;
+    default:
+        return false;
+    }
+}
+
+AnalogMapping SDLDriver::GetAnalogMappingForDevice(const Common::ParamPackage& params) {
+    if (!params.Has("guid") || !params.Has("port")) {
+        return {};
+    }
+    const auto joystick = GetSDLJoystickByGUID(params.Get("guid", ""), params.Get("port", 0));
+    const auto joystick2 = GetSDLJoystickByGUID(params.Get("guid2", ""), params.Get("port", 0));
+    auto* controller = joystick->GetSDLGameController();
+    if (controller == nullptr) {
+        return {};
+    }
+
+    AnalogMapping mapping = {};
+    const auto& binding_left_x =
+        SDL_GameControllerGetBindForAxis(controller, SDL_CONTROLLER_AXIS_LEFTX);
+    const auto& binding_left_y =
+        SDL_GameControllerGetBindForAxis(controller, SDL_CONTROLLER_AXIS_LEFTY);
+    if (params.Has("guid2")) {
+        const auto identifier = joystick2->GetPadIdentifier();
+        PreSetController(identifier);
+        PreSetAxis(identifier, binding_left_x.value.axis);
+        PreSetAxis(identifier, binding_left_y.value.axis);
+        const auto left_offset_x = -GetAxis(identifier, binding_left_x.value.axis);
+        const auto left_offset_y = -GetAxis(identifier, binding_left_y.value.axis);
+        mapping.insert_or_assign(Settings::NativeAnalog::LStick,
+                                 BuildParamPackageForAnalog(identifier, binding_left_x.value.axis,
+                                                            binding_left_y.value.axis,
+                                                            left_offset_x, left_offset_y));
+    } else {
+        const auto identifier = joystick->GetPadIdentifier();
+        PreSetController(identifier);
+        PreSetAxis(identifier, binding_left_x.value.axis);
+        PreSetAxis(identifier, binding_left_y.value.axis);
+        const auto left_offset_x = -GetAxis(identifier, binding_left_x.value.axis);
+        const auto left_offset_y = -GetAxis(identifier, binding_left_y.value.axis);
+        mapping.insert_or_assign(Settings::NativeAnalog::LStick,
+                                 BuildParamPackageForAnalog(identifier, binding_left_x.value.axis,
+                                                            binding_left_y.value.axis,
+                                                            left_offset_x, left_offset_y));
+    }
+    const auto& binding_right_x =
+        SDL_GameControllerGetBindForAxis(controller, SDL_CONTROLLER_AXIS_RIGHTX);
+    const auto& binding_right_y =
+        SDL_GameControllerGetBindForAxis(controller, SDL_CONTROLLER_AXIS_RIGHTY);
+    const auto identifier = joystick->GetPadIdentifier();
+    PreSetController(identifier);
+    PreSetAxis(identifier, binding_right_x.value.axis);
+    PreSetAxis(identifier, binding_right_y.value.axis);
+    const auto right_offset_x = -GetAxis(identifier, binding_right_x.value.axis);
+    const auto right_offset_y = -GetAxis(identifier, binding_right_y.value.axis);
+    mapping.insert_or_assign(Settings::NativeAnalog::RStick,
+                             BuildParamPackageForAnalog(identifier, binding_right_x.value.axis,
+                                                        binding_right_y.value.axis, right_offset_x,
+                                                        right_offset_y));
+    return mapping;
+}
+
+MotionMapping SDLDriver::GetMotionMappingForDevice(const Common::ParamPackage& params) {
+    if (!params.Has("guid") || !params.Has("port")) {
+        return {};
+    }
+    const auto joystick = GetSDLJoystickByGUID(params.Get("guid", ""), params.Get("port", 0));
+    const auto joystick2 = GetSDLJoystickByGUID(params.Get("guid2", ""), params.Get("port", 0));
+    auto* controller = joystick->GetSDLGameController();
+    if (controller == nullptr) {
+        return {};
+    }
+
+    MotionMapping mapping = {};
+    joystick->EnableMotion();
+
+    if (joystick->HasGyro() || joystick->HasAccel()) {
+        mapping.insert_or_assign(Settings::NativeMotion::MotionRight,
+                                 BuildMotionParam(joystick->GetPort(), joystick->GetGUID()));
+    }
+    if (params.Has("guid2")) {
+        joystick2->EnableMotion();
+        if (joystick2->HasGyro() || joystick2->HasAccel()) {
+            mapping.insert_or_assign(Settings::NativeMotion::MotionLeft,
+                                     BuildMotionParam(joystick2->GetPort(), joystick2->GetGUID()));
+        }
+    } else {
+        if (joystick->HasGyro() || joystick->HasAccel()) {
+            mapping.insert_or_assign(Settings::NativeMotion::MotionLeft,
+                                     BuildMotionParam(joystick->GetPort(), joystick->GetGUID()));
+        }
+    }
+
+    return mapping;
+}
+
+std::string SDLDriver::GetUIName(const Common::ParamPackage& params) const {
+    if (params.Has("button")) {
+        // TODO(German77): Find how to substitue the values for real button names
+        return fmt::format("Button {}", params.Get("button", 0));
+    }
+    if (params.Has("hat")) {
+        return fmt::format("Hat {}", params.Get("direction", ""));
+    }
+    if (params.Has("axis")) {
+        return fmt::format("Axis {}", params.Get("axis", ""));
+    }
+    if (params.Has("axis_x") && params.Has("axis_y") && params.Has("axis_z")) {
+        return fmt::format("Axis {},{},{}", params.Get("axis_x", ""), params.Get("axis_y", ""),
+                           params.Get("axis_z", ""));
+    }
+    if (params.Has("motion")) {
+        return "SDL motion";
+    }
+
+    return "Bad SDL";
+}
+
+std::string SDLDriver::GetHatButtonName(u8 direction_value) const {
+    switch (direction_value) {
+    case SDL_HAT_UP:
+        return "up";
+    case SDL_HAT_DOWN:
+        return "down";
+    case SDL_HAT_LEFT:
+        return "left";
+    case SDL_HAT_RIGHT:
+        return "right";
+    default:
+        return {};
+    }
+}
+
+u8 SDLDriver::GetHatButtonId(const std::string direction_name) const {
+    Uint8 direction;
+    if (direction_name == "up") {
+        direction = SDL_HAT_UP;
+    } else if (direction_name == "down") {
+        direction = SDL_HAT_DOWN;
+    } else if (direction_name == "left") {
+        direction = SDL_HAT_LEFT;
+    } else if (direction_name == "right") {
+        direction = SDL_HAT_RIGHT;
+    } else {
+        direction = 0;
+    }
+    return direction;
+}
+
+} // namespace InputCommon
diff --git a/src/input_common/sdl/sdl_impl.h b/src/input_common/drivers/sdl_driver.h
index 7a9ad6346..d8d350184 100644
--- a/src/input_common/sdl/sdl_impl.h
+++ b/src/input_common/drivers/sdl_driver.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include <atomic>
-#include <memory>
 #include <mutex>
 #include <thread>
 #include <unordered_map>
@@ -13,8 +12,7 @@
 #include <SDL.h>
 
 #include "common/common_types.h"
-#include "common/threadsafe_queue.h"
-#include "input_common/sdl/sdl.h"
+#include "input_common/input_engine.h"
 
 union SDL_Event;
 using SDL_GameController = struct _SDL_GameController;
@@ -26,21 +24,17 @@ using ButtonBindings =
 using ZButtonBindings =
     std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerAxis>, 2>;
 
-namespace InputCommon::SDL {
+namespace InputCommon {
 
-class SDLAnalogFactory;
-class SDLButtonFactory;
-class SDLMotionFactory;
-class SDLVibrationFactory;
 class SDLJoystick;
 
-class SDLState : public State {
+class SDLDriver : public InputCommon::InputEngine {
 public:
     /// Initializes and registers SDL device factories
-    SDLState();
+    SDLDriver(const std::string& input_engine_);
 
     /// Unregisters SDL device factories and shut them down.
-    ~SDLState() override;
+    ~SDLDriver() override;
 
     /// Handle SDL_Events for joysticks from SDL_PollEvent
     void HandleGameControllerEvent(const SDL_Event& event);
@@ -54,18 +48,18 @@ public:
      */
     std::shared_ptr<SDLJoystick> GetSDLJoystickByGUID(const std::string& guid, int port);
 
-    /// Get all DevicePoller that use the SDL backend for a specific device type
-    Pollers GetPollers(Polling::DeviceType type) override;
-
-    /// Used by the Pollers during config
-    std::atomic<bool> polling = false;
-    Common::SPSCQueue<SDL_Event> event_queue;
-
-    std::vector<Common::ParamPackage> GetInputDevices() override;
+    std::vector<Common::ParamPackage> GetInputDevices() const override;
 
     ButtonMapping GetButtonMappingForDevice(const Common::ParamPackage& params) override;
     AnalogMapping GetAnalogMappingForDevice(const Common::ParamPackage& params) override;
     MotionMapping GetMotionMappingForDevice(const Common::ParamPackage& params) override;
+    std::string GetUIName(const Common::ParamPackage& params) const override;
+
+    std::string GetHatButtonName(u8 direction_value) const override;
+    u8 GetHatButtonId(const std::string direction_name) const override;
+
+    bool SetRumble(const PadIdentifier& identifier,
+                   const Input::VibrationStatus vibration) override;
 
 private:
     void InitJoystick(int joystick_index);
@@ -74,6 +68,23 @@ private:
     /// Needs to be called before SDL_QuitSubSystem.
     void CloseJoysticks();
 
+    Common::ParamPackage BuildAnalogParamPackageForButton(int port, std::string guid, s32 axis,
+                                                          float value = 0.1f) const;
+    Common::ParamPackage BuildButtonParamPackageForButton(int port, std::string guid,
+                                                          s32 button) const;
+
+    Common::ParamPackage BuildHatParamPackageForButton(int port, std::string guid, s32 hat,
+                                                       u8 value) const;
+
+    Common::ParamPackage BuildMotionParam(int port, std::string guid) const;
+
+    Common::ParamPackage BuildParamPackageForBinding(
+        int port, const std::string& guid, const SDL_GameControllerButtonBind& binding) const;
+
+    Common::ParamPackage BuildParamPackageForAnalog(PadIdentifier identifier, int axis_x,
+                                                    int axis_y, float offset_x,
+                                                    float offset_y) const;
+
     /// Returns the default button bindings list for generic controllers
     ButtonBindings GetDefaultButtonBinding() const;
 
@@ -101,14 +112,9 @@ private:
     std::unordered_map<std::string, std::vector<std::shared_ptr<SDLJoystick>>> joystick_map;
     std::mutex joystick_map_mutex;
 
-    std::shared_ptr<SDLButtonFactory> button_factory;
-    std::shared_ptr<SDLAnalogFactory> analog_factory;
-    std::shared_ptr<SDLVibrationFactory> vibration_factory;
-    std::shared_ptr<SDLMotionFactory> motion_factory;
-
     bool start_thread = false;
     std::atomic<bool> initialized = false;
 
     std::thread poll_thread;
 };
-} // namespace InputCommon::SDL
+} // namespace InputCommon
diff --git a/src/input_common/sdl/sdl.cpp b/src/input_common/sdl/sdl.cpp
deleted file mode 100644
index 644db3448..000000000
--- a/src/input_common/sdl/sdl.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2018 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "input_common/sdl/sdl.h"
-#ifdef HAVE_SDL2
-#include "input_common/sdl/sdl_impl.h"
-#endif
-
-namespace InputCommon::SDL {
-
-std::unique_ptr<State> Init() {
-#ifdef HAVE_SDL2
-    return std::make_unique<SDLState>();
-#else
-    return std::make_unique<NullState>();
-#endif
-}
-} // namespace InputCommon::SDL
diff --git a/src/input_common/sdl/sdl.h b/src/input_common/sdl/sdl.h
deleted file mode 100644
index b5d41bba4..000000000
--- a/src/input_common/sdl/sdl.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2018 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <vector>
-#include "common/param_package.h"
-#include "input_common/main.h"
-
-namespace InputCommon::Polling {
-class DevicePoller;
-enum class DeviceType;
-} // namespace InputCommon::Polling
-
-namespace InputCommon::SDL {
-
-class State {
-public:
-    using Pollers = std::vector<std::unique_ptr<Polling::DevicePoller>>;
-
-    /// Unregisters SDL device factories and shut them down.
-    virtual ~State() = default;
-
-    virtual Pollers GetPollers(Polling::DeviceType) {
-        return {};
-    }
-
-    virtual std::vector<Common::ParamPackage> GetInputDevices() {
-        return {};
-    }
-
-    virtual ButtonMapping GetButtonMappingForDevice(const Common::ParamPackage&) {
-        return {};
-    }
-    virtual AnalogMapping GetAnalogMappingForDevice(const Common::ParamPackage&) {
-        return {};
-    }
-    virtual MotionMapping GetMotionMappingForDevice(const Common::ParamPackage&) {
-        return {};
-    }
-};
-
-class NullState : public State {
-public:
-};
-
-std::unique_ptr<State> Init();
-
-} // namespace InputCommon::SDL
diff --git a/src/input_common/sdl/sdl_impl.cpp b/src/input_common/sdl/sdl_impl.cpp
deleted file mode 100644
index ecb00d428..000000000
--- a/src/input_common/sdl/sdl_impl.cpp
+++ /dev/null
@@ -1,1658 +0,0 @@
-// Copyright 2018 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <chrono>
-#include <cmath>
-#include <functional>
-#include <mutex>
-#include <optional>
-#include <sstream>
-#include <string>
-#include <thread>
-#include <tuple>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "common/logging/log.h"
-#include "common/math_util.h"
-#include "common/param_package.h"
-#include "common/settings.h"
-#include "common/threadsafe_queue.h"
-#include "core/frontend/input.h"
-#include "input_common/motion_input.h"
-#include "input_common/sdl/sdl_impl.h"
-
-namespace InputCommon::SDL {
-
-namespace {
-std::string GetGUID(SDL_Joystick* joystick) {
-    const SDL_JoystickGUID guid = SDL_JoystickGetGUID(joystick);
-    char guid_str[33];
-    SDL_JoystickGetGUIDString(guid, guid_str, sizeof(guid_str));
-    return guid_str;
-}
-
-/// Creates a ParamPackage from an SDL_Event that can directly be used to create a ButtonDevice
-Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const SDL_Event& event);
-} // Anonymous namespace
-
-static int SDLEventWatcher(void* user_data, SDL_Event* event) {
-    auto* const sdl_state = static_cast<SDLState*>(user_data);
-
-    // Don't handle the event if we are configuring
-    if (sdl_state->polling) {
-        sdl_state->event_queue.Push(*event);
-    } else {
-        sdl_state->HandleGameControllerEvent(*event);
-    }
-
-    return 0;
-}
-
-class SDLJoystick {
-public:
-    SDLJoystick(std::string guid_, int port_, SDL_Joystick* joystick,
-                SDL_GameController* game_controller)
-        : guid{std::move(guid_)}, port{port_}, sdl_joystick{joystick, &SDL_JoystickClose},
-          sdl_controller{game_controller, &SDL_GameControllerClose} {
-        EnableMotion();
-    }
-
-    void EnableMotion() {
-        if (sdl_controller) {
-            SDL_GameController* controller = sdl_controller.get();
-            if (SDL_GameControllerHasSensor(controller, SDL_SENSOR_ACCEL) && !has_accel) {
-                SDL_GameControllerSetSensorEnabled(controller, SDL_SENSOR_ACCEL, SDL_TRUE);
-                has_accel = true;
-            }
-            if (SDL_GameControllerHasSensor(controller, SDL_SENSOR_GYRO) && !has_gyro) {
-                SDL_GameControllerSetSensorEnabled(controller, SDL_SENSOR_GYRO, SDL_TRUE);
-                has_gyro = true;
-            }
-        }
-    }
-
-    void SetButton(int button, bool value) {
-        std::lock_guard lock{mutex};
-        state.buttons.insert_or_assign(button, value);
-    }
-
-    void PreSetButton(int button) {
-        if (!state.buttons.contains(button)) {
-            SetButton(button, false);
-        }
-    }
-
-    void SetMotion(SDL_ControllerSensorEvent event) {
-        constexpr float gravity_constant = 9.80665f;
-        std::lock_guard lock{mutex};
-        u64 time_difference = event.timestamp - last_motion_update;
-        last_motion_update = event.timestamp;
-        switch (event.sensor) {
-        case SDL_SENSOR_ACCEL: {
-            const Common::Vec3f acceleration = {-event.data[0], event.data[2], -event.data[1]};
-            motion.SetAcceleration(acceleration / gravity_constant);
-            break;
-        }
-        case SDL_SENSOR_GYRO: {
-            const Common::Vec3f gyroscope = {event.data[0], -event.data[2], event.data[1]};
-            motion.SetGyroscope(gyroscope / (Common::PI * 2));
-            break;
-        }
-        }
-
-        // Ignore duplicated timestamps
-        if (time_difference == 0) {
-            return;
-        }
-
-        motion.SetGyroThreshold(0.0001f);
-        motion.UpdateRotation(time_difference * 1000);
-        motion.UpdateOrientation(time_difference * 1000);
-    }
-
-    bool GetButton(int button) const {
-        std::lock_guard lock{mutex};
-        return state.buttons.at(button);
-    }
-
-    bool ToggleButton(int button) {
-        std::lock_guard lock{mutex};
-
-        if (!state.toggle_buttons.contains(button) || !state.lock_buttons.contains(button)) {
-            state.toggle_buttons.insert_or_assign(button, false);
-            state.lock_buttons.insert_or_assign(button, false);
-        }
-
-        const bool button_state = state.toggle_buttons.at(button);
-        const bool button_lock = state.lock_buttons.at(button);
-
-        if (button_lock) {
-            return button_state;
-        }
-
-        state.lock_buttons.insert_or_assign(button, true);
-
-        if (button_state) {
-            state.toggle_buttons.insert_or_assign(button, false);
-        } else {
-            state.toggle_buttons.insert_or_assign(button, true);
-        }
-
-        return !button_state;
-    }
-
-    bool UnlockButton(int button) {
-        std::lock_guard lock{mutex};
-        if (!state.toggle_buttons.contains(button)) {
-            return false;
-        }
-        state.lock_buttons.insert_or_assign(button, false);
-        return state.toggle_buttons.at(button);
-    }
-
-    void SetAxis(int axis, Sint16 value) {
-        std::lock_guard lock{mutex};
-        state.axes.insert_or_assign(axis, value);
-    }
-
-    void PreSetAxis(int axis) {
-        if (!state.axes.contains(axis)) {
-            SetAxis(axis, 0);
-        }
-    }
-
-    float GetAxis(int axis, float range, float offset) const {
-        std::lock_guard lock{mutex};
-        const float value = static_cast<float>(state.axes.at(axis)) / 32767.0f;
-        const float offset_scale = (value + offset) > 0.0f ? 1.0f + offset : 1.0f - offset;
-        return (value + offset) / range / offset_scale;
-    }
-
-    bool RumblePlay(u16 amp_low, u16 amp_high) {
-        constexpr u32 rumble_max_duration_ms = 1000;
-
-        if (sdl_controller) {
-            return SDL_GameControllerRumble(sdl_controller.get(), amp_low, amp_high,
-                                            rumble_max_duration_ms) != -1;
-        } else if (sdl_joystick) {
-            return SDL_JoystickRumble(sdl_joystick.get(), amp_low, amp_high,
-                                      rumble_max_duration_ms) != -1;
-        }
-
-        return false;
-    }
-
-    std::tuple<float, float> GetAnalog(int axis_x, int axis_y, float range, float offset_x,
-                                       float offset_y) const {
-        float x = GetAxis(axis_x, range, offset_x);
-        float y = GetAxis(axis_y, range, offset_y);
-        y = -y; // 3DS uses an y-axis inverse from SDL
-
-        // 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);
-    }
-
-    bool HasGyro() const {
-        return has_gyro;
-    }
-
-    bool HasAccel() const {
-        return has_accel;
-    }
-
-    const MotionInput& GetMotion() const {
-        return motion;
-    }
-
-    void SetHat(int hat, Uint8 direction) {
-        std::lock_guard lock{mutex};
-        state.hats.insert_or_assign(hat, direction);
-    }
-
-    bool GetHatDirection(int hat, Uint8 direction) const {
-        std::lock_guard lock{mutex};
-        return (state.hats.at(hat) & direction) != 0;
-    }
-    /**
-     * The guid of the joystick
-     */
-    const std::string& GetGUID() const {
-        return guid;
-    }
-
-    /**
-     * The number of joystick from the same type that were connected before this joystick
-     */
-    int GetPort() const {
-        return port;
-    }
-
-    SDL_Joystick* GetSDLJoystick() const {
-        return sdl_joystick.get();
-    }
-
-    SDL_GameController* GetSDLGameController() const {
-        return sdl_controller.get();
-    }
-
-    void SetSDLJoystick(SDL_Joystick* joystick, SDL_GameController* controller) {
-        sdl_joystick.reset(joystick);
-        sdl_controller.reset(controller);
-    }
-
-    bool IsJoyconLeft() const {
-        const std::string controller_name = GetControllerName();
-        if (std::strstr(controller_name.c_str(), "Joy-Con Left") != nullptr) {
-            return true;
-        }
-        if (std::strstr(controller_name.c_str(), "Joy-Con (L)") != nullptr) {
-            return true;
-        }
-        return false;
-    }
-
-    bool IsJoyconRight() const {
-        const std::string controller_name = GetControllerName();
-        if (std::strstr(controller_name.c_str(), "Joy-Con Right") != nullptr) {
-            return true;
-        }
-        if (std::strstr(controller_name.c_str(), "Joy-Con (R)") != nullptr) {
-            return true;
-        }
-        return false;
-    }
-
-    std::string GetControllerName() const {
-        if (sdl_controller) {
-            switch (SDL_GameControllerGetType(sdl_controller.get())) {
-            case SDL_CONTROLLER_TYPE_XBOX360:
-                return "XBox 360 Controller";
-            case SDL_CONTROLLER_TYPE_XBOXONE:
-                return "XBox One Controller";
-            default:
-                break;
-            }
-            const auto name = SDL_GameControllerName(sdl_controller.get());
-            if (name) {
-                return name;
-            }
-        }
-
-        if (sdl_joystick) {
-            const auto name = SDL_JoystickName(sdl_joystick.get());
-            if (name) {
-                return name;
-            }
-        }
-
-        return "Unknown";
-    }
-
-private:
-    struct State {
-        std::unordered_map<int, bool> buttons;
-        std::unordered_map<int, bool> toggle_buttons{};
-        std::unordered_map<int, bool> lock_buttons{};
-        std::unordered_map<int, Sint16> axes;
-        std::unordered_map<int, Uint8> hats;
-    } state;
-    std::string guid;
-    int port;
-    std::unique_ptr<SDL_Joystick, decltype(&SDL_JoystickClose)> sdl_joystick;
-    std::unique_ptr<SDL_GameController, decltype(&SDL_GameControllerClose)> sdl_controller;
-    mutable std::mutex mutex;
-
-    // Motion is initialized with the PID values
-    MotionInput motion{0.3f, 0.005f, 0.0f};
-    u64 last_motion_update{};
-    bool has_gyro{false};
-    bool has_accel{false};
-};
-
-std::shared_ptr<SDLJoystick> SDLState::GetSDLJoystickByGUID(const std::string& guid, int port) {
-    std::lock_guard lock{joystick_map_mutex};
-    const auto it = joystick_map.find(guid);
-
-    if (it != joystick_map.end()) {
-        while (it->second.size() <= static_cast<std::size_t>(port)) {
-            auto joystick = std::make_shared<SDLJoystick>(guid, static_cast<int>(it->second.size()),
-                                                          nullptr, nullptr);
-            it->second.emplace_back(std::move(joystick));
-        }
-
-        return it->second[static_cast<std::size_t>(port)];
-    }
-
-    auto joystick = std::make_shared<SDLJoystick>(guid, 0, nullptr, nullptr);
-
-    return joystick_map[guid].emplace_back(std::move(joystick));
-}
-
-std::shared_ptr<SDLJoystick> SDLState::GetSDLJoystickBySDLID(SDL_JoystickID sdl_id) {
-    auto sdl_joystick = SDL_JoystickFromInstanceID(sdl_id);
-    const std::string guid = GetGUID(sdl_joystick);
-
-    std::lock_guard lock{joystick_map_mutex};
-    const auto map_it = joystick_map.find(guid);
-
-    if (map_it == joystick_map.end()) {
-        return nullptr;
-    }
-
-    const auto vec_it = std::find_if(map_it->second.begin(), map_it->second.end(),
-                                     [&sdl_joystick](const auto& joystick) {
-                                         return joystick->GetSDLJoystick() == sdl_joystick;
-                                     });
-
-    if (vec_it == map_it->second.end()) {
-        return nullptr;
-    }
-
-    return *vec_it;
-}
-
-void SDLState::InitJoystick(int joystick_index) {
-    SDL_Joystick* sdl_joystick = SDL_JoystickOpen(joystick_index);
-    SDL_GameController* sdl_gamecontroller = nullptr;
-
-    if (SDL_IsGameController(joystick_index)) {
-        sdl_gamecontroller = SDL_GameControllerOpen(joystick_index);
-    }
-
-    if (!sdl_joystick) {
-        LOG_ERROR(Input, "Failed to open joystick {}", joystick_index);
-        return;
-    }
-
-    const std::string guid = GetGUID(sdl_joystick);
-
-    std::lock_guard lock{joystick_map_mutex};
-    if (joystick_map.find(guid) == joystick_map.end()) {
-        auto joystick = std::make_shared<SDLJoystick>(guid, 0, sdl_joystick, sdl_gamecontroller);
-        joystick_map[guid].emplace_back(std::move(joystick));
-        return;
-    }
-
-    auto& joystick_guid_list = joystick_map[guid];
-    const auto joystick_it =
-        std::find_if(joystick_guid_list.begin(), joystick_guid_list.end(),
-                     [](const auto& joystick) { return !joystick->GetSDLJoystick(); });
-
-    if (joystick_it != joystick_guid_list.end()) {
-        (*joystick_it)->SetSDLJoystick(sdl_joystick, sdl_gamecontroller);
-        return;
-    }
-
-    const int port = static_cast<int>(joystick_guid_list.size());
-    auto joystick = std::make_shared<SDLJoystick>(guid, port, sdl_joystick, sdl_gamecontroller);
-    joystick_guid_list.emplace_back(std::move(joystick));
-}
-
-void SDLState::CloseJoystick(SDL_Joystick* sdl_joystick) {
-    const std::string guid = GetGUID(sdl_joystick);
-
-    std::lock_guard lock{joystick_map_mutex};
-    // This call to guid is safe since the joystick is guaranteed to be in the map
-    const auto& joystick_guid_list = joystick_map[guid];
-    const auto joystick_it = std::find_if(joystick_guid_list.begin(), joystick_guid_list.end(),
-                                          [&sdl_joystick](const auto& joystick) {
-                                              return joystick->GetSDLJoystick() == sdl_joystick;
-                                          });
-
-    if (joystick_it != joystick_guid_list.end()) {
-        (*joystick_it)->SetSDLJoystick(nullptr, nullptr);
-    }
-}
-
-void SDLState::HandleGameControllerEvent(const SDL_Event& event) {
-    switch (event.type) {
-    case SDL_JOYBUTTONUP: {
-        if (auto joystick = GetSDLJoystickBySDLID(event.jbutton.which)) {
-            joystick->SetButton(event.jbutton.button, false);
-        }
-        break;
-    }
-    case SDL_JOYBUTTONDOWN: {
-        if (auto joystick = GetSDLJoystickBySDLID(event.jbutton.which)) {
-            joystick->SetButton(event.jbutton.button, true);
-        }
-        break;
-    }
-    case SDL_JOYHATMOTION: {
-        if (auto joystick = GetSDLJoystickBySDLID(event.jhat.which)) {
-            joystick->SetHat(event.jhat.hat, event.jhat.value);
-        }
-        break;
-    }
-    case SDL_JOYAXISMOTION: {
-        if (auto joystick = GetSDLJoystickBySDLID(event.jaxis.which)) {
-            joystick->SetAxis(event.jaxis.axis, event.jaxis.value);
-        }
-        break;
-    }
-    case SDL_CONTROLLERSENSORUPDATE: {
-        if (auto joystick = GetSDLJoystickBySDLID(event.csensor.which)) {
-            joystick->SetMotion(event.csensor);
-        }
-        break;
-    }
-    case SDL_JOYDEVICEREMOVED:
-        LOG_DEBUG(Input, "Controller removed with Instance_ID {}", event.jdevice.which);
-        CloseJoystick(SDL_JoystickFromInstanceID(event.jdevice.which));
-        break;
-    case SDL_JOYDEVICEADDED:
-        LOG_DEBUG(Input, "Controller connected with device index {}", event.jdevice.which);
-        InitJoystick(event.jdevice.which);
-        break;
-    }
-}
-
-void SDLState::CloseJoysticks() {
-    std::lock_guard lock{joystick_map_mutex};
-    joystick_map.clear();
-}
-
-class SDLButton final : public Input::ButtonDevice {
-public:
-    explicit SDLButton(std::shared_ptr<SDLJoystick> joystick_, int button_, bool toggle_)
-        : joystick(std::move(joystick_)), button(button_), toggle(toggle_) {}
-
-    bool GetStatus() const override {
-        const bool button_state = joystick->GetButton(button);
-        if (!toggle) {
-            return button_state;
-        }
-
-        if (button_state) {
-            return joystick->ToggleButton(button);
-        }
-        return joystick->UnlockButton(button);
-    }
-
-private:
-    std::shared_ptr<SDLJoystick> joystick;
-    int button;
-    bool toggle;
-};
-
-class SDLDirectionButton final : public Input::ButtonDevice {
-public:
-    explicit SDLDirectionButton(std::shared_ptr<SDLJoystick> joystick_, int hat_, Uint8 direction_)
-        : joystick(std::move(joystick_)), hat(hat_), direction(direction_) {}
-
-    bool GetStatus() const override {
-        return joystick->GetHatDirection(hat, direction);
-    }
-
-private:
-    std::shared_ptr<SDLJoystick> joystick;
-    int hat;
-    Uint8 direction;
-};
-
-class SDLAxisButton final : public Input::ButtonDevice {
-public:
-    explicit SDLAxisButton(std::shared_ptr<SDLJoystick> joystick_, int axis_, float threshold_,
-                           bool trigger_if_greater_)
-        : joystick(std::move(joystick_)), axis(axis_), threshold(threshold_),
-          trigger_if_greater(trigger_if_greater_) {}
-
-    bool GetStatus() const override {
-        const float axis_value = joystick->GetAxis(axis, 1.0f, 0.0f);
-        if (trigger_if_greater) {
-            return axis_value > threshold;
-        }
-        return axis_value < threshold;
-    }
-
-private:
-    std::shared_ptr<SDLJoystick> joystick;
-    int axis;
-    float threshold;
-    bool trigger_if_greater;
-};
-
-class SDLAnalog final : public Input::AnalogDevice {
-public:
-    explicit SDLAnalog(std::shared_ptr<SDLJoystick> joystick_, int axis_x_, int axis_y_,
-                       bool invert_x_, bool invert_y_, float deadzone_, float range_,
-                       float offset_x_, float offset_y_)
-        : joystick(std::move(joystick_)), axis_x(axis_x_), axis_y(axis_y_), invert_x(invert_x_),
-          invert_y(invert_y_), deadzone(deadzone_), range(range_), offset_x(offset_x_),
-          offset_y(offset_y_) {}
-
-    std::tuple<float, float> GetStatus() const override {
-        auto [x, y] = joystick->GetAnalog(axis_x, axis_y, range, offset_x, offset_y);
-        const float r = std::sqrt((x * x) + (y * y));
-        if (invert_x) {
-            x = -x;
-        }
-        if (invert_y) {
-            y = -y;
-        }
-
-        if (r > deadzone) {
-            return std::make_tuple(x / r * (r - deadzone) / (1 - deadzone),
-                                   y / r * (r - deadzone) / (1 - deadzone));
-        }
-        return {};
-    }
-
-    std::tuple<float, float> GetRawStatus() const override {
-        const float x = joystick->GetAxis(axis_x, range, offset_x);
-        const float y = joystick->GetAxis(axis_y, range, offset_y);
-        return {x, -y};
-    }
-
-    Input::AnalogProperties GetAnalogProperties() const override {
-        return {deadzone, range, 0.5f};
-    }
-
-    bool GetAnalogDirectionStatus(Input::AnalogDirection direction) const override {
-        const auto [x, y] = GetStatus();
-        const float directional_deadzone = 0.5f;
-        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:
-    std::shared_ptr<SDLJoystick> joystick;
-    const int axis_x;
-    const int axis_y;
-    const bool invert_x;
-    const bool invert_y;
-    const float deadzone;
-    const float range;
-    const float offset_x;
-    const float offset_y;
-};
-
-class SDLVibration final : public Input::VibrationDevice {
-public:
-    explicit SDLVibration(std::shared_ptr<SDLJoystick> joystick_)
-        : joystick(std::move(joystick_)) {}
-
-    u8 GetStatus() const override {
-        joystick->RumblePlay(1, 1);
-        return joystick->RumblePlay(0, 0);
-    }
-
-    bool SetRumblePlay(f32 amp_low, [[maybe_unused]] f32 freq_low, f32 amp_high,
-                       [[maybe_unused]] f32 freq_high) const override {
-        const auto process_amplitude = [](f32 amplitude) {
-            return static_cast<u16>((amplitude + std::pow(amplitude, 0.3f)) * 0.5f * 0xFFFF);
-        };
-
-        const auto processed_amp_low = process_amplitude(amp_low);
-        const auto processed_amp_high = process_amplitude(amp_high);
-
-        return joystick->RumblePlay(processed_amp_low, processed_amp_high);
-    }
-
-private:
-    std::shared_ptr<SDLJoystick> joystick;
-};
-
-class SDLMotion final : public Input::MotionDevice {
-public:
-    explicit SDLMotion(std::shared_ptr<SDLJoystick> joystick_) : joystick(std::move(joystick_)) {}
-
-    Input::MotionStatus GetStatus() const override {
-        return joystick->GetMotion().GetMotion();
-    }
-
-private:
-    std::shared_ptr<SDLJoystick> joystick;
-};
-
-class SDLDirectionMotion final : public Input::MotionDevice {
-public:
-    explicit SDLDirectionMotion(std::shared_ptr<SDLJoystick> joystick_, int hat_, Uint8 direction_)
-        : joystick(std::move(joystick_)), hat(hat_), direction(direction_) {}
-
-    Input::MotionStatus GetStatus() const override {
-        if (joystick->GetHatDirection(hat, direction)) {
-            return joystick->GetMotion().GetRandomMotion(2, 6);
-        }
-        return joystick->GetMotion().GetRandomMotion(0, 0);
-    }
-
-private:
-    std::shared_ptr<SDLJoystick> joystick;
-    int hat;
-    Uint8 direction;
-};
-
-class SDLAxisMotion final : public Input::MotionDevice {
-public:
-    explicit SDLAxisMotion(std::shared_ptr<SDLJoystick> joystick_, int axis_, float threshold_,
-                           bool trigger_if_greater_)
-        : joystick(std::move(joystick_)), axis(axis_), threshold(threshold_),
-          trigger_if_greater(trigger_if_greater_) {}
-
-    Input::MotionStatus GetStatus() const override {
-        const float axis_value = joystick->GetAxis(axis, 1.0f, 0.0f);
-        bool trigger = axis_value < threshold;
-        if (trigger_if_greater) {
-            trigger = axis_value > threshold;
-        }
-
-        if (trigger) {
-            return joystick->GetMotion().GetRandomMotion(2, 6);
-        }
-        return joystick->GetMotion().GetRandomMotion(0, 0);
-    }
-
-private:
-    std::shared_ptr<SDLJoystick> joystick;
-    int axis;
-    float threshold;
-    bool trigger_if_greater;
-};
-
-class SDLButtonMotion final : public Input::MotionDevice {
-public:
-    explicit SDLButtonMotion(std::shared_ptr<SDLJoystick> joystick_, int button_)
-        : joystick(std::move(joystick_)), button(button_) {}
-
-    Input::MotionStatus GetStatus() const override {
-        if (joystick->GetButton(button)) {
-            return joystick->GetMotion().GetRandomMotion(2, 6);
-        }
-        return joystick->GetMotion().GetRandomMotion(0, 0);
-    }
-
-private:
-    std::shared_ptr<SDLJoystick> joystick;
-    int button;
-};
-
-/// A button device factory that creates button devices from SDL joystick
-class SDLButtonFactory final : public Input::Factory<Input::ButtonDevice> {
-public:
-    explicit SDLButtonFactory(SDLState& state_) : state(state_) {}
-
-    /**
-     * Creates a button device from a joystick button
-     * @param params contains parameters for creating the device:
-     *     - "guid": the guid of the joystick to bind
-     *     - "port": the nth joystick of the same type to bind
-     *     - "button"(optional): the index of the button to bind
-     *     - "hat"(optional): the index of the hat to bind as direction buttons
-     *     - "axis"(optional): the index of the axis to bind
-     *     - "direction"(only used for hat): the direction name of the hat to bind. Can be "up",
-     *         "down", "left" or "right"
-     *     - "threshold"(only used for axis): a float value in (-1.0, 1.0) which the button is
-     *         triggered if the axis value crosses
-     *     - "direction"(only used for axis): "+" means the button is triggered when the axis
-     * value is greater than the threshold; "-" means the button is triggered when the axis
-     * value is smaller than the threshold
-     */
-    std::unique_ptr<Input::ButtonDevice> Create(const Common::ParamPackage& params) override {
-        const std::string guid = params.Get("guid", "0");
-        const int port = params.Get("port", 0);
-        const auto toggle = params.Get("toggle", false);
-
-        auto joystick = state.GetSDLJoystickByGUID(guid, port);
-
-        if (params.Has("hat")) {
-            const int hat = params.Get("hat", 0);
-            const std::string direction_name = params.Get("direction", "");
-            Uint8 direction;
-            if (direction_name == "up") {
-                direction = SDL_HAT_UP;
-            } else if (direction_name == "down") {
-                direction = SDL_HAT_DOWN;
-            } else if (direction_name == "left") {
-                direction = SDL_HAT_LEFT;
-            } else if (direction_name == "right") {
-                direction = SDL_HAT_RIGHT;
-            } else {
-                direction = 0;
-            }
-            // This is necessary so accessing GetHat with hat won't crash
-            joystick->SetHat(hat, SDL_HAT_CENTERED);
-            return std::make_unique<SDLDirectionButton>(joystick, hat, direction);
-        }
-
-        if (params.Has("axis")) {
-            const int axis = params.Get("axis", 0);
-            // Convert range from (0.0, 1.0) to (-1.0, 1.0)
-            const float threshold = (params.Get("threshold", 0.5f) - 0.5f) * 2.0f;
-            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);
-            }
-            // This is necessary so accessing GetAxis with axis won't crash
-            joystick->PreSetAxis(axis);
-            return std::make_unique<SDLAxisButton>(joystick, axis, threshold, trigger_if_greater);
-        }
-
-        const int button = params.Get("button", 0);
-        // This is necessary so accessing GetButton with button won't crash
-        joystick->PreSetButton(button);
-        return std::make_unique<SDLButton>(joystick, button, toggle);
-    }
-
-private:
-    SDLState& state;
-};
-
-/// An analog device factory that creates analog devices from SDL joystick
-class SDLAnalogFactory final : public Input::Factory<Input::AnalogDevice> {
-public:
-    explicit SDLAnalogFactory(SDLState& state_) : state(state_) {}
-    /**
-     * Creates an analog device from joystick axes
-     * @param params contains parameters for creating the device:
-     *     - "guid": the guid of the joystick to bind
-     *     - "port": the nth joystick of the same type
-     *     - "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> Create(const Common::ParamPackage& params) override {
-        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, 1.0f);
-        const float range = std::clamp(params.Get("range", 1.0f), 0.50f, 1.50f);
-        const std::string invert_x_value = params.Get("invert_x", "+");
-        const std::string invert_y_value = params.Get("invert_y", "+");
-        const bool invert_x = invert_x_value == "-";
-        const bool invert_y = invert_y_value == "-";
-        const float offset_x = std::clamp(params.Get("offset_x", 0.0f), -0.99f, 0.99f);
-        const float offset_y = std::clamp(params.Get("offset_y", 0.0f), -0.99f, 0.99f);
-        auto joystick = state.GetSDLJoystickByGUID(guid, port);
-
-        // This is necessary so accessing GetAxis with axis_x and axis_y won't crash
-        joystick->PreSetAxis(axis_x);
-        joystick->PreSetAxis(axis_y);
-        return std::make_unique<SDLAnalog>(joystick, axis_x, axis_y, invert_x, invert_y, deadzone,
-                                           range, offset_x, offset_y);
-    }
-
-private:
-    SDLState& state;
-};
-
-/// An vibration device factory that creates vibration devices from SDL joystick
-class SDLVibrationFactory final : public Input::Factory<Input::VibrationDevice> {
-public:
-    explicit SDLVibrationFactory(SDLState& state_) : state(state_) {}
-    /**
-     * Creates a vibration device from a joystick
-     * @param params contains parameters for creating the device:
-     *     - "guid": the guid of the joystick to bind
-     *     - "port": the nth joystick of the same type
-     */
-    std::unique_ptr<Input::VibrationDevice> Create(const Common::ParamPackage& params) override {
-        const std::string guid = params.Get("guid", "0");
-        const int port = params.Get("port", 0);
-        return std::make_unique<SDLVibration>(state.GetSDLJoystickByGUID(guid, port));
-    }
-
-private:
-    SDLState& state;
-};
-
-/// A motion device factory that creates motion devices from SDL joystick
-class SDLMotionFactory final : public Input::Factory<Input::MotionDevice> {
-public:
-    explicit SDLMotionFactory(SDLState& state_) : state(state_) {}
-    /**
-     * Creates motion device from joystick axes
-     * @param params contains parameters for creating the device:
-     *     - "guid": the guid of the joystick to bind
-     *     - "port": the nth joystick of the same type
-     */
-    std::unique_ptr<Input::MotionDevice> Create(const Common::ParamPackage& params) override {
-        const std::string guid = params.Get("guid", "0");
-        const int port = params.Get("port", 0);
-
-        auto joystick = state.GetSDLJoystickByGUID(guid, port);
-
-        if (params.Has("motion")) {
-            return std::make_unique<SDLMotion>(joystick);
-        }
-
-        if (params.Has("hat")) {
-            const int hat = params.Get("hat", 0);
-            const std::string direction_name = params.Get("direction", "");
-            Uint8 direction;
-            if (direction_name == "up") {
-                direction = SDL_HAT_UP;
-            } else if (direction_name == "down") {
-                direction = SDL_HAT_DOWN;
-            } else if (direction_name == "left") {
-                direction = SDL_HAT_LEFT;
-            } else if (direction_name == "right") {
-                direction = SDL_HAT_RIGHT;
-            } else {
-                direction = 0;
-            }
-            // This is necessary so accessing GetHat with hat won't crash
-            joystick->SetHat(hat, SDL_HAT_CENTERED);
-            return std::make_unique<SDLDirectionMotion>(joystick, hat, direction);
-        }
-
-        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);
-            }
-            // This is necessary so accessing GetAxis with axis won't crash
-            joystick->PreSetAxis(axis);
-            return std::make_unique<SDLAxisMotion>(joystick, axis, threshold, trigger_if_greater);
-        }
-
-        const int button = params.Get("button", 0);
-        // This is necessary so accessing GetButton with button won't crash
-        joystick->PreSetButton(button);
-        return std::make_unique<SDLButtonMotion>(joystick, button);
-    }
-
-private:
-    SDLState& state;
-};
-
-SDLState::SDLState() {
-    using namespace Input;
-    button_factory = std::make_shared<SDLButtonFactory>(*this);
-    analog_factory = std::make_shared<SDLAnalogFactory>(*this);
-    vibration_factory = std::make_shared<SDLVibrationFactory>(*this);
-    motion_factory = std::make_shared<SDLMotionFactory>(*this);
-    RegisterFactory<ButtonDevice>("sdl", button_factory);
-    RegisterFactory<AnalogDevice>("sdl", analog_factory);
-    RegisterFactory<VibrationDevice>("sdl", vibration_factory);
-    RegisterFactory<MotionDevice>("sdl", motion_factory);
-
-    if (!Settings::values.enable_raw_input) {
-        // Disable raw input. When enabled this setting causes SDL to die when a web applet opens
-        SDL_SetHint(SDL_HINT_JOYSTICK_RAWINPUT, "0");
-    }
-
-    // Enable HIDAPI rumble. This prevents SDL from disabling motion on PS4 and PS5 controllers
-    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE, "1");
-    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE, "1");
-
-    // Tell SDL2 to use the hidapi driver. This will allow joycons to be detected as a
-    // GameController and not a generic one
-    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, "1");
-
-    // Turn off Pro controller home led
-    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED, "0");
-
-    // If the frontend is going to manage the event loop, then we don't start one here
-    start_thread = SDL_WasInit(SDL_INIT_JOYSTICK) == 0;
-    if (start_thread && SDL_Init(SDL_INIT_JOYSTICK) < 0) {
-        LOG_CRITICAL(Input, "SDL_Init(SDL_INIT_JOYSTICK) failed with: {}", SDL_GetError());
-        return;
-    }
-    has_gamecontroller = SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) != 0;
-    if (SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1") == SDL_FALSE) {
-        LOG_ERROR(Input, "Failed to set hint for background events with: {}", SDL_GetError());
-    }
-
-    SDL_AddEventWatch(&SDLEventWatcher, this);
-
-    initialized = true;
-    if (start_thread) {
-        poll_thread = std::thread([this] {
-            using namespace std::chrono_literals;
-            while (initialized) {
-                SDL_PumpEvents();
-                std::this_thread::sleep_for(1ms);
-            }
-        });
-    }
-    // Because the events for joystick connection happens before we have our event watcher added, we
-    // can just open all the joysticks right here
-    for (int i = 0; i < SDL_NumJoysticks(); ++i) {
-        InitJoystick(i);
-    }
-}
-
-SDLState::~SDLState() {
-    using namespace Input;
-    UnregisterFactory<ButtonDevice>("sdl");
-    UnregisterFactory<AnalogDevice>("sdl");
-    UnregisterFactory<VibrationDevice>("sdl");
-    UnregisterFactory<MotionDevice>("sdl");
-
-    CloseJoysticks();
-    SDL_DelEventWatch(&SDLEventWatcher, this);
-
-    initialized = false;
-    if (start_thread) {
-        poll_thread.join();
-        SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
-    }
-}
-
-std::vector<Common::ParamPackage> SDLState::GetInputDevices() {
-    std::scoped_lock lock(joystick_map_mutex);
-    std::vector<Common::ParamPackage> devices;
-    std::unordered_map<int, std::shared_ptr<SDLJoystick>> joycon_pairs;
-    for (const auto& [key, value] : joystick_map) {
-        for (const auto& joystick : value) {
-            if (!joystick->GetSDLJoystick()) {
-                continue;
-            }
-            std::string name =
-                fmt::format("{} {}", joystick->GetControllerName(), joystick->GetPort());
-            devices.emplace_back(Common::ParamPackage{
-                {"class", "sdl"},
-                {"display", std::move(name)},
-                {"guid", joystick->GetGUID()},
-                {"port", std::to_string(joystick->GetPort())},
-            });
-            if (joystick->IsJoyconLeft()) {
-                joycon_pairs.insert_or_assign(joystick->GetPort(), joystick);
-            }
-        }
-    }
-
-    // Add dual controllers
-    for (const auto& [key, value] : joystick_map) {
-        for (const auto& joystick : value) {
-            if (joystick->IsJoyconRight()) {
-                if (!joycon_pairs.contains(joystick->GetPort())) {
-                    continue;
-                }
-                const auto joystick2 = joycon_pairs.at(joystick->GetPort());
-
-                std::string name =
-                    fmt::format("{} {}", "Nintendo Dual Joy-Con", joystick->GetPort());
-                devices.emplace_back(Common::ParamPackage{
-                    {"class", "sdl"},
-                    {"display", std::move(name)},
-                    {"guid", joystick->GetGUID()},
-                    {"guid2", joystick2->GetGUID()},
-                    {"port", std::to_string(joystick->GetPort())},
-                });
-            }
-        }
-    }
-    return devices;
-}
-
-namespace {
-Common::ParamPackage BuildAnalogParamPackageForButton(int port, std::string guid, s32 axis,
-                                                      float value = 0.1f) {
-    Common::ParamPackage params({{"engine", "sdl"}});
-    params.Set("port", port);
-    params.Set("guid", std::move(guid));
-    params.Set("axis", axis);
-    params.Set("threshold", "0.5");
-    if (value > 0) {
-        params.Set("direction", "+");
-    } else {
-        params.Set("direction", "-");
-    }
-    return params;
-}
-
-Common::ParamPackage BuildButtonParamPackageForButton(int port, std::string guid, s32 button) {
-    Common::ParamPackage params({{"engine", "sdl"}});
-    params.Set("port", port);
-    params.Set("guid", std::move(guid));
-    params.Set("button", button);
-    params.Set("toggle", false);
-    return params;
-}
-
-Common::ParamPackage BuildHatParamPackageForButton(int port, std::string guid, s32 hat, s32 value) {
-    Common::ParamPackage params({{"engine", "sdl"}});
-
-    params.Set("port", port);
-    params.Set("guid", std::move(guid));
-    params.Set("hat", hat);
-    switch (value) {
-    case SDL_HAT_UP:
-        params.Set("direction", "up");
-        break;
-    case SDL_HAT_DOWN:
-        params.Set("direction", "down");
-        break;
-    case SDL_HAT_LEFT:
-        params.Set("direction", "left");
-        break;
-    case SDL_HAT_RIGHT:
-        params.Set("direction", "right");
-        break;
-    default:
-        return {};
-    }
-    return params;
-}
-
-Common::ParamPackage BuildMotionParam(int port, std::string guid) {
-    Common::ParamPackage params({{"engine", "sdl"}, {"motion", "0"}});
-    params.Set("port", port);
-    params.Set("guid", std::move(guid));
-    return params;
-}
-
-Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const SDL_Event& event) {
-    switch (event.type) {
-    case SDL_JOYAXISMOTION: {
-        if (const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which)) {
-            return BuildAnalogParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
-                                                    static_cast<s32>(event.jaxis.axis),
-                                                    event.jaxis.value);
-        }
-        break;
-    }
-    case SDL_JOYBUTTONUP: {
-        if (const auto joystick = state.GetSDLJoystickBySDLID(event.jbutton.which)) {
-            return BuildButtonParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
-                                                    static_cast<s32>(event.jbutton.button));
-        }
-        break;
-    }
-    case SDL_JOYHATMOTION: {
-        if (const auto joystick = state.GetSDLJoystickBySDLID(event.jhat.which)) {
-            return BuildHatParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
-                                                 static_cast<s32>(event.jhat.hat),
-                                                 static_cast<s32>(event.jhat.value));
-        }
-        break;
-    }
-    }
-    return {};
-}
-
-Common::ParamPackage SDLEventToMotionParamPackage(SDLState& state, const SDL_Event& event) {
-    switch (event.type) {
-    case SDL_JOYAXISMOTION: {
-        if (const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which)) {
-            return BuildAnalogParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
-                                                    static_cast<s32>(event.jaxis.axis),
-                                                    event.jaxis.value);
-        }
-        break;
-    }
-    case SDL_JOYBUTTONUP: {
-        if (const auto joystick = state.GetSDLJoystickBySDLID(event.jbutton.which)) {
-            return BuildButtonParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
-                                                    static_cast<s32>(event.jbutton.button));
-        }
-        break;
-    }
-    case SDL_JOYHATMOTION: {
-        if (const auto joystick = state.GetSDLJoystickBySDLID(event.jhat.which)) {
-            return BuildHatParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
-                                                 static_cast<s32>(event.jhat.hat),
-                                                 static_cast<s32>(event.jhat.value));
-        }
-        break;
-    }
-    case SDL_CONTROLLERSENSORUPDATE: {
-        bool is_motion_shaking = false;
-        constexpr float gyro_threshold = 5.0f;
-        constexpr float accel_threshold = 11.0f;
-        if (event.csensor.sensor == SDL_SENSOR_ACCEL) {
-            const Common::Vec3f acceleration = {-event.csensor.data[0], event.csensor.data[2],
-                                                -event.csensor.data[1]};
-            if (acceleration.Length() > accel_threshold) {
-                is_motion_shaking = true;
-            }
-        }
-
-        if (event.csensor.sensor == SDL_SENSOR_GYRO) {
-            const Common::Vec3f gyroscope = {event.csensor.data[0], -event.csensor.data[2],
-                                             event.csensor.data[1]};
-            if (gyroscope.Length() > gyro_threshold) {
-                is_motion_shaking = true;
-            }
-        }
-
-        if (!is_motion_shaking) {
-            break;
-        }
-
-        if (const auto joystick = state.GetSDLJoystickBySDLID(event.csensor.which)) {
-            return BuildMotionParam(joystick->GetPort(), joystick->GetGUID());
-        }
-        break;
-    }
-    }
-    return {};
-}
-
-Common::ParamPackage BuildParamPackageForBinding(int port, const std::string& guid,
-                                                 const SDL_GameControllerButtonBind& binding) {
-    switch (binding.bindType) {
-    case SDL_CONTROLLER_BINDTYPE_NONE:
-        break;
-    case SDL_CONTROLLER_BINDTYPE_AXIS:
-        return BuildAnalogParamPackageForButton(port, guid, binding.value.axis);
-    case SDL_CONTROLLER_BINDTYPE_BUTTON:
-        return BuildButtonParamPackageForButton(port, guid, binding.value.button);
-    case SDL_CONTROLLER_BINDTYPE_HAT:
-        return BuildHatParamPackageForButton(port, guid, binding.value.hat.hat,
-                                             binding.value.hat.hat_mask);
-    }
-    return {};
-}
-
-Common::ParamPackage BuildParamPackageForAnalog(int port, const std::string& guid, int axis_x,
-                                                int axis_y, float offset_x, float offset_y) {
-    Common::ParamPackage params;
-    params.Set("engine", "sdl");
-    params.Set("port", port);
-    params.Set("guid", guid);
-    params.Set("axis_x", axis_x);
-    params.Set("axis_y", axis_y);
-    params.Set("offset_x", offset_x);
-    params.Set("offset_y", offset_y);
-    params.Set("invert_x", "+");
-    params.Set("invert_y", "+");
-    return params;
-}
-} // Anonymous namespace
-
-ButtonMapping SDLState::GetButtonMappingForDevice(const Common::ParamPackage& params) {
-    if (!params.Has("guid") || !params.Has("port")) {
-        return {};
-    }
-    const auto joystick = GetSDLJoystickByGUID(params.Get("guid", ""), params.Get("port", 0));
-
-    auto* controller = joystick->GetSDLGameController();
-    if (controller == nullptr) {
-        return {};
-    }
-
-    // This list is missing ZL/ZR since those are not considered buttons in SDL GameController.
-    // We will add those afterwards
-    // This list also excludes Screenshot since theres not really a mapping for that
-    ButtonBindings switch_to_sdl_button;
-
-    if (SDL_GameControllerGetType(controller) == SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO) {
-        switch_to_sdl_button = GetNintendoButtonBinding(joystick);
-    } else {
-        switch_to_sdl_button = GetDefaultButtonBinding();
-    }
-
-    // Add the missing bindings for ZL/ZR
-    static constexpr ZButtonBindings switch_to_sdl_axis{{
-        {Settings::NativeButton::ZL, SDL_CONTROLLER_AXIS_TRIGGERLEFT},
-        {Settings::NativeButton::ZR, SDL_CONTROLLER_AXIS_TRIGGERRIGHT},
-    }};
-
-    // Parameters contain two joysticks return dual
-    if (params.Has("guid2")) {
-        const auto joystick2 = GetSDLJoystickByGUID(params.Get("guid2", ""), params.Get("port", 0));
-
-        if (joystick2->GetSDLGameController() != nullptr) {
-            return GetDualControllerMapping(joystick, joystick2, switch_to_sdl_button,
-                                            switch_to_sdl_axis);
-        }
-    }
-
-    return GetSingleControllerMapping(joystick, switch_to_sdl_button, switch_to_sdl_axis);
-}
-
-ButtonBindings SDLState::GetDefaultButtonBinding() const {
-    return {
-        std::pair{Settings::NativeButton::A, SDL_CONTROLLER_BUTTON_B},
-        {Settings::NativeButton::B, SDL_CONTROLLER_BUTTON_A},
-        {Settings::NativeButton::X, SDL_CONTROLLER_BUTTON_Y},
-        {Settings::NativeButton::Y, SDL_CONTROLLER_BUTTON_X},
-        {Settings::NativeButton::LStick, SDL_CONTROLLER_BUTTON_LEFTSTICK},
-        {Settings::NativeButton::RStick, SDL_CONTROLLER_BUTTON_RIGHTSTICK},
-        {Settings::NativeButton::L, SDL_CONTROLLER_BUTTON_LEFTSHOULDER},
-        {Settings::NativeButton::R, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER},
-        {Settings::NativeButton::Plus, SDL_CONTROLLER_BUTTON_START},
-        {Settings::NativeButton::Minus, SDL_CONTROLLER_BUTTON_BACK},
-        {Settings::NativeButton::DLeft, SDL_CONTROLLER_BUTTON_DPAD_LEFT},
-        {Settings::NativeButton::DUp, SDL_CONTROLLER_BUTTON_DPAD_UP},
-        {Settings::NativeButton::DRight, SDL_CONTROLLER_BUTTON_DPAD_RIGHT},
-        {Settings::NativeButton::DDown, SDL_CONTROLLER_BUTTON_DPAD_DOWN},
-        {Settings::NativeButton::SL, SDL_CONTROLLER_BUTTON_LEFTSHOULDER},
-        {Settings::NativeButton::SR, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER},
-        {Settings::NativeButton::Home, SDL_CONTROLLER_BUTTON_GUIDE},
-    };
-}
-
-ButtonBindings SDLState::GetNintendoButtonBinding(
-    const std::shared_ptr<SDLJoystick>& joystick) const {
-    // Default SL/SR mapping for pro controllers
-    auto sl_button = SDL_CONTROLLER_BUTTON_LEFTSHOULDER;
-    auto sr_button = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;
-
-    if (joystick->IsJoyconLeft()) {
-        sl_button = SDL_CONTROLLER_BUTTON_PADDLE2;
-        sr_button = SDL_CONTROLLER_BUTTON_PADDLE4;
-    }
-    if (joystick->IsJoyconRight()) {
-        sl_button = SDL_CONTROLLER_BUTTON_PADDLE3;
-        sr_button = SDL_CONTROLLER_BUTTON_PADDLE1;
-    }
-
-    return {
-        std::pair{Settings::NativeButton::A, SDL_CONTROLLER_BUTTON_A},
-        {Settings::NativeButton::B, SDL_CONTROLLER_BUTTON_B},
-        {Settings::NativeButton::X, SDL_CONTROLLER_BUTTON_X},
-        {Settings::NativeButton::Y, SDL_CONTROLLER_BUTTON_Y},
-        {Settings::NativeButton::LStick, SDL_CONTROLLER_BUTTON_LEFTSTICK},
-        {Settings::NativeButton::RStick, SDL_CONTROLLER_BUTTON_RIGHTSTICK},
-        {Settings::NativeButton::L, SDL_CONTROLLER_BUTTON_LEFTSHOULDER},
-        {Settings::NativeButton::R, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER},
-        {Settings::NativeButton::Plus, SDL_CONTROLLER_BUTTON_START},
-        {Settings::NativeButton::Minus, SDL_CONTROLLER_BUTTON_BACK},
-        {Settings::NativeButton::DLeft, SDL_CONTROLLER_BUTTON_DPAD_LEFT},
-        {Settings::NativeButton::DUp, SDL_CONTROLLER_BUTTON_DPAD_UP},
-        {Settings::NativeButton::DRight, SDL_CONTROLLER_BUTTON_DPAD_RIGHT},
-        {Settings::NativeButton::DDown, SDL_CONTROLLER_BUTTON_DPAD_DOWN},
-        {Settings::NativeButton::SL, sl_button},
-        {Settings::NativeButton::SR, sr_button},
-        {Settings::NativeButton::Home, SDL_CONTROLLER_BUTTON_GUIDE},
-    };
-}
-
-ButtonMapping SDLState::GetSingleControllerMapping(
-    const std::shared_ptr<SDLJoystick>& joystick, const ButtonBindings& switch_to_sdl_button,
-    const ZButtonBindings& switch_to_sdl_axis) const {
-    ButtonMapping mapping;
-    mapping.reserve(switch_to_sdl_button.size() + switch_to_sdl_axis.size());
-    auto* controller = joystick->GetSDLGameController();
-
-    for (const auto& [switch_button, sdl_button] : switch_to_sdl_button) {
-        const auto& binding = SDL_GameControllerGetBindForButton(controller, sdl_button);
-        mapping.insert_or_assign(
-            switch_button,
-            BuildParamPackageForBinding(joystick->GetPort(), joystick->GetGUID(), binding));
-    }
-    for (const auto& [switch_button, sdl_axis] : switch_to_sdl_axis) {
-        const auto& binding = SDL_GameControllerGetBindForAxis(controller, sdl_axis);
-        mapping.insert_or_assign(
-            switch_button,
-            BuildParamPackageForBinding(joystick->GetPort(), joystick->GetGUID(), binding));
-    }
-
-    return mapping;
-}
-
-ButtonMapping SDLState::GetDualControllerMapping(const std::shared_ptr<SDLJoystick>& joystick,
-                                                 const std::shared_ptr<SDLJoystick>& joystick2,
-                                                 const ButtonBindings& switch_to_sdl_button,
-                                                 const ZButtonBindings& switch_to_sdl_axis) const {
-    ButtonMapping mapping;
-    mapping.reserve(switch_to_sdl_button.size() + switch_to_sdl_axis.size());
-    auto* controller = joystick->GetSDLGameController();
-    auto* controller2 = joystick2->GetSDLGameController();
-
-    for (const auto& [switch_button, sdl_button] : switch_to_sdl_button) {
-        if (IsButtonOnLeftSide(switch_button)) {
-            const auto& binding = SDL_GameControllerGetBindForButton(controller2, sdl_button);
-            mapping.insert_or_assign(
-                switch_button,
-                BuildParamPackageForBinding(joystick2->GetPort(), joystick2->GetGUID(), binding));
-            continue;
-        }
-        const auto& binding = SDL_GameControllerGetBindForButton(controller, sdl_button);
-        mapping.insert_or_assign(
-            switch_button,
-            BuildParamPackageForBinding(joystick->GetPort(), joystick->GetGUID(), binding));
-    }
-    for (const auto& [switch_button, sdl_axis] : switch_to_sdl_axis) {
-        if (IsButtonOnLeftSide(switch_button)) {
-            const auto& binding = SDL_GameControllerGetBindForAxis(controller2, sdl_axis);
-            mapping.insert_or_assign(
-                switch_button,
-                BuildParamPackageForBinding(joystick2->GetPort(), joystick2->GetGUID(), binding));
-            continue;
-        }
-        const auto& binding = SDL_GameControllerGetBindForAxis(controller, sdl_axis);
-        mapping.insert_or_assign(
-            switch_button,
-            BuildParamPackageForBinding(joystick->GetPort(), joystick->GetGUID(), binding));
-    }
-
-    return mapping;
-}
-
-bool SDLState::IsButtonOnLeftSide(Settings::NativeButton::Values button) const {
-    switch (button) {
-    case Settings::NativeButton::DDown:
-    case Settings::NativeButton::DLeft:
-    case Settings::NativeButton::DRight:
-    case Settings::NativeButton::DUp:
-    case Settings::NativeButton::L:
-    case Settings::NativeButton::LStick:
-    case Settings::NativeButton::Minus:
-    case Settings::NativeButton::Screenshot:
-    case Settings::NativeButton::ZL:
-        return true;
-    default:
-        return false;
-    }
-}
-
-AnalogMapping SDLState::GetAnalogMappingForDevice(const Common::ParamPackage& params) {
-    if (!params.Has("guid") || !params.Has("port")) {
-        return {};
-    }
-    const auto joystick = GetSDLJoystickByGUID(params.Get("guid", ""), params.Get("port", 0));
-    const auto joystick2 = GetSDLJoystickByGUID(params.Get("guid2", ""), params.Get("port", 0));
-    auto* controller = joystick->GetSDLGameController();
-    if (controller == nullptr) {
-        return {};
-    }
-
-    AnalogMapping mapping = {};
-    const auto& binding_left_x =
-        SDL_GameControllerGetBindForAxis(controller, SDL_CONTROLLER_AXIS_LEFTX);
-    const auto& binding_left_y =
-        SDL_GameControllerGetBindForAxis(controller, SDL_CONTROLLER_AXIS_LEFTY);
-    if (params.Has("guid2")) {
-        joystick2->PreSetAxis(binding_left_x.value.axis);
-        joystick2->PreSetAxis(binding_left_y.value.axis);
-        const auto left_offset_x = -joystick2->GetAxis(binding_left_x.value.axis, 1.0f, 0);
-        const auto left_offset_y = -joystick2->GetAxis(binding_left_y.value.axis, 1.0f, 0);
-        mapping.insert_or_assign(
-            Settings::NativeAnalog::LStick,
-            BuildParamPackageForAnalog(joystick2->GetPort(), joystick2->GetGUID(),
-                                       binding_left_x.value.axis, binding_left_y.value.axis,
-                                       left_offset_x, left_offset_y));
-    } else {
-        joystick->PreSetAxis(binding_left_x.value.axis);
-        joystick->PreSetAxis(binding_left_y.value.axis);
-        const auto left_offset_x = -joystick->GetAxis(binding_left_x.value.axis, 1.0f, 0);
-        const auto left_offset_y = -joystick->GetAxis(binding_left_y.value.axis, 1.0f, 0);
-        mapping.insert_or_assign(
-            Settings::NativeAnalog::LStick,
-            BuildParamPackageForAnalog(joystick->GetPort(), joystick->GetGUID(),
-                                       binding_left_x.value.axis, binding_left_y.value.axis,
-                                       left_offset_x, left_offset_y));
-    }
-    const auto& binding_right_x =
-        SDL_GameControllerGetBindForAxis(controller, SDL_CONTROLLER_AXIS_RIGHTX);
-    const auto& binding_right_y =
-        SDL_GameControllerGetBindForAxis(controller, SDL_CONTROLLER_AXIS_RIGHTY);
-    joystick->PreSetAxis(binding_right_x.value.axis);
-    joystick->PreSetAxis(binding_right_y.value.axis);
-    const auto right_offset_x = -joystick->GetAxis(binding_right_x.value.axis, 1.0f, 0);
-    const auto right_offset_y = -joystick->GetAxis(binding_right_y.value.axis, 1.0f, 0);
-    mapping.insert_or_assign(Settings::NativeAnalog::RStick,
-                             BuildParamPackageForAnalog(joystick->GetPort(), joystick->GetGUID(),
-                                                        binding_right_x.value.axis,
-                                                        binding_right_y.value.axis, right_offset_x,
-                                                        right_offset_y));
-    return mapping;
-}
-
-MotionMapping SDLState::GetMotionMappingForDevice(const Common::ParamPackage& params) {
-    if (!params.Has("guid") || !params.Has("port")) {
-        return {};
-    }
-    const auto joystick = GetSDLJoystickByGUID(params.Get("guid", ""), params.Get("port", 0));
-    const auto joystick2 = GetSDLJoystickByGUID(params.Get("guid2", ""), params.Get("port", 0));
-    auto* controller = joystick->GetSDLGameController();
-    if (controller == nullptr) {
-        return {};
-    }
-
-    MotionMapping mapping = {};
-    joystick->EnableMotion();
-
-    if (joystick->HasGyro() || joystick->HasAccel()) {
-        mapping.insert_or_assign(Settings::NativeMotion::MotionRight,
-                                 BuildMotionParam(joystick->GetPort(), joystick->GetGUID()));
-    }
-    if (params.Has("guid2")) {
-        joystick2->EnableMotion();
-        if (joystick2->HasGyro() || joystick2->HasAccel()) {
-            mapping.insert_or_assign(Settings::NativeMotion::MotionLeft,
-                                     BuildMotionParam(joystick2->GetPort(), joystick2->GetGUID()));
-        }
-    } else {
-        if (joystick->HasGyro() || joystick->HasAccel()) {
-            mapping.insert_or_assign(Settings::NativeMotion::MotionLeft,
-                                     BuildMotionParam(joystick->GetPort(), joystick->GetGUID()));
-        }
-    }
-
-    return mapping;
-}
-namespace Polling {
-class SDLPoller : public InputCommon::Polling::DevicePoller {
-public:
-    explicit SDLPoller(SDLState& state_) : state(state_) {}
-
-    void Start([[maybe_unused]] const std::string& device_id) override {
-        state.event_queue.Clear();
-        state.polling = true;
-    }
-
-    void Stop() override {
-        state.polling = false;
-    }
-
-protected:
-    SDLState& state;
-};
-
-class SDLButtonPoller final : public SDLPoller {
-public:
-    explicit SDLButtonPoller(SDLState& state_) : SDLPoller(state_) {}
-
-    Common::ParamPackage GetNextInput() override {
-        SDL_Event event;
-        while (state.event_queue.Pop(event)) {
-            const auto package = FromEvent(event);
-            if (package) {
-                return *package;
-            }
-        }
-        return {};
-    }
-    [[nodiscard]] std::optional<Common::ParamPackage> FromEvent(SDL_Event& event) {
-        switch (event.type) {
-        case SDL_JOYAXISMOTION:
-            if (!axis_memory.count(event.jaxis.which) ||
-                !axis_memory[event.jaxis.which].count(event.jaxis.axis)) {
-                axis_memory[event.jaxis.which][event.jaxis.axis] = event.jaxis.value;
-                axis_event_count[event.jaxis.which][event.jaxis.axis] = 1;
-                break;
-            } else {
-                axis_event_count[event.jaxis.which][event.jaxis.axis]++;
-                // The joystick and axis exist in our map if we take this branch, so no checks
-                // needed
-                if (std::abs(
-                        (event.jaxis.value - axis_memory[event.jaxis.which][event.jaxis.axis]) /
-                        32767.0) < 0.5) {
-                    break;
-                } else {
-                    if (axis_event_count[event.jaxis.which][event.jaxis.axis] == 2 &&
-                        IsAxisAtPole(event.jaxis.value) &&
-                        IsAxisAtPole(axis_memory[event.jaxis.which][event.jaxis.axis])) {
-                        // If we have exactly two events and both are near a pole, this is
-                        // likely a digital input masquerading as an analog axis; Instead of
-                        // trying to look at the direction the axis travelled, assume the first
-                        // event was press and the second was release; This should handle most
-                        // digital axes while deferring to the direction of travel for analog
-                        // axes
-                        event.jaxis.value = static_cast<Sint16>(
-                            std::copysign(32767, axis_memory[event.jaxis.which][event.jaxis.axis]));
-                    } else {
-                        // There are more than two events, so this is likely a true analog axis,
-                        // check the direction it travelled
-                        event.jaxis.value = static_cast<Sint16>(std::copysign(
-                            32767,
-                            event.jaxis.value - axis_memory[event.jaxis.which][event.jaxis.axis]));
-                    }
-                    axis_memory.clear();
-                    axis_event_count.clear();
-                }
-            }
-            [[fallthrough]];
-        case SDL_JOYBUTTONUP:
-        case SDL_JOYHATMOTION:
-            return {SDLEventToButtonParamPackage(state, event)};
-        }
-        return std::nullopt;
-    }
-
-private:
-    // Determine whether an axis value is close to an extreme or center
-    // Some controllers have a digital D-Pad as a pair of analog sticks, with 3 possible values per
-    // axis, which is why the center must be considered a pole
-    bool IsAxisAtPole(int16_t value) const {
-        return std::abs(value) >= 32767 || std::abs(value) < 327;
-    }
-    std::unordered_map<SDL_JoystickID, std::unordered_map<uint8_t, int16_t>> axis_memory;
-    std::unordered_map<SDL_JoystickID, std::unordered_map<uint8_t, uint32_t>> axis_event_count;
-};
-
-class SDLMotionPoller final : public SDLPoller {
-public:
-    explicit SDLMotionPoller(SDLState& state_) : SDLPoller(state_) {}
-
-    Common::ParamPackage GetNextInput() override {
-        SDL_Event event;
-        while (state.event_queue.Pop(event)) {
-            const auto package = FromEvent(event);
-            if (package) {
-                return *package;
-            }
-        }
-        return {};
-    }
-    [[nodiscard]] std::optional<Common::ParamPackage> FromEvent(const SDL_Event& event) const {
-        switch (event.type) {
-        case SDL_JOYAXISMOTION:
-            if (std::abs(event.jaxis.value / 32767.0) < 0.5) {
-                break;
-            }
-            [[fallthrough]];
-        case SDL_JOYBUTTONUP:
-        case SDL_JOYHATMOTION:
-        case SDL_CONTROLLERSENSORUPDATE:
-            return {SDLEventToMotionParamPackage(state, event)};
-        }
-        return std::nullopt;
-    }
-};
-
-/**
- * Attempts to match the press to a controller joy axis (left/right stick) and if a match
- * isn't found, checks if the event matches anything from SDLButtonPoller and uses that
- * instead
- */
-class SDLAnalogPreferredPoller final : public SDLPoller {
-public:
-    explicit SDLAnalogPreferredPoller(SDLState& state_)
-        : SDLPoller(state_), button_poller(state_) {}
-
-    void Start(const std::string& device_id) override {
-        SDLPoller::Start(device_id);
-        // Reset stored axes
-        first_axis = -1;
-    }
-
-    Common::ParamPackage GetNextInput() override {
-        SDL_Event event;
-        while (state.event_queue.Pop(event)) {
-            if (event.type != SDL_JOYAXISMOTION) {
-                // Check for a button press
-                auto button_press = button_poller.FromEvent(event);
-                if (button_press) {
-                    return *button_press;
-                }
-                continue;
-            }
-            const auto axis = event.jaxis.axis;
-
-            // Filter out axis events that are below a threshold
-            if (std::abs(event.jaxis.value / 32767.0) < 0.5) {
-                continue;
-            }
-
-            // Filter out axis events that are the same
-            if (first_axis == axis) {
-                continue;
-            }
-
-            // In order to return a complete analog param, we need inputs for both axes.
-            // If the first axis isn't set we set the value then wait till next event
-            if (first_axis == -1) {
-                first_axis = axis;
-                continue;
-            }
-
-            if (const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which)) {
-                // Set offset to zero since the joystick is not on center
-                auto params = BuildParamPackageForAnalog(joystick->GetPort(), joystick->GetGUID(),
-                                                         first_axis, axis, 0, 0);
-                first_axis = -1;
-                return params;
-            }
-        }
-        return {};
-    }
-
-private:
-    int first_axis = -1;
-    SDLButtonPoller button_poller;
-};
-} // namespace Polling
-
-SDLState::Pollers SDLState::GetPollers(InputCommon::Polling::DeviceType type) {
-    Pollers pollers;
-
-    switch (type) {
-    case InputCommon::Polling::DeviceType::AnalogPreferred:
-        pollers.emplace_back(std::make_unique<Polling::SDLAnalogPreferredPoller>(*this));
-        break;
-    case InputCommon::Polling::DeviceType::Button:
-        pollers.emplace_back(std::make_unique<Polling::SDLButtonPoller>(*this));
-        break;
-    case InputCommon::Polling::DeviceType::Motion:
-        pollers.emplace_back(std::make_unique<Polling::SDLMotionPoller>(*this));
-        break;
-    }
-
-    return pollers;
-}
-
-} // namespace InputCommon::SDL