From 1d0e9b62da1b72de33539586b484abc48f6d2f32 Mon Sep 17 00:00:00 2001
From: german77 <juangerman-13@hotmail.com>
Date: Mon, 20 Sep 2021 16:57:55 -0500
Subject: input_common: Move touch and analog from button. Move udp protocol

---
 src/input_common/main.cpp | 8 --------
 1 file changed, 8 deletions(-)

(limited to 'src/input_common/main.cpp')

diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index f3907c65ac..7a5c29b400 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -6,7 +6,6 @@
 #include <thread>
 #include "common/param_package.h"
 #include "common/settings.h"
-#include "input_common/analog_from_button.h"
 #include "input_common/gcadapter/gc_adapter.h"
 #include "input_common/gcadapter/gc_poller.h"
 #include "input_common/keyboard.h"
@@ -16,7 +15,6 @@
 #include "input_common/mouse/mouse_poller.h"
 #include "input_common/tas/tas_input.h"
 #include "input_common/tas/tas_poller.h"
-#include "input_common/touch_from_button.h"
 #include "input_common/udp/client.h"
 #include "input_common/udp/udp.h"
 #ifdef HAVE_SDL2
@@ -37,12 +35,8 @@ struct InputSubsystem::Impl {
 
         keyboard = std::make_shared<Keyboard>();
         Input::RegisterFactory<Input::ButtonDevice>("keyboard", keyboard);
-        Input::RegisterFactory<Input::AnalogDevice>("analog_from_button",
-                                                    std::make_shared<AnalogFromButton>());
         Input::RegisterFactory<Input::MotionDevice>("keyboard",
                                                     std::make_shared<MotionFromButton>());
-        Input::RegisterFactory<Input::TouchDevice>("touch_from_button",
-                                                   std::make_shared<TouchFromButtonFactory>());
 
 #ifdef HAVE_SDL2
         sdl = SDL::Init();
@@ -75,8 +69,6 @@ struct InputSubsystem::Impl {
         Input::UnregisterFactory<Input::ButtonDevice>("keyboard");
         Input::UnregisterFactory<Input::MotionDevice>("keyboard");
         keyboard.reset();
-        Input::UnregisterFactory<Input::AnalogDevice>("analog_from_button");
-        Input::UnregisterFactory<Input::TouchDevice>("touch_from_button");
 #ifdef HAVE_SDL2
         sdl.reset();
 #endif
-- 
cgit v1.2.3


From 00d3c058c5af92d748563ef730bfc1a7921c33b8 Mon Sep 17 00:00:00 2001
From: german77 <juangerman-13@hotmail.com>
Date: Mon, 20 Sep 2021 17:18:40 -0500
Subject: input_common: Rewrite keyboard

---
 src/input_common/CMakeLists.txt                   |   4 +-
 src/input_common/drivers/keyboard.cpp             |  35 +++
 src/input_common/drivers/keyboard.h               |  44 ++++
 src/input_common/keyboard.cpp                     | 121 ----------
 src/input_common/keyboard.h                       |  47 ----
 src/input_common/main.cpp                         | 263 +---------------------
 src/input_common/main.h                           |  89 --------
 src/yuzu/bootmanager.cpp                          |  62 +++--
 src/yuzu/bootmanager.h                            |   2 +-
 src/yuzu/configuration/configure_input_player.cpp |  83 +------
 src/yuzu/debugger/controller.cpp                  |   3 +-
 src/yuzu/main.cpp                                 |  18 +-
 12 files changed, 126 insertions(+), 645 deletions(-)
 create mode 100644 src/input_common/drivers/keyboard.cpp
 create mode 100644 src/input_common/drivers/keyboard.h
 delete mode 100644 src/input_common/keyboard.cpp
 delete mode 100644 src/input_common/keyboard.h

(limited to 'src/input_common/main.cpp')

diff --git a/src/input_common/CMakeLists.txt b/src/input_common/CMakeLists.txt
index 90e7618cee..0fcf7a9d7b 100644
--- a/src/input_common/CMakeLists.txt
+++ b/src/input_common/CMakeLists.txt
@@ -1,6 +1,6 @@
 add_library(input_common STATIC
-    keyboard.cpp
-    keyboard.h
+    drivers/keyboard.cpp
+    drivers/keyboard.h
     helpers/stick_from_buttons.cpp
     helpers/stick_from_buttons.h
     helpers/touch_from_buttons.cpp
diff --git a/src/input_common/drivers/keyboard.cpp b/src/input_common/drivers/keyboard.cpp
new file mode 100644
index 0000000000..b00a4b8d95
--- /dev/null
+++ b/src/input_common/drivers/keyboard.cpp
@@ -0,0 +1,35 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included
+
+#include "common/param_package.h"
+#include "input_common/drivers/keyboard.h"
+
+namespace InputCommon {
+
+Keyboard::Keyboard(const std::string& input_engine_) : InputEngine(input_engine_) {
+    PreSetController(identifier);
+}
+
+void Keyboard::PressKey(int key_code) {
+    SetButton(identifier, key_code, true);
+}
+
+void Keyboard::ReleaseKey(int key_code) {
+    SetButton(identifier, key_code, false);
+}
+
+void Keyboard::ReleaseAllKeys() {
+    ResetButtonState();
+}
+
+std::vector<Common::ParamPackage> Keyboard::GetInputDevices() const {
+    std::vector<Common::ParamPackage> devices;
+    devices.emplace_back(Common::ParamPackage{
+        {"engine", "keyboard"},
+        {"display", "Keyboard Only"},
+    });
+    return devices;
+}
+
+} // namespace InputCommon
diff --git a/src/input_common/drivers/keyboard.h b/src/input_common/drivers/keyboard.h
new file mode 100644
index 0000000000..a3e0d8a617
--- /dev/null
+++ b/src/input_common/drivers/keyboard.h
@@ -0,0 +1,44 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included
+
+#pragma once
+
+#include "input_common/input_engine.h"
+
+namespace InputCommon {
+
+/**
+ * A button device factory representing a keyboard. It receives keyboard events and forward them
+ * to all button devices it created.
+ */
+class Keyboard final : public InputCommon::InputEngine {
+public:
+    explicit Keyboard(const std::string& input_engine_);
+
+    /**
+     * Sets the status of all buttons bound with the key to pressed
+     * @param key_code the code of the key to press
+     */
+    void PressKey(int key_code);
+
+    /**
+     * Sets the status of all buttons bound with the key to released
+     * @param key_code the code of the key to release
+     */
+    void ReleaseKey(int key_code);
+
+    void ReleaseAllKeys();
+
+    /// Used for automapping features
+    std::vector<Common::ParamPackage> GetInputDevices() const override;
+
+private:
+    const PadIdentifier identifier = {
+        .guid = Common::UUID{""},
+        .port = 0,
+        .pad = 0,
+    };
+};
+
+} // namespace InputCommon
diff --git a/src/input_common/keyboard.cpp b/src/input_common/keyboard.cpp
deleted file mode 100644
index 8261e76fd7..0000000000
--- a/src/input_common/keyboard.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2017 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <atomic>
-#include <list>
-#include <mutex>
-#include <utility>
-#include "input_common/keyboard.h"
-
-namespace InputCommon {
-
-class KeyButton final : public Input::ButtonDevice {
-public:
-    explicit KeyButton(std::shared_ptr<KeyButtonList> key_button_list_, bool toggle_)
-        : key_button_list(std::move(key_button_list_)), toggle(toggle_) {}
-
-    ~KeyButton() override;
-
-    bool GetStatus() const override {
-        if (toggle) {
-            return toggled_status.load(std::memory_order_relaxed);
-        }
-        return status.load();
-    }
-
-    void ToggleButton() {
-        if (lock) {
-            return;
-        }
-        lock = true;
-        const bool old_toggle_status = toggled_status.load();
-        toggled_status.store(!old_toggle_status);
-    }
-
-    void UnlockButton() {
-        lock = false;
-    }
-
-    friend class KeyButtonList;
-
-private:
-    std::shared_ptr<KeyButtonList> key_button_list;
-    std::atomic<bool> status{false};
-    std::atomic<bool> toggled_status{false};
-    bool lock{false};
-    const bool toggle;
-};
-
-struct KeyButtonPair {
-    int key_code;
-    KeyButton* key_button;
-};
-
-class KeyButtonList {
-public:
-    void AddKeyButton(int key_code, KeyButton* key_button) {
-        std::lock_guard guard{mutex};
-        list.push_back(KeyButtonPair{key_code, key_button});
-    }
-
-    void RemoveKeyButton(const KeyButton* key_button) {
-        std::lock_guard guard{mutex};
-        list.remove_if(
-            [key_button](const KeyButtonPair& pair) { return pair.key_button == key_button; });
-    }
-
-    void ChangeKeyStatus(int key_code, bool pressed) {
-        std::lock_guard guard{mutex};
-        for (const KeyButtonPair& pair : list) {
-            if (pair.key_code == key_code) {
-                pair.key_button->status.store(pressed);
-                if (pressed) {
-                    pair.key_button->ToggleButton();
-                } else {
-                    pair.key_button->UnlockButton();
-                }
-                pair.key_button->TriggerOnChange();
-            }
-        }
-    }
-
-    void ChangeAllKeyStatus(bool pressed) {
-        std::lock_guard guard{mutex};
-        for (const KeyButtonPair& pair : list) {
-            pair.key_button->status.store(pressed);
-        }
-    }
-
-private:
-    std::mutex mutex;
-    std::list<KeyButtonPair> list;
-};
-
-Keyboard::Keyboard() : key_button_list{std::make_shared<KeyButtonList>()} {}
-
-KeyButton::~KeyButton() {
-    key_button_list->RemoveKeyButton(this);
-}
-
-std::unique_ptr<Input::ButtonDevice> Keyboard::Create(const Common::ParamPackage& params) {
-    const int key_code = params.Get("code", 0);
-    const bool toggle = params.Get("toggle", false);
-    std::unique_ptr<KeyButton> button = std::make_unique<KeyButton>(key_button_list, toggle);
-    key_button_list->AddKeyButton(key_code, button.get());
-    return button;
-}
-
-void Keyboard::PressKey(int key_code) {
-    key_button_list->ChangeKeyStatus(key_code, true);
-}
-
-void Keyboard::ReleaseKey(int key_code) {
-    key_button_list->ChangeKeyStatus(key_code, false);
-}
-
-void Keyboard::ReleaseAllKeys() {
-    key_button_list->ChangeAllKeyStatus(false);
-}
-
-} // namespace InputCommon
diff --git a/src/input_common/keyboard.h b/src/input_common/keyboard.h
deleted file mode 100644
index 8619504729..0000000000
--- a/src/input_common/keyboard.h
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2017 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include "core/frontend/input.h"
-
-namespace InputCommon {
-
-class KeyButtonList;
-
-/**
- * A button device factory representing a keyboard. It receives keyboard events and forward them
- * to all button devices it created.
- */
-class Keyboard final : public Input::Factory<Input::ButtonDevice> {
-public:
-    Keyboard();
-
-    /**
-     * Creates a button device from a keyboard key
-     * @param params contains parameters for creating the device:
-     *     - "code": the code of the key to bind with the button
-     */
-    std::unique_ptr<Input::ButtonDevice> Create(const Common::ParamPackage& params) override;
-
-    /**
-     * Sets the status of all buttons bound with the key to pressed
-     * @param key_code the code of the key to press
-     */
-    void PressKey(int key_code);
-
-    /**
-     * Sets the status of all buttons bound with the key to released
-     * @param key_code the code of the key to release
-     */
-    void ReleaseKey(int key_code);
-
-    void ReleaseAllKeys();
-
-private:
-    std::shared_ptr<KeyButtonList> key_button_list;
-};
-
-} // namespace InputCommon
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index 7a5c29b400..da501b6ccb 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -6,17 +6,7 @@
 #include <thread>
 #include "common/param_package.h"
 #include "common/settings.h"
-#include "input_common/gcadapter/gc_adapter.h"
-#include "input_common/gcadapter/gc_poller.h"
-#include "input_common/keyboard.h"
 #include "input_common/main.h"
-#include "input_common/motion_from_button.h"
-#include "input_common/mouse/mouse_input.h"
-#include "input_common/mouse/mouse_poller.h"
-#include "input_common/tas/tas_input.h"
-#include "input_common/tas/tas_poller.h"
-#include "input_common/udp/client.h"
-#include "input_common/udp/udp.h"
 #ifdef HAVE_SDL2
 #include "input_common/sdl/sdl.h"
 #endif
@@ -25,82 +15,9 @@ namespace InputCommon {
 
 struct InputSubsystem::Impl {
     void Initialize() {
-        gcadapter = std::make_shared<GCAdapter::Adapter>();
-        gcbuttons = std::make_shared<GCButtonFactory>(gcadapter);
-        Input::RegisterFactory<Input::ButtonDevice>("gcpad", gcbuttons);
-        gcanalog = std::make_shared<GCAnalogFactory>(gcadapter);
-        Input::RegisterFactory<Input::AnalogDevice>("gcpad", gcanalog);
-        gcvibration = std::make_shared<GCVibrationFactory>(gcadapter);
-        Input::RegisterFactory<Input::VibrationDevice>("gcpad", gcvibration);
-
-        keyboard = std::make_shared<Keyboard>();
-        Input::RegisterFactory<Input::ButtonDevice>("keyboard", keyboard);
-        Input::RegisterFactory<Input::MotionDevice>("keyboard",
-                                                    std::make_shared<MotionFromButton>());
-
-#ifdef HAVE_SDL2
-        sdl = SDL::Init();
-#endif
-
-        udp = std::make_shared<InputCommon::CemuhookUDP::Client>();
-        udpmotion = std::make_shared<UDPMotionFactory>(udp);
-        Input::RegisterFactory<Input::MotionDevice>("cemuhookudp", udpmotion);
-        udptouch = std::make_shared<UDPTouchFactory>(udp);
-        Input::RegisterFactory<Input::TouchDevice>("cemuhookudp", udptouch);
-
-        mouse = std::make_shared<MouseInput::Mouse>();
-        mousebuttons = std::make_shared<MouseButtonFactory>(mouse);
-        Input::RegisterFactory<Input::ButtonDevice>("mouse", mousebuttons);
-        mouseanalog = std::make_shared<MouseAnalogFactory>(mouse);
-        Input::RegisterFactory<Input::AnalogDevice>("mouse", mouseanalog);
-        mousemotion = std::make_shared<MouseMotionFactory>(mouse);
-        Input::RegisterFactory<Input::MotionDevice>("mouse", mousemotion);
-        mousetouch = std::make_shared<MouseTouchFactory>(mouse);
-        Input::RegisterFactory<Input::TouchDevice>("mouse", mousetouch);
-
-        tas = std::make_shared<TasInput::Tas>();
-        tasbuttons = std::make_shared<TasButtonFactory>(tas);
-        Input::RegisterFactory<Input::ButtonDevice>("tas", tasbuttons);
-        tasanalog = std::make_shared<TasAnalogFactory>(tas);
-        Input::RegisterFactory<Input::AnalogDevice>("tas", tasanalog);
     }
 
     void Shutdown() {
-        Input::UnregisterFactory<Input::ButtonDevice>("keyboard");
-        Input::UnregisterFactory<Input::MotionDevice>("keyboard");
-        keyboard.reset();
-#ifdef HAVE_SDL2
-        sdl.reset();
-#endif
-        Input::UnregisterFactory<Input::ButtonDevice>("gcpad");
-        Input::UnregisterFactory<Input::AnalogDevice>("gcpad");
-        Input::UnregisterFactory<Input::VibrationDevice>("gcpad");
-
-        gcbuttons.reset();
-        gcanalog.reset();
-        gcvibration.reset();
-
-        Input::UnregisterFactory<Input::MotionDevice>("cemuhookudp");
-        Input::UnregisterFactory<Input::TouchDevice>("cemuhookudp");
-
-        udpmotion.reset();
-        udptouch.reset();
-
-        Input::UnregisterFactory<Input::ButtonDevice>("mouse");
-        Input::UnregisterFactory<Input::AnalogDevice>("mouse");
-        Input::UnregisterFactory<Input::MotionDevice>("mouse");
-        Input::UnregisterFactory<Input::TouchDevice>("mouse");
-
-        mousebuttons.reset();
-        mouseanalog.reset();
-        mousemotion.reset();
-        mousetouch.reset();
-
-        Input::UnregisterFactory<Input::ButtonDevice>("tas");
-        Input::UnregisterFactory<Input::AnalogDevice>("tas");
-
-        tasbuttons.reset();
-        tasanalog.reset();
     }
 
     [[nodiscard]] std::vector<Common::ParamPackage> GetInputDevices() const {
@@ -108,19 +25,7 @@ struct InputSubsystem::Impl {
             Common::ParamPackage{{"display", "Any"}, {"class", "any"}},
             Common::ParamPackage{{"display", "Keyboard/Mouse"}, {"class", "keyboard"}},
         };
-        if (Settings::values.tas_enable) {
-            devices.emplace_back(
-                Common::ParamPackage{{"display", "TAS Controller"}, {"class", "tas"}});
-        }
-#ifdef HAVE_SDL2
-        auto sdl_devices = sdl->GetInputDevices();
-        devices.insert(devices.end(), sdl_devices.begin(), sdl_devices.end());
-#endif
-        auto udp_devices = udp->GetInputDevices();
-        devices.insert(devices.end(), udp_devices.begin(), udp_devices.end());
-        auto gcpad_devices = gcadapter->GetInputDevices();
-        devices.insert(devices.end(), gcpad_devices.begin(), gcpad_devices.end());
-        return devices;
+        return {};
     }
 
     [[nodiscard]] AnalogMapping GetAnalogMappingForDevice(
@@ -128,17 +33,6 @@ struct InputSubsystem::Impl {
         if (!params.Has("class") || params.Get("class", "") == "any") {
             return {};
         }
-        if (params.Get("class", "") == "gcpad") {
-            return gcadapter->GetAnalogMappingForDevice(params);
-        }
-        if (params.Get("class", "") == "tas") {
-            return tas->GetAnalogMappingForDevice(params);
-        }
-#ifdef HAVE_SDL2
-        if (params.Get("class", "") == "sdl") {
-            return sdl->GetAnalogMappingForDevice(params);
-        }
-#endif
         return {};
     }
 
@@ -147,17 +41,6 @@ struct InputSubsystem::Impl {
         if (!params.Has("class") || params.Get("class", "") == "any") {
             return {};
         }
-        if (params.Get("class", "") == "gcpad") {
-            return gcadapter->GetButtonMappingForDevice(params);
-        }
-        if (params.Get("class", "") == "tas") {
-            return tas->GetButtonMappingForDevice(params);
-        }
-#ifdef HAVE_SDL2
-        if (params.Get("class", "") == "sdl") {
-            return sdl->GetButtonMappingForDevice(params);
-        }
-#endif
         return {};
     }
 
@@ -166,37 +49,9 @@ struct InputSubsystem::Impl {
         if (!params.Has("class") || params.Get("class", "") == "any") {
             return {};
         }
-        if (params.Get("class", "") == "cemuhookudp") {
-            // TODO return the correct motion device
-            return {};
-        }
-#ifdef HAVE_SDL2
-        if (params.Get("class", "") == "sdl") {
-            return sdl->GetMotionMappingForDevice(params);
-        }
-#endif
         return {};
     }
 
-    std::shared_ptr<Keyboard> keyboard;
-#ifdef HAVE_SDL2
-    std::unique_ptr<SDL::State> sdl;
-#endif
-    std::shared_ptr<GCButtonFactory> gcbuttons;
-    std::shared_ptr<GCAnalogFactory> gcanalog;
-    std::shared_ptr<GCVibrationFactory> gcvibration;
-    std::shared_ptr<UDPMotionFactory> udpmotion;
-    std::shared_ptr<UDPTouchFactory> udptouch;
-    std::shared_ptr<MouseButtonFactory> mousebuttons;
-    std::shared_ptr<MouseAnalogFactory> mouseanalog;
-    std::shared_ptr<MouseMotionFactory> mousemotion;
-    std::shared_ptr<MouseTouchFactory> mousetouch;
-    std::shared_ptr<TasButtonFactory> tasbuttons;
-    std::shared_ptr<TasAnalogFactory> tasanalog;
-    std::shared_ptr<CemuhookUDP::Client> udp;
-    std::shared_ptr<GCAdapter::Adapter> gcadapter;
-    std::shared_ptr<MouseInput::Mouse> mouse;
-    std::shared_ptr<TasInput::Tas> tas;
 };
 
 InputSubsystem::InputSubsystem() : impl{std::make_unique<Impl>()} {}
@@ -211,30 +66,6 @@ void InputSubsystem::Shutdown() {
     impl->Shutdown();
 }
 
-Keyboard* InputSubsystem::GetKeyboard() {
-    return impl->keyboard.get();
-}
-
-const Keyboard* InputSubsystem::GetKeyboard() const {
-    return impl->keyboard.get();
-}
-
-MouseInput::Mouse* InputSubsystem::GetMouse() {
-    return impl->mouse.get();
-}
-
-const MouseInput::Mouse* InputSubsystem::GetMouse() const {
-    return impl->mouse.get();
-}
-
-TasInput::Tas* InputSubsystem::GetTas() {
-    return impl->tas.get();
-}
-
-const TasInput::Tas* InputSubsystem::GetTas() const {
-    return impl->tas.get();
-}
-
 std::vector<Common::ParamPackage> InputSubsystem::GetInputDevices() const {
     return impl->GetInputDevices();
 }
@@ -251,100 +82,12 @@ MotionMapping InputSubsystem::GetMotionMappingForDevice(const Common::ParamPacka
     return impl->GetMotionMappingForDevice(device);
 }
 
-GCAnalogFactory* InputSubsystem::GetGCAnalogs() {
-    return impl->gcanalog.get();
-}
-
-const GCAnalogFactory* InputSubsystem::GetGCAnalogs() const {
-    return impl->gcanalog.get();
-}
-
-GCButtonFactory* InputSubsystem::GetGCButtons() {
-    return impl->gcbuttons.get();
-}
-
-const GCButtonFactory* InputSubsystem::GetGCButtons() const {
-    return impl->gcbuttons.get();
-}
-
-UDPMotionFactory* InputSubsystem::GetUDPMotions() {
-    return impl->udpmotion.get();
-}
-
-const UDPMotionFactory* InputSubsystem::GetUDPMotions() const {
-    return impl->udpmotion.get();
-}
-
-UDPTouchFactory* InputSubsystem::GetUDPTouch() {
-    return impl->udptouch.get();
-}
-
-const UDPTouchFactory* InputSubsystem::GetUDPTouch() const {
-    return impl->udptouch.get();
-}
-
-MouseButtonFactory* InputSubsystem::GetMouseButtons() {
-    return impl->mousebuttons.get();
-}
-
-const MouseButtonFactory* InputSubsystem::GetMouseButtons() const {
-    return impl->mousebuttons.get();
-}
-
-MouseAnalogFactory* InputSubsystem::GetMouseAnalogs() {
-    return impl->mouseanalog.get();
-}
-
-const MouseAnalogFactory* InputSubsystem::GetMouseAnalogs() const {
-    return impl->mouseanalog.get();
-}
-
-MouseMotionFactory* InputSubsystem::GetMouseMotions() {
-    return impl->mousemotion.get();
-}
-
-const MouseMotionFactory* InputSubsystem::GetMouseMotions() const {
-    return impl->mousemotion.get();
-}
-
-MouseTouchFactory* InputSubsystem::GetMouseTouch() {
-    return impl->mousetouch.get();
-}
-
-const MouseTouchFactory* InputSubsystem::GetMouseTouch() const {
-    return impl->mousetouch.get();
-}
-
-TasButtonFactory* InputSubsystem::GetTasButtons() {
-    return impl->tasbuttons.get();
-}
-
-const TasButtonFactory* InputSubsystem::GetTasButtons() const {
-    return impl->tasbuttons.get();
-}
-
-TasAnalogFactory* InputSubsystem::GetTasAnalogs() {
-    return impl->tasanalog.get();
-}
-
-const TasAnalogFactory* InputSubsystem::GetTasAnalogs() const {
-    return impl->tasanalog.get();
-}
-
 void InputSubsystem::ReloadInputDevices() {
-    if (!impl->udp) {
-        return;
-    }
-    impl->udp->ReloadSockets();
 }
 
-std::vector<std::unique_ptr<Polling::DevicePoller>> InputSubsystem::GetPollers(
-    [[maybe_unused]] Polling::DeviceType type) const {
-#ifdef HAVE_SDL2
-    return impl->sdl->GetPollers(type);
-#else
+std::vector<std::unique_ptr<Polling::DevicePoller>> InputSubsystem::GetPollers([
+    [maybe_unused]] Polling::DeviceType type) const {
     return {};
-#endif
 }
 
 std::string GenerateKeyboardParam(int key_code) {
diff --git a/src/input_common/main.h b/src/input_common/main.h
index eb247e1641..b504ebe54a 100644
--- a/src/input_common/main.h
+++ b/src/input_common/main.h
@@ -63,18 +63,6 @@ public:
 };
 } // namespace Polling
 
-class GCAnalogFactory;
-class GCButtonFactory;
-class UDPMotionFactory;
-class UDPTouchFactory;
-class MouseButtonFactory;
-class MouseAnalogFactory;
-class MouseMotionFactory;
-class MouseTouchFactory;
-class TasButtonFactory;
-class TasAnalogFactory;
-class Keyboard;
-
 /**
  * Given a ParamPackage for a Device returned from `GetInputDevices`, attempt to get the default
  * mapping for the device. This is currently only implemented for the SDL backend devices.
@@ -100,23 +88,6 @@ public:
     /// Unregisters all built-in input device factories and shuts them down.
     void Shutdown();
 
-    /// Retrieves the underlying keyboard device.
-    [[nodiscard]] Keyboard* GetKeyboard();
-
-    /// Retrieves the underlying keyboard device.
-    [[nodiscard]] const Keyboard* GetKeyboard() const;
-
-    /// Retrieves the underlying mouse device.
-    [[nodiscard]] MouseInput::Mouse* GetMouse();
-
-    /// Retrieves the underlying mouse device.
-    [[nodiscard]] const MouseInput::Mouse* GetMouse() const;
-
-    /// Retrieves the underlying tas device.
-    [[nodiscard]] TasInput::Tas* GetTas();
-
-    /// Retrieves the underlying tas device.
-    [[nodiscard]] const TasInput::Tas* GetTas() const;
     /**
      * Returns all available input devices that this Factory can create a new device with.
      * Each returned ParamPackage should have a `display` field used for display, a class field for
@@ -134,66 +105,6 @@ public:
     /// Retrieves the motion mappings for the given device.
     [[nodiscard]] MotionMapping GetMotionMappingForDevice(const Common::ParamPackage& device) const;
 
-    /// Retrieves the underlying GameCube analog handler.
-    [[nodiscard]] GCAnalogFactory* GetGCAnalogs();
-
-    /// Retrieves the underlying GameCube analog handler.
-    [[nodiscard]] const GCAnalogFactory* GetGCAnalogs() const;
-
-    /// Retrieves the underlying GameCube button handler.
-    [[nodiscard]] GCButtonFactory* GetGCButtons();
-
-    /// Retrieves the underlying GameCube button handler.
-    [[nodiscard]] const GCButtonFactory* GetGCButtons() const;
-
-    /// Retrieves the underlying udp motion handler.
-    [[nodiscard]] UDPMotionFactory* GetUDPMotions();
-
-    /// Retrieves the underlying udp motion handler.
-    [[nodiscard]] const UDPMotionFactory* GetUDPMotions() const;
-
-    /// Retrieves the underlying udp touch handler.
-    [[nodiscard]] UDPTouchFactory* GetUDPTouch();
-
-    /// Retrieves the underlying udp touch handler.
-    [[nodiscard]] const UDPTouchFactory* GetUDPTouch() const;
-
-    /// Retrieves the underlying mouse button handler.
-    [[nodiscard]] MouseButtonFactory* GetMouseButtons();
-
-    /// Retrieves the underlying mouse button handler.
-    [[nodiscard]] const MouseButtonFactory* GetMouseButtons() const;
-
-    /// Retrieves the underlying mouse analog handler.
-    [[nodiscard]] MouseAnalogFactory* GetMouseAnalogs();
-
-    /// Retrieves the underlying mouse analog handler.
-    [[nodiscard]] const MouseAnalogFactory* GetMouseAnalogs() const;
-
-    /// Retrieves the underlying mouse motion handler.
-    [[nodiscard]] MouseMotionFactory* GetMouseMotions();
-
-    /// Retrieves the underlying mouse motion handler.
-    [[nodiscard]] const MouseMotionFactory* GetMouseMotions() const;
-
-    /// Retrieves the underlying mouse touch handler.
-    [[nodiscard]] MouseTouchFactory* GetMouseTouch();
-
-    /// Retrieves the underlying mouse touch handler.
-    [[nodiscard]] const MouseTouchFactory* GetMouseTouch() const;
-
-    /// Retrieves the underlying tas button handler.
-    [[nodiscard]] TasButtonFactory* GetTasButtons();
-
-    /// Retrieves the underlying tas button handler.
-    [[nodiscard]] const TasButtonFactory* GetTasButtons() const;
-
-    /// Retrieves the underlying tas analogs handler.
-    [[nodiscard]] TasAnalogFactory* GetTasAnalogs();
-
-    /// Retrieves the underlying tas analogs handler.
-    [[nodiscard]] const TasAnalogFactory* GetTasAnalogs() const;
-
     /// Reloads the input devices
     void ReloadInputDevices();
 
diff --git a/src/yuzu/bootmanager.cpp b/src/yuzu/bootmanager.cpp
index fd0a130a3a..8a0ea90f9d 100644
--- a/src/yuzu/bootmanager.cpp
+++ b/src/yuzu/bootmanager.cpp
@@ -34,8 +34,6 @@
 #include "core/frontend/framebuffer_layout.h"
 #include "input_common/keyboard.h"
 #include "input_common/main.h"
-#include "input_common/mouse/mouse_input.h"
-#include "input_common/tas/tas_input.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
 #include "yuzu/bootmanager.h"
@@ -394,34 +392,34 @@ void GRenderWindow::closeEvent(QCloseEvent* event) {
 
 void GRenderWindow::keyPressEvent(QKeyEvent* event) {
     if (!event->isAutoRepeat()) {
-        input_subsystem->GetKeyboard()->PressKey(event->key());
+       // input_subsystem->GetKeyboard()->PressKey(event->key());
     }
 }
 
 void GRenderWindow::keyReleaseEvent(QKeyEvent* event) {
     if (!event->isAutoRepeat()) {
-        input_subsystem->GetKeyboard()->ReleaseKey(event->key());
-    }
-}
-
-MouseInput::MouseButton GRenderWindow::QtButtonToMouseButton(Qt::MouseButton button) {
-    switch (button) {
-    case Qt::LeftButton:
-        return MouseInput::MouseButton::Left;
-    case Qt::RightButton:
-        return MouseInput::MouseButton::Right;
-    case Qt::MiddleButton:
-        return MouseInput::MouseButton::Wheel;
-    case Qt::BackButton:
-        return MouseInput::MouseButton::Backward;
-    case Qt::ForwardButton:
-        return MouseInput::MouseButton::Forward;
-    case Qt::TaskButton:
-        return MouseInput::MouseButton::Task;
-    default:
-        return MouseInput::MouseButton::Extra;
-    }
-}
+       // input_subsystem->GetKeyboard()->ReleaseKey(event->key());
+    }
+}
+
+//MouseInput::MouseButton GRenderWindow::QtButtonToMouseButton(Qt::MouseButton button) {
+//    switch (button) {
+//    case Qt::LeftButton:
+//        return MouseInput::MouseButton::Left;
+//    case Qt::RightButton:
+//        return MouseInput::MouseButton::Right;
+//    case Qt::MiddleButton:
+//        return MouseInput::MouseButton::Wheel;
+//    case Qt::BackButton:
+//        return MouseInput::MouseButton::Backward;
+//    case Qt::ForwardButton:
+//        return MouseInput::MouseButton::Forward;
+//    case Qt::TaskButton:
+//        return MouseInput::MouseButton::Task;
+//    default:
+//        return MouseInput::MouseButton::Extra;
+//    }
+//}
 
 void GRenderWindow::mousePressEvent(QMouseEvent* event) {
     // Touch input is handled in TouchBeginEvent
@@ -432,8 +430,8 @@ void GRenderWindow::mousePressEvent(QMouseEvent* event) {
     // coordinates and map them to the current render area
     const auto pos = mapFromGlobal(QCursor::pos());
     const auto [x, y] = ScaleTouch(pos);
-    const auto button = QtButtonToMouseButton(event->button());
-    input_subsystem->GetMouse()->PressButton(x, y, button);
+    //const auto button = QtButtonToMouseButton(event->button());
+    //input_subsystem->GetMouse()->PressButton(x, y, button);
 
     if (event->button() == Qt::LeftButton) {
         this->TouchPressed(x, y, 0);
@@ -453,7 +451,7 @@ void GRenderWindow::mouseMoveEvent(QMouseEvent* event) {
     const auto [x, y] = ScaleTouch(pos);
     const int center_x = width() / 2;
     const int center_y = height() / 2;
-    input_subsystem->GetMouse()->MouseMove(x, y, center_x, center_y);
+    //input_subsystem->GetMouse()->MouseMove(x, y, center_x, center_y);
     this->TouchMoved(x, y, 0);
 
     if (Settings::values.mouse_panning) {
@@ -469,8 +467,8 @@ void GRenderWindow::mouseReleaseEvent(QMouseEvent* event) {
         return;
     }
 
-    const auto button = QtButtonToMouseButton(event->button());
-    input_subsystem->GetMouse()->ReleaseButton(button);
+    //const auto button = QtButtonToMouseButton(event->button());
+    //input_subsystem->GetMouse()->ReleaseButton(button);
 
     if (event->button() == Qt::LeftButton) {
         this->TouchReleased(0);
@@ -558,8 +556,8 @@ bool GRenderWindow::event(QEvent* event) {
 
 void GRenderWindow::focusOutEvent(QFocusEvent* event) {
     QWidget::focusOutEvent(event);
-    input_subsystem->GetKeyboard()->ReleaseAllKeys();
-    input_subsystem->GetMouse()->ReleaseAllButtons();
+    //input_subsystem->GetKeyboard()->ReleaseAllKeys();
+    //input_subsystem->GetMouse()->ReleaseAllButtons();
     this->TouchReleased(0);
 }
 
diff --git a/src/yuzu/bootmanager.h b/src/yuzu/bootmanager.h
index 061e3605f3..f0784046bd 100644
--- a/src/yuzu/bootmanager.h
+++ b/src/yuzu/bootmanager.h
@@ -165,7 +165,7 @@ public:
     void keyReleaseEvent(QKeyEvent* event) override;
 
     /// Converts a Qt mouse button into MouseInput mouse button
-    static MouseInput::MouseButton QtButtonToMouseButton(Qt::MouseButton button);
+    // static MouseInput::MouseButton QtButtonToMouseButton(Qt::MouseButton button);
 
     void mousePressEvent(QMouseEvent* event) override;
     void mouseMoveEvent(QMouseEvent* event) override;
diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp
index 3aab5d5f8f..09f0b219bf 100644
--- a/src/yuzu/configuration/configure_input_player.cpp
+++ b/src/yuzu/configuration/configure_input_player.cpp
@@ -16,10 +16,7 @@
 #include "core/hle/service/hid/controllers/npad.h"
 #include "core/hle/service/hid/hid.h"
 #include "core/hle/service/sm/sm.h"
-#include "input_common/gcadapter/gc_poller.h"
 #include "input_common/main.h"
-#include "input_common/mouse/mouse_poller.h"
-#include "input_common/udp/udp.h"
 #include "ui_configure_input_player.h"
 #include "yuzu/bootmanager.h"
 #include "yuzu/configuration/config.h"
@@ -564,55 +561,6 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
 
     connect(poll_timer.get(), &QTimer::timeout, [this] {
         Common::ParamPackage params;
-        if (input_subsystem->GetGCButtons()->IsPolling()) {
-            params = input_subsystem->GetGCButtons()->GetNextInput();
-            if (params.Has("engine") && IsInputAcceptable(params)) {
-                SetPollingResult(params, false);
-                return;
-            }
-        }
-        if (input_subsystem->GetGCAnalogs()->IsPolling()) {
-            params = input_subsystem->GetGCAnalogs()->GetNextInput();
-            if (params.Has("engine") && IsInputAcceptable(params)) {
-                SetPollingResult(params, false);
-                return;
-            }
-        }
-        if (input_subsystem->GetUDPMotions()->IsPolling()) {
-            params = input_subsystem->GetUDPMotions()->GetNextInput();
-            if (params.Has("engine")) {
-                SetPollingResult(params, false);
-                return;
-            }
-        }
-        if (input_subsystem->GetMouseButtons()->IsPolling()) {
-            params = input_subsystem->GetMouseButtons()->GetNextInput();
-            if (params.Has("engine") && IsInputAcceptable(params)) {
-                SetPollingResult(params, false);
-                return;
-            }
-        }
-        if (input_subsystem->GetMouseAnalogs()->IsPolling()) {
-            params = input_subsystem->GetMouseAnalogs()->GetNextInput();
-            if (params.Has("engine") && IsInputAcceptable(params)) {
-                SetPollingResult(params, false);
-                return;
-            }
-        }
-        if (input_subsystem->GetMouseMotions()->IsPolling()) {
-            params = input_subsystem->GetMouseMotions()->GetNextInput();
-            if (params.Has("engine") && IsInputAcceptable(params)) {
-                SetPollingResult(params, false);
-                return;
-            }
-        }
-        if (input_subsystem->GetMouseTouch()->IsPolling()) {
-            params = input_subsystem->GetMouseTouch()->GetNextInput();
-            if (params.Has("engine") && IsInputAcceptable(params)) {
-                SetPollingResult(params, false);
-                return;
-            }
-        }
         for (auto& poller : device_pollers) {
             params = poller->GetNextInput();
             if (params.Has("engine") && IsInputAcceptable(params)) {
@@ -1353,25 +1301,6 @@ void ConfigureInputPlayer::HandleClick(
     QWidget::grabMouse();
     QWidget::grabKeyboard();
 
-    if (type == InputCommon::Polling::DeviceType::Button) {
-        input_subsystem->GetGCButtons()->BeginConfiguration();
-    } else {
-        input_subsystem->GetGCAnalogs()->BeginConfiguration();
-    }
-
-    if (type == InputCommon::Polling::DeviceType::Motion) {
-        input_subsystem->GetUDPMotions()->BeginConfiguration();
-    }
-
-    if (type == InputCommon::Polling::DeviceType::Button) {
-        input_subsystem->GetMouseButtons()->BeginConfiguration();
-    } else if (type == InputCommon::Polling::DeviceType::AnalogPreferred) {
-        input_subsystem->GetMouseAnalogs()->BeginConfiguration();
-    } else if (type == InputCommon::Polling::DeviceType::Motion) {
-        input_subsystem->GetMouseMotions()->BeginConfiguration();
-    } else {
-        input_subsystem->GetMouseTouch()->BeginConfiguration();
-    }
 
     if (type == InputCommon::Polling::DeviceType::Button) {
         ui->controllerFrame->BeginMappingButton(button_id);
@@ -1393,15 +1322,6 @@ void ConfigureInputPlayer::SetPollingResult(const Common::ParamPackage& params,
     QWidget::releaseMouse();
     QWidget::releaseKeyboard();
 
-    input_subsystem->GetGCButtons()->EndConfiguration();
-    input_subsystem->GetGCAnalogs()->EndConfiguration();
-
-    input_subsystem->GetUDPMotions()->EndConfiguration();
-
-    input_subsystem->GetMouseButtons()->EndConfiguration();
-    input_subsystem->GetMouseAnalogs()->EndConfiguration();
-    input_subsystem->GetMouseMotions()->EndConfiguration();
-    input_subsystem->GetMouseTouch()->EndConfiguration();
 
     if (!abort) {
         (*input_setter)(params);
@@ -1435,8 +1355,7 @@ void ConfigureInputPlayer::mousePressEvent(QMouseEvent* event) {
         return;
     }
 
-    const auto button = GRenderWindow::QtButtonToMouseButton(event->button());
-    input_subsystem->GetMouse()->PressButton(0, 0, button);
+    //const auto button = GRenderWindow::QtButtonToMouseButton(event->button());
 }
 
 void ConfigureInputPlayer::keyPressEvent(QKeyEvent* event) {
diff --git a/src/yuzu/debugger/controller.cpp b/src/yuzu/debugger/controller.cpp
index 5a844409b1..0e190a3d58 100644
--- a/src/yuzu/debugger/controller.cpp
+++ b/src/yuzu/debugger/controller.cpp
@@ -7,7 +7,6 @@
 #include <QString>
 #include "common/settings.h"
 #include "input_common/main.h"
-#include "input_common/tas/tas_input.h"
 #include "yuzu/configuration/configure_input_player_widget.h"
 #include "yuzu/debugger/controller.h"
 
@@ -81,5 +80,5 @@ void ControllerDialog::InputController(ControllerInput input) {
         buttons |= (btn ? 1U : 0U) << index;
         index++;
     }
-    input_subsystem->GetTas()->RecordInput(buttons, input.axis_values);
+    //input_subsystem->GetTas()->RecordInput(buttons, input.axis_values);
 }
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index 88e84e8f74..663760a1ea 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -2969,15 +2969,15 @@ void GMainWindow::UpdateWindowTitle(std::string_view title_name, std::string_vie
 }
 
 QString GMainWindow::GetTasStateDescription() const {
-    auto [tas_status, current_tas_frame, total_tas_frames] = input_subsystem->GetTas()->GetStatus();
-    switch (tas_status) {
-    case TasInput::TasState::Running:
-        return tr("TAS state: Running %1/%2").arg(current_tas_frame).arg(total_tas_frames);
-    case TasInput::TasState::Recording:
-        return tr("TAS state: Recording %1").arg(total_tas_frames);
-    case TasInput::TasState::Stopped:
-        return tr("TAS state: Idle %1/%2").arg(current_tas_frame).arg(total_tas_frames);
-    default:
+    //auto [tas_status, current_tas_frame, total_tas_frames] = input_subsystem->GetTas()->GetStatus();
+    //switch (tas_status) {
+    //case TasInput::TasState::Running:
+    //    return tr("TAS state: Running %1/%2").arg(current_tas_frame).arg(total_tas_frames);
+    //case TasInput::TasState::Recording:
+    //    return tr("TAS state: Recording %1").arg(total_tas_frames);
+    //case TasInput::TasState::Stopped:
+    //    return tr("TAS state: Idle %1/%2").arg(current_tas_frame).arg(total_tas_frames);
+    //default:
         return tr("TAS State: Invalid");
     }
 }
-- 
cgit v1.2.3


From 547a1e6dc968ea761fd14672d88ecf0d829d74ad Mon Sep 17 00:00:00 2001
From: german77 <juangerman-13@hotmail.com>
Date: Mon, 20 Sep 2021 17:43:13 -0500
Subject: input_common: Rewrite main and add the new drivers

---
 src/input_common/main.cpp | 290 ++++++++++++++++++++++++++++++++++++++++++++--
 src/input_common/main.h   |  89 ++++++++------
 2 files changed, 330 insertions(+), 49 deletions(-)

(limited to 'src/input_common/main.cpp')

diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index da501b6ccb..46ca6b76c8 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -4,54 +4,265 @@
 
 #include <memory>
 #include <thread>
+#include "common/input.h"
 #include "common/param_package.h"
-#include "common/settings.h"
+#include "input_common/drivers/gc_adapter.h"
+#include "input_common/drivers/keyboard.h"
+#include "input_common/drivers/mouse.h"
+#include "input_common/drivers/tas_input.h"
+#include "input_common/drivers/touch_screen.h"
+#include "input_common/drivers/udp_client.h"
+#include "input_common/helpers/stick_from_buttons.h"
+#include "input_common/helpers/touch_from_buttons.h"
+#include "input_common/input_engine.h"
+#include "input_common/input_mapping.h"
+#include "input_common/input_poller.h"
 #include "input_common/main.h"
 #ifdef HAVE_SDL2
-#include "input_common/sdl/sdl.h"
+#include "input_common/drivers/sdl_driver.h"
 #endif
 
 namespace InputCommon {
 
 struct InputSubsystem::Impl {
     void Initialize() {
+        mapping_factory = std::make_shared<MappingFactory>();
+        MappingCallback mapping_callback{[this](MappingData data) { RegisterInput(data); }};
+
+        keyboard = std::make_shared<Keyboard>("keyboard");
+        keyboard->SetMappingCallback(mapping_callback);
+        keyboard_factory = std::make_shared<InputFactory>(keyboard);
+        Input::RegisterFactory<Input::InputDevice>(keyboard->GetEngineName(), keyboard_factory);
+
+        mouse = std::make_shared<Mouse>("mouse");
+        mouse->SetMappingCallback(mapping_callback);
+        mouse_factory = std::make_shared<InputFactory>(mouse);
+        Input::RegisterFactory<Input::InputDevice>(mouse->GetEngineName(), mouse_factory);
+
+        touch_screen = std::make_shared<TouchScreen>("touch");
+        touch_screen_factory = std::make_shared<InputFactory>(touch_screen);
+        Input::RegisterFactory<Input::InputDevice>(touch_screen->GetEngineName(),
+                                                   touch_screen_factory);
+
+        gcadapter = std::make_shared<GCAdapter>("gcpad");
+        gcadapter->SetMappingCallback(mapping_callback);
+        gcadapter_factory = std::make_shared<InputFactory>(gcadapter);
+        Input::RegisterFactory<Input::InputDevice>(gcadapter->GetEngineName(), gcadapter_factory);
+
+        udp_client = std::make_shared<CemuhookUDP::UDPClient>("cemuhookudp");
+        udp_client->SetMappingCallback(mapping_callback);
+        udp_client_factory = std::make_shared<InputFactory>(udp_client);
+        Input::RegisterFactory<Input::InputDevice>(udp_client->GetEngineName(), udp_client_factory);
+
+        tas_input = std::make_shared<TasInput::Tas>("tas");
+        tas_input->SetMappingCallback(mapping_callback);
+        tas_input_factory = std::make_shared<InputFactory>(tas_input);
+        Input::RegisterFactory<Input::InputDevice>(tas_input->GetEngineName(), tas_input_factory);
+
+#ifdef HAVE_SDL2
+        sdl = std::make_shared<SDLDriver>("sdl");
+        sdl->SetMappingCallback(mapping_callback);
+        sdl_factory = std::make_shared<InputFactory>(sdl);
+        Input::RegisterFactory<Input::InputDevice>(sdl->GetEngineName(), sdl_factory);
+#endif
+
+        Input::RegisterFactory<Input::InputDevice>("touch_from_button",
+                                                   std::make_shared<TouchFromButton>());
+        Input::RegisterFactory<Input::InputDevice>("analog_from_button",
+                                                   std::make_shared<StickFromButton>());
     }
 
     void Shutdown() {
+        Input::UnregisterFactory<Input::InputDevice>(keyboard->GetEngineName());
+        keyboard.reset();
+
+        Input::UnregisterFactory<Input::InputDevice>(mouse->GetEngineName());
+        mouse.reset();
+
+        Input::UnregisterFactory<Input::InputDevice>(touch_screen->GetEngineName());
+        touch_screen.reset();
+
+        Input::UnregisterFactory<Input::InputDevice>(gcadapter->GetEngineName());
+        gcadapter.reset();
+
+        Input::UnregisterFactory<Input::InputDevice>(udp_client->GetEngineName());
+        udp_client.reset();
+
+        Input::UnregisterFactory<Input::InputDevice>(tas_input->GetEngineName());
+        tas_input.reset();
+
+#ifdef HAVE_SDL2
+        Input::UnregisterFactory<Input::InputDevice>(sdl->GetEngineName());
+        sdl.reset();
+#endif
+
+        Input::UnregisterFactory<Input::InputDevice>("touch_from_button");
+        Input::UnregisterFactory<Input::InputDevice>("analog_from_button");
     }
 
     [[nodiscard]] std::vector<Common::ParamPackage> GetInputDevices() const {
         std::vector<Common::ParamPackage> devices = {
-            Common::ParamPackage{{"display", "Any"}, {"class", "any"}},
-            Common::ParamPackage{{"display", "Keyboard/Mouse"}, {"class", "keyboard"}},
+            Common::ParamPackage{{"display", "Any"}, {"engine", "any"}},
         };
-        return {};
+
+        auto keyboard_devices = keyboard->GetInputDevices();
+        devices.insert(devices.end(), keyboard_devices.begin(), keyboard_devices.end());
+        auto mouse_devices = mouse->GetInputDevices();
+        devices.insert(devices.end(), mouse_devices.begin(), mouse_devices.end());
+        auto gcadapter_devices = gcadapter->GetInputDevices();
+        devices.insert(devices.end(), gcadapter_devices.begin(), gcadapter_devices.end());
+        auto tas_input_devices = tas_input->GetInputDevices();
+        devices.insert(devices.end(), tas_input_devices.begin(), tas_input_devices.end());
+#ifdef HAVE_SDL2
+        auto sdl_devices = sdl->GetInputDevices();
+        devices.insert(devices.end(), sdl_devices.begin(), sdl_devices.end());
+#endif
+
+        return devices;
     }
 
     [[nodiscard]] AnalogMapping GetAnalogMappingForDevice(
         const Common::ParamPackage& params) const {
-        if (!params.Has("class") || params.Get("class", "") == "any") {
+        if (!params.Has("engine") || params.Get("engine", "") == "any") {
             return {};
         }
+        const std::string engine = params.Get("engine", "");
+        if (engine == gcadapter->GetEngineName()) {
+            return gcadapter->GetAnalogMappingForDevice(params);
+        }
+        if (engine == tas_input->GetEngineName()) {
+            return tas_input->GetAnalogMappingForDevice(params);
+        }
+#ifdef HAVE_SDL2
+        if (engine == sdl->GetEngineName()) {
+            return sdl->GetAnalogMappingForDevice(params);
+        }
+#endif
         return {};
     }
 
     [[nodiscard]] ButtonMapping GetButtonMappingForDevice(
         const Common::ParamPackage& params) const {
-        if (!params.Has("class") || params.Get("class", "") == "any") {
+        if (!params.Has("engine") || params.Get("engine", "") == "any") {
             return {};
         }
+        const std::string engine = params.Get("engine", "");
+        if (engine == gcadapter->GetEngineName()) {
+            return gcadapter->GetButtonMappingForDevice(params);
+        }
+        if (engine == tas_input->GetEngineName()) {
+            return tas_input->GetButtonMappingForDevice(params);
+        }
+#ifdef HAVE_SDL2
+        if (engine == sdl->GetEngineName()) {
+            return sdl->GetButtonMappingForDevice(params);
+        }
+#endif
         return {};
     }
 
     [[nodiscard]] MotionMapping GetMotionMappingForDevice(
         const Common::ParamPackage& params) const {
-        if (!params.Has("class") || params.Get("class", "") == "any") {
+        if (!params.Has("engine") || params.Get("engine", "") == "any") {
             return {};
         }
+        const std::string engine = params.Get("engine", "");
+        if (engine == gcadapter->GetEngineName()) {
+            return gcadapter->GetMotionMappingForDevice(params);
+        }
+#ifdef HAVE_SDL2
+        if (engine == sdl->GetEngineName()) {
+            return sdl->GetMotionMappingForDevice(params);
+        }
+#endif
         return {};
     }
 
+    std::string GetButtonName(const Common::ParamPackage& params) const {
+        if (!params.Has("engine") || params.Get("engine", "") == "any") {
+            return "Unknown";
+        }
+        const std::string engine = params.Get("engine", "");
+        if (engine == mouse->GetEngineName()) {
+            return mouse->GetUIName(params);
+        }
+        if (engine == gcadapter->GetEngineName()) {
+            return gcadapter->GetUIName(params);
+        }
+        if (engine == udp_client->GetEngineName()) {
+            return udp_client->GetUIName(params);
+        }
+        if (engine == tas_input->GetEngineName()) {
+            return tas_input->GetUIName(params);
+        }
+#ifdef HAVE_SDL2
+        if (engine == sdl->GetEngineName()) {
+            return sdl->GetUIName(params);
+        }
+#endif
+        return "Bad engine";
+    }
+
+    bool IsController(const Common::ParamPackage& params) {
+        const std::string engine = params.Get("engine", "");
+        if (engine == mouse->GetEngineName()) {
+            return true;
+        }
+        if (engine == gcadapter->GetEngineName()) {
+            return true;
+        }
+        if (engine == tas_input->GetEngineName()) {
+            return true;
+        }
+#ifdef HAVE_SDL2
+        if (engine == sdl->GetEngineName()) {
+            return true;
+        }
+#endif
+        return false;
+    }
+
+    void BeginConfiguration() {
+        keyboard->BeginConfiguration();
+        mouse->BeginConfiguration();
+        gcadapter->BeginConfiguration();
+        udp_client->BeginConfiguration();
+#ifdef HAVE_SDL2
+        sdl->BeginConfiguration();
+#endif
+    }
+
+    void EndConfiguration() {
+        keyboard->EndConfiguration();
+        mouse->EndConfiguration();
+        gcadapter->EndConfiguration();
+        udp_client->EndConfiguration();
+#ifdef HAVE_SDL2
+        sdl->EndConfiguration();
+#endif
+    }
+
+    void RegisterInput(MappingData data) {
+        mapping_factory->RegisterInput(data);
+    }
+
+    std::shared_ptr<MappingFactory> mapping_factory;
+    std::shared_ptr<Keyboard> keyboard;
+    std::shared_ptr<InputFactory> keyboard_factory;
+    std::shared_ptr<Mouse> mouse;
+    std::shared_ptr<InputFactory> mouse_factory;
+    std::shared_ptr<GCAdapter> gcadapter;
+    std::shared_ptr<InputFactory> gcadapter_factory;
+    std::shared_ptr<TouchScreen> touch_screen;
+    std::shared_ptr<InputFactory> touch_screen_factory;
+    std::shared_ptr<CemuhookUDP::UDPClient> udp_client;
+    std::shared_ptr<InputFactory> udp_client_factory;
+    std::shared_ptr<TasInput::Tas> tas_input;
+    std::shared_ptr<InputFactory> tas_input_factory;
+#ifdef HAVE_SDL2
+    std::shared_ptr<SDLDriver> sdl;
+    std::shared_ptr<InputFactory> sdl_factory;
+#endif
 };
 
 InputSubsystem::InputSubsystem() : impl{std::make_unique<Impl>()} {}
@@ -66,6 +277,38 @@ void InputSubsystem::Shutdown() {
     impl->Shutdown();
 }
 
+Keyboard* InputSubsystem::GetKeyboard() {
+    return impl->keyboard.get();
+}
+
+const Keyboard* InputSubsystem::GetKeyboard() const {
+    return impl->keyboard.get();
+}
+
+Mouse* InputSubsystem::GetMouse() {
+    return impl->mouse.get();
+}
+
+const Mouse* InputSubsystem::GetMouse() const {
+    return impl->mouse.get();
+}
+
+TouchScreen* InputSubsystem::GetTouchScreen() {
+    return impl->touch_screen.get();
+}
+
+const TouchScreen* InputSubsystem::GetTouchScreen() const {
+    return impl->touch_screen.get();
+}
+
+TasInput::Tas* InputSubsystem::GetTas() {
+    return impl->tas_input.get();
+}
+
+const TasInput::Tas* InputSubsystem::GetTas() const {
+    return impl->tas_input.get();
+}
+
 std::vector<Common::ParamPackage> InputSubsystem::GetInputDevices() const {
     return impl->GetInputDevices();
 }
@@ -82,12 +325,37 @@ MotionMapping InputSubsystem::GetMotionMappingForDevice(const Common::ParamPacka
     return impl->GetMotionMappingForDevice(device);
 }
 
+std::string InputSubsystem::GetButtonName(const Common::ParamPackage& params) const {
+    const std::string toggle = params.Get("toggle", false) ? "~" : "";
+    const std::string inverted = params.Get("inverted", false) ? "!" : "";
+    const std::string button_name = impl->GetButtonName(params);
+    std::string axis_direction = "";
+    if (params.Has("axis")) {
+        axis_direction = params.Get("invert", "+");
+    }
+    return fmt::format("{}{}{}{}", toggle, inverted, button_name, axis_direction);
+}
+
+bool InputSubsystem::IsController(const Common::ParamPackage& params) const {
+    return impl->IsController(params);
+}
+
 void InputSubsystem::ReloadInputDevices() {
+    impl->udp_client.get()->ReloadSockets();
+}
+
+void InputSubsystem::BeginMapping(Polling::InputType type) {
+    impl->BeginConfiguration();
+    impl->mapping_factory->BeginMapping(type);
+}
+
+const Common::ParamPackage InputSubsystem::GetNextInput() const {
+    return impl->mapping_factory->GetNextInput();
 }
 
-std::vector<std::unique_ptr<Polling::DevicePoller>> InputSubsystem::GetPollers([
-    [maybe_unused]] Polling::DeviceType type) const {
-    return {};
+void InputSubsystem::StopMapping() const {
+    impl->EndConfiguration();
+    impl->mapping_factory->StopMapping();
 }
 
 std::string GenerateKeyboardParam(int key_code) {
diff --git a/src/input_common/main.h b/src/input_common/main.h
index b504ebe54a..a4a24d076e 100644
--- a/src/input_common/main.h
+++ b/src/input_common/main.h
@@ -25,47 +25,26 @@ namespace Settings::NativeMotion {
 enum Values : int;
 }
 
-namespace MouseInput {
+namespace InputCommon {
+class Keyboard;
 class Mouse;
-}
+class TouchScreen;
+struct MappingData;
+} // namespace InputCommon
 
-namespace TasInput {
+namespace InputCommon::TasInput {
 class Tas;
-}
+} // namespace InputCommon::TasInput
 
 namespace InputCommon {
 namespace Polling {
-
-enum class DeviceType { Button, AnalogPreferred, Motion };
-
 /// Type of input desired for mapping purposes
 enum class InputType { None, Button, Stick, Motion, Touch };
-
-/**
- * A class that can be used to get inputs from an input device like controllers without having to
- * poll the device's status yourself
- */
-class DevicePoller {
-public:
-    virtual ~DevicePoller() = default;
-    /// Setup and start polling for inputs, should be called before GetNextInput
-    /// If a device_id is provided, events should be filtered to only include events from this
-    /// device id
-    virtual void Start(const std::string& device_id = "") = 0;
-    /// Stop polling
-    virtual void Stop() = 0;
-    /**
-     * Every call to this function returns the next input recorded since calling Start
-     * @return A ParamPackage of the recorded input, which can be used to create an InputDevice.
-     *         If there has been no input, the package is empty
-     */
-    virtual Common::ParamPackage GetNextInput() = 0;
-};
 } // namespace Polling
 
 /**
  * Given a ParamPackage for a Device returned from `GetInputDevices`, attempt to get the default
- * mapping for the device. This is currently only implemented for the SDL backend devices.
+ * mapping for the device.
  */
 using AnalogMapping = std::unordered_map<Settings::NativeAnalog::Values, Common::ParamPackage>;
 using ButtonMapping = std::unordered_map<Settings::NativeButton::Values, Common::ParamPackage>;
@@ -88,10 +67,34 @@ public:
     /// Unregisters all built-in input device factories and shuts them down.
     void Shutdown();
 
+    /// Retrieves the underlying keyboard device.
+    [[nodiscard]] Keyboard* GetKeyboard();
+
+    /// Retrieves the underlying keyboard device.
+    [[nodiscard]] const Keyboard* GetKeyboard() const;
+
+    /// Retrieves the underlying mouse device.
+    [[nodiscard]] Mouse* GetMouse();
+
+    /// Retrieves the underlying mouse device.
+    [[nodiscard]] const Mouse* GetMouse() const;
+
+    /// Retrieves the underlying touch screen device.
+    [[nodiscard]] TouchScreen* GetTouchScreen();
+
+    /// Retrieves the underlying touch screen device.
+    [[nodiscard]] const TouchScreen* GetTouchScreen() const;
+
+    /// Retrieves the underlying tas input device.
+    [[nodiscard]] TasInput::Tas* GetTas();
+
+    /// Retrieves the underlying  tas input  device.
+    [[nodiscard]] const TasInput::Tas* GetTas() const;
+
     /**
      * Returns all available input devices that this Factory can create a new device with.
-     * Each returned ParamPackage should have a `display` field used for display, a class field for
-     * backends to determine if this backend is meant to service the request and any other
+     * Each returned ParamPackage should have a `display` field used for display, a `engine` field
+     * for backends to determine if this backend is meant to service the request and any other
      * information needed to identify this in the backend later.
      */
     [[nodiscard]] std::vector<Common::ParamPackage> GetInputDevices() const;
@@ -105,23 +108,33 @@ public:
     /// Retrieves the motion mappings for the given device.
     [[nodiscard]] MotionMapping GetMotionMappingForDevice(const Common::ParamPackage& device) const;
 
-    /// Reloads the input devices
+    /// Returns a string contaning the name of the button from the input engine.
+    [[nodiscard]] std::string GetButtonName(const Common::ParamPackage& params) const;
+
+    /// Returns true if device is a controller.
+    [[nodiscard]] bool IsController(const Common::ParamPackage& params) const;
+
+    /// Reloads the input devices.
     void ReloadInputDevices();
 
-    /// Get all DevicePoller from all backends for a specific device type
-    [[nodiscard]] std::vector<std::unique_ptr<Polling::DevicePoller>> GetPollers(
-        Polling::DeviceType type) const;
+    /// Start polling from all backends for a desired input type.
+    void BeginMapping(Polling::InputType type);
+
+    /// Returns an input event with mapping information.
+    [[nodiscard]] const Common::ParamPackage GetNextInput() const;
+
+    /// Stop polling from all backends.
+    void StopMapping() const;
 
 private:
     struct Impl;
     std::unique_ptr<Impl> impl;
 };
 
-/// Generates a serialized param package for creating a keyboard button device
+/// Generates a serialized param package for creating a keyboard button device.
 std::string GenerateKeyboardParam(int key_code);
 
-/// Generates a serialized param package for creating an analog device taking input from keyboard
+/// Generates a serialized param package for creating an analog device taking input from keyboard.
 std::string GenerateAnalogParamFromKeys(int key_up, int key_down, int key_left, int key_right,
                                         int key_modifier, float modifier_scale);
-
 } // namespace InputCommon
-- 
cgit v1.2.3


From 66cf94709ae0d28d0c62d2745b3365fc18658cd5 Mon Sep 17 00:00:00 2001
From: german77 <juangerman-13@hotmail.com>
Date: Mon, 11 Oct 2021 00:43:11 -0500
Subject: core/hid: Add output devices

---
 src/common/input.h                                 |  39 +++++++
 src/core/hid/emulated_controller.cpp               | 119 ++++++++++++++++-----
 src/core/hid/emulated_controller.h                 |  13 ++-
 src/core/hid/hid_types.h                           |  18 ++++
 src/core/hle/service/hid/controllers/npad.cpp      |  27 +----
 src/core/hle/service/hid/controllers/npad.h        |  18 +---
 src/input_common/drivers/gc_adapter.cpp            |   8 +-
 src/input_common/drivers/gc_adapter.h              |   2 +-
 src/input_common/drivers/sdl_driver.cpp            |   8 +-
 src/input_common/drivers/sdl_driver.h              |   2 +-
 src/input_common/helpers/stick_from_buttons.cpp    |   3 +-
 src/input_common/helpers/stick_from_buttons.h      |   3 +-
 src/input_common/helpers/touch_from_buttons.cpp    |   4 +-
 src/input_common/input_engine.h                    |  18 ++--
 src/input_common/input_poller.cpp                  |  40 ++++++-
 src/input_common/input_poller.h                    |  28 ++++-
 src/input_common/main.cpp                          |  30 ++++--
 src/yuzu/configuration/configure_input_player.cpp  |   7 ++
 .../configure_input_player_widget.cpp              |  59 ++++------
 .../configuration/configure_input_player_widget.h  |  10 +-
 20 files changed, 312 insertions(+), 144 deletions(-)

(limited to 'src/input_common/main.cpp')

diff --git a/src/common/input.h b/src/common/input.h
index 6eefc55f9c..3a28b77a7b 100644
--- a/src/common/input.h
+++ b/src/common/input.h
@@ -38,6 +38,27 @@ enum class BatteryLevel {
     Charging,
 };
 
+enum class PollingMode {
+    Active,
+    Pasive,
+    Camera,
+    NCF,
+    IR,
+};
+
+enum class VibrationError {
+    None,
+    NotSupported,
+    Disabled,
+    Unknown,
+};
+
+enum class PollingError {
+    None,
+    NotSupported,
+    Unknown,
+};
+
 struct AnalogProperties {
     float deadzone{};
     float range{1.0f};
@@ -149,6 +170,24 @@ private:
     InputCallback callback;
 };
 
+/// An abstract class template for an output device (rumble, LED pattern, polling mode).
+class OutputDevice {
+public:
+    virtual ~OutputDevice() = default;
+
+    virtual void SetLED([[maybe_unused]] LedStatus led_status) {
+        return;
+    }
+
+    virtual VibrationError SetVibration([[maybe_unused]] VibrationStatus vibration_status) {
+        return VibrationError::NotSupported;
+    }
+
+    virtual PollingError SetPollingMode([[maybe_unused]] PollingMode polling_mode) {
+        return PollingError::NotSupported;
+    }
+};
+
 /// An abstract class template for a factory that can create input devices.
 template <typename InputDeviceType>
 class Factory {
diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index 4eb5d99bc3..b9d16657a5 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -66,12 +66,32 @@ void EmulatedController::ReloadFromSettings() {
     for (std::size_t index = 0; index < player.motions.size(); ++index) {
         motion_params[index] = Common::ParamPackage(player.motions[index]);
     }
+
+    controller.colors_state.left = {
+        .body = player.body_color_left,
+        .button = player.button_color_left,
+    };
+
+    controller.colors_state.right = {
+        .body = player.body_color_right,
+        .button = player.button_color_right,
+    };
+
+    controller.colors_state.fullkey = controller.colors_state.left;
+
+    SetNpadType(MapSettingsTypeToNPad(player.controller_type));
+
+    if (player.connected) {
+        Connect();
+    } else {
+        Disconnect();
+    }
+
     ReloadInput();
 }
 
 void EmulatedController::ReloadInput() {
     const auto player_index = NpadIdTypeToIndex(npad_id_type);
-    const auto& player = Settings::values.players.GetValue()[player_index];
     const auto left_side = button_params[Settings::NativeButton::ZL];
     const auto right_side = button_params[Settings::NativeButton::ZR];
 
@@ -90,21 +110,13 @@ void EmulatedController::ReloadInput() {
     trigger_devices[1] =
         Input::CreateDevice<Input::InputDevice>(button_params[Settings::NativeButton::ZR]);
 
-    controller.colors_state.left = {
-        .body = player.body_color_left,
-        .button = player.button_color_left,
-    };
-
-    controller.colors_state.right = {
-        .body = player.body_color_right,
-        .button = player.button_color_right,
-    };
-
-    controller.colors_state.fullkey = controller.colors_state.left;
-
     battery_devices[0] = Input::CreateDevice<Input::InputDevice>(left_side);
     battery_devices[1] = Input::CreateDevice<Input::InputDevice>(right_side);
 
+    button_params[Settings::NativeButton::ZL].Set("output",true);
+    output_devices[0] =
+        Input::CreateDevice<Input::OutputDevice>(button_params[Settings::NativeButton::ZL]);
+
     for (std::size_t index = 0; index < button_devices.size(); ++index) {
         if (!button_devices[index]) {
             continue;
@@ -149,14 +161,6 @@ void EmulatedController::ReloadInput() {
             [this, index](Input::CallbackStatus callback) { SetMotion(callback, index); }};
         motion_devices[index]->SetCallback(motion_callback);
     }
-
-    SetNpadType(MapSettingsTypeToNPad(player.controller_type));
-
-    if (player.connected) {
-        Connect();
-    } else {
-        Disconnect();
-    }
 }
 
 void EmulatedController::UnloadInput() {
@@ -197,7 +201,8 @@ void EmulatedController::SaveCurrentConfig() {
 
     const auto player_index = NpadIdTypeToIndex(npad_id_type);
     auto& player = Settings::values.players.GetValue()[player_index];
-
+    player.connected = is_connected;
+    player.controller_type = MapNPadToSettingsType(npad_type);
     for (std::size_t index = 0; index < player.buttons.size(); ++index) {
         player.buttons[index] = button_params[index].Serialize();
     }
@@ -601,13 +606,50 @@ void EmulatedController::SetBattery(Input::CallbackStatus callback, std::size_t
     TriggerOnChange(ControllerTriggerType::Battery);
 }
 
-bool EmulatedController::SetVibration([[maybe_unused]] std::size_t device_index,
-                                      [[maybe_unused]] VibrationValue vibration) {
-    return false;
+bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue vibration) {
+    if (!output_devices[device_index]) {
+        return false;
+    }
+
+    const Input::VibrationStatus status = {
+        .low_amplitude = vibration.high_amplitude,
+        .low_frequency = vibration.high_amplitude,
+        .high_amplitude = vibration.high_amplitude,
+        .high_frequency = vibration.high_amplitude,
+    };
+    return output_devices[device_index]->SetVibration(status) == Input::VibrationError::None;
+}
+
+bool EmulatedController::TestVibration(std::size_t device_index) {
+    if (!output_devices[device_index]) {
+        return false;
+    }
+
+    // Send a slight vibration to test for rumble support
+    constexpr Input::VibrationStatus status = {
+        .low_amplitude = 0.001f,
+        .low_frequency = 160.0f,
+        .high_amplitude = 0.001f,
+        .high_frequency = 320.0f,
+    };
+    return output_devices[device_index]->SetVibration(status) == Input::VibrationError::None;
 }
 
-int EmulatedController::TestVibration(std::size_t device_index) {
-    return 1;
+void EmulatedController::SetLedPattern() {
+    for (auto& device : output_devices) {
+        if (!device) {
+            continue;
+        }
+
+        const LedPattern pattern = GetLedPattern();
+        const Input::LedStatus status = {
+            .led_1 = pattern.position1 != 0,
+            .led_2 = pattern.position2 != 0,
+            .led_3 = pattern.position3 != 0,
+            .led_4 = pattern.position4 != 0,
+        };
+        device->SetLED(status);
+    }
 }
 
 void EmulatedController::Connect() {
@@ -655,6 +697,29 @@ void EmulatedController::SetNpadType(NpadType npad_type_) {
     TriggerOnChange(ControllerTriggerType::Type);
 }
 
+LedPattern EmulatedController::GetLedPattern() const {
+    switch (npad_id_type) {
+    case NpadIdType::Player1:
+        return LedPattern{1, 0, 0, 0};
+    case NpadIdType::Player2:
+        return LedPattern{1, 1, 0, 0};
+    case NpadIdType::Player3:
+        return LedPattern{1, 1, 1, 0};
+    case NpadIdType::Player4:
+        return LedPattern{1, 1, 1, 1};
+    case NpadIdType::Player5:
+        return LedPattern{1, 0, 0, 1};
+    case NpadIdType::Player6:
+        return LedPattern{1, 0, 1, 0};
+    case NpadIdType::Player7:
+        return LedPattern{1, 0, 1, 1};
+    case NpadIdType::Player8:
+        return LedPattern{0, 1, 1, 0};
+    default:
+        return LedPattern{0, 0, 0, 0};
+    }
+}
+
 ButtonValues EmulatedController::GetButtonsValues() const {
     return controller.button_values;
 }
diff --git a/src/core/hid/emulated_controller.h b/src/core/hid/emulated_controller.h
index 94db9b00be..322d2cab04 100644
--- a/src/core/hid/emulated_controller.h
+++ b/src/core/hid/emulated_controller.h
@@ -33,12 +33,14 @@ using ControllerMotionDevices =
 using TriggerDevices =
     std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeTrigger::NumTriggers>;
 using BatteryDevices = std::array<std::unique_ptr<Input::InputDevice>, 2>;
+using OutputDevices = std::array<std::unique_ptr<Input::OutputDevice>, 2>;
 
 using ButtonParams = std::array<Common::ParamPackage, Settings::NativeButton::NumButtons>;
 using StickParams = std::array<Common::ParamPackage, Settings::NativeAnalog::NumAnalogs>;
 using ControllerMotionParams = std::array<Common::ParamPackage, Settings::NativeMotion::NumMotions>;
 using TriggerParams = std::array<Common::ParamPackage, Settings::NativeTrigger::NumTriggers>;
 using BatteryParams = std::array<Common::ParamPackage, 2>;
+using OutputParams = std::array<Common::ParamPackage, 2>;
 
 using ButtonValues = std::array<Input::ButtonStatus, Settings::NativeButton::NumButtons>;
 using SticksValues = std::array<Input::StickStatus, Settings::NativeAnalog::NumAnalogs>;
@@ -94,6 +96,7 @@ struct ControllerStatus {
     ControllerColors colors_state{};
     BatteryLevelState battery_state{};
 };
+
 enum class ControllerTriggerType {
     Button,
     Stick,
@@ -137,6 +140,9 @@ public:
     /// Gets the NpadType for this controller.
     NpadType GetNpadType() const;
 
+    /// Gets the NpadType for this controller.
+    LedPattern GetLedPattern() const;
+
     void Connect();
     void Disconnect();
 
@@ -179,7 +185,9 @@ public:
     BatteryLevelState GetBattery() const;
 
     bool SetVibration(std::size_t device_index, VibrationValue vibration);
-    int TestVibration(std::size_t device_index);
+    bool TestVibration(std::size_t device_index);
+
+    void SetLedPattern();
 
     int SetCallback(ControllerUpdateCallback update_callback);
     void DeleteCallback(int key);
@@ -215,13 +223,14 @@ private:
     ControllerMotionParams motion_params;
     TriggerParams trigger_params;
     BatteryParams battery_params;
+    OutputParams output_params;
 
     ButtonDevices button_devices;
     StickDevices stick_devices;
     ControllerMotionDevices motion_devices;
     TriggerDevices trigger_devices;
     BatteryDevices battery_devices;
-    // VibrationDevices vibration_devices;
+    OutputDevices output_devices;
 
     mutable std::mutex mutex;
     std::unordered_map<int, ControllerUpdateCallback> callback_list;
diff --git a/src/core/hid/hid_types.h b/src/core/hid/hid_types.h
index d3f7930c93..f12a14cb8e 100644
--- a/src/core/hid/hid_types.h
+++ b/src/core/hid/hid_types.h
@@ -112,6 +112,8 @@ struct NpadStyleTag {
         BitField<7, 1, u32> lark;
         BitField<8, 1, u32> handheld_lark;
         BitField<9, 1, u32> lucia;
+        BitField<10, 1, u32> lagoon;
+        BitField<11, 1, u32> lager;
         BitField<29, 1, u32> system_ext;
         BitField<30, 1, u32> system;
     };
@@ -175,6 +177,22 @@ struct NpadPowerInfo {
 };
 static_assert(sizeof(NpadPowerInfo) == 0xC, "NpadPowerInfo is an invalid size");
 
+struct LedPattern {
+    explicit LedPattern(u64 light1, u64 light2, u64 light3, u64 light4) {
+        position1.Assign(light1);
+        position2.Assign(light2);
+        position3.Assign(light3);
+        position4.Assign(light4);
+    }
+    union {
+        u64 raw{};
+        BitField<0, 1, u64> position1;
+        BitField<1, 1, u64> position2;
+        BitField<2, 1, u64> position3;
+        BitField<3, 1, u64> position4;
+    };
+};
+
 // This is nn::hid::NpadButton
 enum class NpadButton : u64 {
     None = 0,
diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp
index 03cbd42f4d..a2e9ddf4d5 100644
--- a/src/core/hle/service/hid/controllers/npad.cpp
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@@ -796,7 +796,7 @@ void Controller_NPad::InitializeVibrationDeviceAtIndex(std::size_t npad_index,
     }
 
     controller.vibration[device_index].device_mounted =
-        controller.device->TestVibration(device_index) == 1;
+        controller.device->TestVibration(device_index);
 }
 
 void Controller_NPad::SetPermitVibrationSession(bool permit_vibration_session) {
@@ -954,31 +954,12 @@ bool Controller_NPad::SwapNpadAssignment(u32 npad_id_1, u32 npad_id_2) {
     return true;
 }
 
-Controller_NPad::LedPattern Controller_NPad::GetLedPattern(u32 npad_id) {
+Core::HID::LedPattern Controller_NPad::GetLedPattern(u32 npad_id) {
     if (npad_id == npad_id_list.back() || npad_id == npad_id_list[npad_id_list.size() - 2]) {
         // These are controllers without led patterns
-        return LedPattern{0, 0, 0, 0};
-    }
-    switch (npad_id) {
-    case 0:
-        return LedPattern{1, 0, 0, 0};
-    case 1:
-        return LedPattern{1, 1, 0, 0};
-    case 2:
-        return LedPattern{1, 1, 1, 0};
-    case 3:
-        return LedPattern{1, 1, 1, 1};
-    case 4:
-        return LedPattern{1, 0, 0, 1};
-    case 5:
-        return LedPattern{1, 0, 1, 0};
-    case 6:
-        return LedPattern{1, 0, 1, 1};
-    case 7:
-        return LedPattern{0, 1, 1, 0};
-    default:
-        return LedPattern{0, 0, 0, 0};
+        return Core::HID::LedPattern{0, 0, 0, 0};
     }
+    return controller_data[npad_id].device->GetLedPattern();
 }
 
 bool Controller_NPad::IsUnintendedHomeButtonInputProtectionEnabled(u32 npad_id) const {
diff --git a/src/core/hle/service/hid/controllers/npad.h b/src/core/hle/service/hid/controllers/npad.h
index 483cae5b68..b0e2f84308 100644
--- a/src/core/hle/service/hid/controllers/npad.h
+++ b/src/core/hle/service/hid/controllers/npad.h
@@ -115,22 +115,6 @@ public:
         .freq_high = 320.0f,
     };
 
-    struct LedPattern {
-        explicit LedPattern(u64 light1, u64 light2, u64 light3, u64 light4) {
-            position1.Assign(light1);
-            position2.Assign(light2);
-            position3.Assign(light3);
-            position4.Assign(light4);
-        }
-        union {
-            u64 raw{};
-            BitField<0, 1, u64> position1;
-            BitField<1, 1, u64> position2;
-            BitField<2, 1, u64> position3;
-            BitField<3, 1, u64> position4;
-        };
-    };
-
     void SetSupportedStyleSet(Core::HID::NpadStyleTag style_set);
     Core::HID::NpadStyleTag GetSupportedStyleSet() const;
 
@@ -186,7 +170,7 @@ public:
     void SetSixAxisFusionParameters(f32 parameter1, f32 parameter2);
     std::pair<f32, f32> GetSixAxisFusionParameters();
     void ResetSixAxisFusionParameters();
-    LedPattern GetLedPattern(u32 npad_id);
+    Core::HID::LedPattern GetLedPattern(u32 npad_id);
     bool IsUnintendedHomeButtonInputProtectionEnabled(u32 npad_id) const;
     void SetUnintendedHomeButtonInputProtectionEnabled(bool is_protection_enabled, u32 npad_id);
     void SetAnalogStickUseCenterClamp(bool use_center_clamp);
diff --git a/src/input_common/drivers/gc_adapter.cpp b/src/input_common/drivers/gc_adapter.cpp
index 6721ba4f7b..2aa5a16a6e 100644
--- a/src/input_common/drivers/gc_adapter.cpp
+++ b/src/input_common/drivers/gc_adapter.cpp
@@ -322,13 +322,17 @@ bool GCAdapter::GetGCEndpoint(libusb_device* device) {
     return true;
 }
 
-bool GCAdapter::SetRumble(const PadIdentifier& identifier, const Input::VibrationStatus vibration) {
+Input::VibrationError GCAdapter::SetRumble(const PadIdentifier& identifier, const Input::VibrationStatus vibration) {
     const auto mean_amplitude = (vibration.low_amplitude + vibration.high_amplitude) * 0.5f;
     const auto processed_amplitude =
         static_cast<u8>((mean_amplitude + std::pow(mean_amplitude, 0.3f)) * 0.5f * 0x8);
 
     pads[identifier.port].rumble_amplitude = processed_amplitude;
-    return rumble_enabled;
+
+    if (!rumble_enabled) {
+        return Input::VibrationError::Disabled;
+    }
+    return Input::VibrationError::None;
 }
 
 void GCAdapter::UpdateVibrations() {
diff --git a/src/input_common/drivers/gc_adapter.h b/src/input_common/drivers/gc_adapter.h
index c0bf1ed7ae..dd23dd9f3b 100644
--- a/src/input_common/drivers/gc_adapter.h
+++ b/src/input_common/drivers/gc_adapter.h
@@ -24,7 +24,7 @@ public:
     explicit GCAdapter(const std::string input_engine_);
     ~GCAdapter();
 
-    bool SetRumble(const PadIdentifier& identifier,
+    Input::VibrationError SetRumble(const PadIdentifier& identifier,
                    const Input::VibrationStatus vibration) override;
 
     /// Used for automapping features
diff --git a/src/input_common/drivers/sdl_driver.cpp b/src/input_common/drivers/sdl_driver.cpp
index efb4a21068..f7f03c5f23 100644
--- a/src/input_common/drivers/sdl_driver.cpp
+++ b/src/input_common/drivers/sdl_driver.cpp
@@ -506,7 +506,8 @@ std::vector<Common::ParamPackage> SDLDriver::GetInputDevices() const {
     }
     return devices;
 }
-bool SDLDriver::SetRumble(const PadIdentifier& identifier, const Input::VibrationStatus vibration) {
+Input::VibrationError 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) {
@@ -519,7 +520,10 @@ bool SDLDriver::SetRumble(const PadIdentifier& identifier, const Input::Vibratio
         .high_frequency = vibration.high_frequency,
     };
 
-    return joystick->RumblePlay(new_vibration);
+    if (!joystick->RumblePlay(new_vibration)) {
+        return Input::VibrationError::Unknown;
+    }
+    return Input::VibrationError::None;
 }
 Common::ParamPackage SDLDriver::BuildAnalogParamPackageForButton(int port, std::string guid,
                                                                  s32 axis, float value) const {
diff --git a/src/input_common/drivers/sdl_driver.h b/src/input_common/drivers/sdl_driver.h
index d8d3501842..f66b33c775 100644
--- a/src/input_common/drivers/sdl_driver.h
+++ b/src/input_common/drivers/sdl_driver.h
@@ -58,7 +58,7 @@ public:
     std::string GetHatButtonName(u8 direction_value) const override;
     u8 GetHatButtonId(const std::string direction_name) const override;
 
-    bool SetRumble(const PadIdentifier& identifier,
+    Input::VibrationError SetRumble(const PadIdentifier& identifier,
                    const Input::VibrationStatus vibration) override;
 
 private:
diff --git a/src/input_common/helpers/stick_from_buttons.cpp b/src/input_common/helpers/stick_from_buttons.cpp
index 38f1507462..89ba4aeb12 100644
--- a/src/input_common/helpers/stick_from_buttons.cpp
+++ b/src/input_common/helpers/stick_from_buttons.cpp
@@ -251,7 +251,8 @@ private:
     std::chrono::time_point<std::chrono::steady_clock> last_update;
 };
 
-std::unique_ptr<Input::InputDevice> StickFromButton::Create(const Common::ParamPackage& params) {
+std::unique_ptr<Input::InputDevice> StickFromButton::Create(
+    const Common::ParamPackage& params) {
     const std::string null_engine = Common::ParamPackage{{"engine", "null"}}.Serialize();
     auto up = Input::CreateDeviceFromString<Input::InputDevice>(params.Get("up", null_engine));
     auto down = Input::CreateDeviceFromString<Input::InputDevice>(params.Get("down", null_engine));
diff --git a/src/input_common/helpers/stick_from_buttons.h b/src/input_common/helpers/stick_from_buttons.h
index 1d6e24c98e..87165e022a 100644
--- a/src/input_common/helpers/stick_from_buttons.h
+++ b/src/input_common/helpers/stick_from_buttons.h
@@ -25,7 +25,8 @@ public:
      *     - "modifier": a serialized ParamPackage for creating a button device as the modifier
      *     - "modifier_scale": a float for the multiplier the modifier gives to the position
      */
-    std::unique_ptr<Input::InputDevice> Create(const Common::ParamPackage& params) override;
+    std::unique_ptr<Input::InputDevice> Create(
+        const Common::ParamPackage& params) override;
 };
 
 } // namespace InputCommon
diff --git a/src/input_common/helpers/touch_from_buttons.cpp b/src/input_common/helpers/touch_from_buttons.cpp
index 2abfaf841d..6c9046ffb4 100644
--- a/src/input_common/helpers/touch_from_buttons.cpp
+++ b/src/input_common/helpers/touch_from_buttons.cpp
@@ -57,7 +57,9 @@ private:
     const Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
 };
 
-std::unique_ptr<Input::InputDevice> TouchFromButton::Create(const Common::ParamPackage& params) {
+
+std::unique_ptr<Input::InputDevice> TouchFromButton::Create(
+    const Common::ParamPackage& params) {
     const std::string null_engine = Common::ParamPackage{{"engine", "null"}}.Serialize();
     auto button =
         Input::CreateDeviceFromString<Input::InputDevice>(params.Get("button", null_engine));
diff --git a/src/input_common/input_engine.h b/src/input_common/input_engine.h
index 86a8e00d8e..8a953c3820 100644
--- a/src/input_common/input_engine.h
+++ b/src/input_common/input_engine.h
@@ -114,18 +114,24 @@ public:
     // Disable configuring mode for mapping
     void EndConfiguration();
 
-    // Sets rumble to a controller
-    virtual bool SetRumble([[maybe_unused]] const PadIdentifier& identifier,
-                           [[maybe_unused]] const Input::VibrationStatus vibration) {
-        return false;
-    }
-
     // Sets a led pattern for a controller
     virtual void SetLeds([[maybe_unused]] const PadIdentifier& identifier,
                          [[maybe_unused]] const Input::LedStatus led_status) {
         return;
     }
 
+    // Sets rumble to a controller
+    virtual Input::VibrationError SetRumble([[maybe_unused]] const PadIdentifier& identifier,
+                           [[maybe_unused]] const Input::VibrationStatus vibration) {
+        return Input::VibrationError::NotSupported;
+    }
+
+    // Sets polling mode to a controller
+    virtual Input::PollingError SetPollingMode([[maybe_unused]] const PadIdentifier& identifier,
+                           [[maybe_unused]] const Input::PollingMode vibration) {
+        return Input::PollingError::NotSupported;
+    }
+
     // Returns the engine name
     [[nodiscard]] const std::string& GetEngineName() const;
 
diff --git a/src/input_common/input_poller.cpp b/src/input_common/input_poller.cpp
index 46a7dd2761..781012886a 100644
--- a/src/input_common/input_poller.cpp
+++ b/src/input_common/input_poller.cpp
@@ -592,6 +592,28 @@ private:
     InputEngine* input_engine;
 };
 
+class OutputFromIdentifier final : public Input::OutputDevice {
+public:
+    explicit OutputFromIdentifier(PadIdentifier identifier_, InputEngine* input_engine_)
+        : identifier(identifier_), input_engine(input_engine_) {}
+
+    virtual void SetLED( Input::LedStatus led_status) {
+        input_engine->SetLeds(identifier, led_status);
+    }
+
+    virtual Input::VibrationError SetVibration(Input::VibrationStatus vibration_status) {
+        return input_engine->SetRumble(identifier, vibration_status);
+    }
+
+    virtual Input::PollingError SetPollingMode(Input::PollingMode polling_mode) {
+        return input_engine->SetPollingMode(identifier, polling_mode);
+    }
+
+private:
+    const PadIdentifier identifier;
+    InputEngine* input_engine;
+};
+
 std::unique_ptr<Input::InputDevice> InputFactory::CreateButtonDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
@@ -825,7 +847,8 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateMotionDevice(Common::Par
 InputFactory::InputFactory(std::shared_ptr<InputEngine> input_engine_)
     : input_engine(std::move(input_engine_)) {}
 
-std::unique_ptr<Input::InputDevice> InputFactory::Create(const Common::ParamPackage& params) {
+std::unique_ptr<Input::InputDevice> InputFactory::Create(
+    const Common::ParamPackage& params) {
     if (params.Has("button") && params.Has("axis")) {
         return CreateTriggerDevice(params);
     }
@@ -857,4 +880,19 @@ std::unique_ptr<Input::InputDevice> InputFactory::Create(const Common::ParamPack
     return std::make_unique<DummyInput>();
 }
 
+OutputFactory::OutputFactory(std::shared_ptr<InputEngine> input_engine_)
+    : input_engine(std::move(input_engine_)) {}
+
+std::unique_ptr<Input::OutputDevice> OutputFactory::Create(
+    const Common::ParamPackage& params) {
+    const PadIdentifier identifier = {
+        .guid = Common::UUID{params.Get("guid", "")},
+        .port = static_cast<std::size_t>(params.Get("port", 0)),
+        .pad = static_cast<std::size_t>(params.Get("pad", 0)),
+    };
+
+    input_engine->PreSetController(identifier);
+    return std::make_unique<OutputFromIdentifier>(identifier, input_engine.get());
+}
+
 } // namespace InputCommon
diff --git a/src/input_common/input_poller.h b/src/input_common/input_poller.h
index 3c1e5b541f..16cade5faf 100644
--- a/src/input_common/input_poller.h
+++ b/src/input_common/input_poller.h
@@ -16,12 +16,32 @@ class InputEngine;
 /**
  * An Input factory. It receives input events and forward them to all input devices it created.
  */
+
+class OutputFactory final : public Input::Factory<Input::OutputDevice> {
+public:
+    explicit OutputFactory(std::shared_ptr<InputEngine> input_engine_);
+
+    /**
+     * Creates an output device from the parameters given.
+     * @param params contains parameters for creating the device:
+     * @param    - "guid": text string for identifing controllers
+     * @param    - "port": port of the connected device
+     * @param    - "pad": slot of the connected controller
+     * @return an unique ouput device with the parameters specified
+     */
+    std::unique_ptr<Input::OutputDevice> Create(
+        const Common::ParamPackage& params) override;
+
+private:
+    std::shared_ptr<InputEngine> input_engine;
+};
+
 class InputFactory final : public Input::Factory<Input::InputDevice> {
 public:
     explicit InputFactory(std::shared_ptr<InputEngine> input_engine_);
 
     /**
-     * Creates a input device from the parameters given. Identifies the type of input to be returned
+     * Creates an input device from the parameters given. Identifies the type of input to be returned
      * if it contains the following parameters:
      * - button: Contains "button" or "code"
      * - hat_button: Contains "hat"
@@ -32,6 +52,7 @@ public:
      * - motion: Contains "motion"
      * - touch: Contains "button", "axis_x" and "axis_y"
      * - battery: Contains "battery"
+     * - output: Contains "output"
      * @param params contains parameters for creating the device:
      * @param    - "code": the code of the keyboard key to bind with the input
      * @param    - "button": same as "code" but for controller buttons
@@ -41,10 +62,11 @@ public:
      * @param    - "axis_x": same as axis but specifing horizontal direction
      * @param    - "axis_y": same as axis but specifing vertical direction
      * @param    - "axis_z": same as axis but specifing forward direction
-     * @param   - "battery": Only used as a placeholder to set the input type
+     * @param    - "battery": Only used as a placeholder to set the input type
      * @return an unique input device with the parameters specified
      */
-    std::unique_ptr<Input::InputDevice> Create(const Common::ParamPackage& params) override;
+    std::unique_ptr<Input::InputDevice> Create(
+        const Common::ParamPackage& params) override;
 
 private:
     /**
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index 46ca6b76c8..b7fe9cb373 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -46,8 +46,10 @@ struct InputSubsystem::Impl {
 
         gcadapter = std::make_shared<GCAdapter>("gcpad");
         gcadapter->SetMappingCallback(mapping_callback);
-        gcadapter_factory = std::make_shared<InputFactory>(gcadapter);
-        Input::RegisterFactory<Input::InputDevice>(gcadapter->GetEngineName(), gcadapter_factory);
+        gcadapter_input_factory = std::make_shared<InputFactory>(gcadapter);
+        gcadapter_output_factory = std::make_shared<OutputFactory>(gcadapter);
+        Input::RegisterFactory<Input::InputDevice>(gcadapter->GetEngineName(), gcadapter_input_factory);
+        Input::RegisterFactory<Input::OutputDevice>(gcadapter->GetEngineName(), gcadapter_output_factory);
 
         udp_client = std::make_shared<CemuhookUDP::UDPClient>("cemuhookudp");
         udp_client->SetMappingCallback(mapping_callback);
@@ -62,8 +64,10 @@ struct InputSubsystem::Impl {
 #ifdef HAVE_SDL2
         sdl = std::make_shared<SDLDriver>("sdl");
         sdl->SetMappingCallback(mapping_callback);
-        sdl_factory = std::make_shared<InputFactory>(sdl);
-        Input::RegisterFactory<Input::InputDevice>(sdl->GetEngineName(), sdl_factory);
+        sdl_input_factory = std::make_shared<InputFactory>(sdl);
+        sdl_output_factory = std::make_shared<OutputFactory>(sdl);
+        Input::RegisterFactory<Input::InputDevice>(sdl->GetEngineName(), sdl_input_factory);
+        Input::RegisterFactory<Input::OutputDevice>(sdl->GetEngineName(), sdl_output_factory);
 #endif
 
         Input::RegisterFactory<Input::InputDevice>("touch_from_button",
@@ -247,21 +251,27 @@ struct InputSubsystem::Impl {
     }
 
     std::shared_ptr<MappingFactory> mapping_factory;
+
     std::shared_ptr<Keyboard> keyboard;
-    std::shared_ptr<InputFactory> keyboard_factory;
     std::shared_ptr<Mouse> mouse;
-    std::shared_ptr<InputFactory> mouse_factory;
     std::shared_ptr<GCAdapter> gcadapter;
-    std::shared_ptr<InputFactory> gcadapter_factory;
     std::shared_ptr<TouchScreen> touch_screen;
-    std::shared_ptr<InputFactory> touch_screen_factory;
+    std::shared_ptr<TasInput::Tas> tas_input;
     std::shared_ptr<CemuhookUDP::UDPClient> udp_client;
+
+    std::shared_ptr<InputFactory> keyboard_factory;
+    std::shared_ptr<InputFactory> mouse_factory;
+    std::shared_ptr<InputFactory> gcadapter_input_factory;
+    std::shared_ptr<InputFactory> touch_screen_factory;
     std::shared_ptr<InputFactory> udp_client_factory;
-    std::shared_ptr<TasInput::Tas> tas_input;
     std::shared_ptr<InputFactory> tas_input_factory;
+
+    std::shared_ptr<OutputFactory> gcadapter_output_factory;
+
 #ifdef HAVE_SDL2
     std::shared_ptr<SDLDriver> sdl;
-    std::shared_ptr<InputFactory> sdl_factory;
+    std::shared_ptr<InputFactory> sdl_input_factory;
+    std::shared_ptr<OutputFactory> sdl_output_factory;
 #endif
 };
 
diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp
index adc9706f14..ed9c3facf5 100644
--- a/src/yuzu/configuration/configure_input_player.cpp
+++ b/src/yuzu/configuration/configure_input_player.cpp
@@ -465,6 +465,8 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
         UpdateControllerEnabledButtons();
         UpdateControllerButtonNames();
         UpdateMotionButtons();
+        emulated_controller->SetNpadType(
+            GetControllerTypeFromIndex(ui->comboControllerType->currentIndex()));
     });
 
     connect(ui->comboDevices, qOverload<int>(&QComboBox::activated), this,
@@ -540,6 +542,11 @@ void ConfigureInputPlayer::LoadConfiguration() {
 
 void ConfigureInputPlayer::ConnectPlayer(bool connected) {
     ui->groupConnectedController->setChecked(connected);
+    if (connected) {
+        emulated_controller->Connect();
+    } else {
+        emulated_controller->Disconnect();
+    }
 }
 
 void ConfigureInputPlayer::UpdateInputDeviceCombobox() {
diff --git a/src/yuzu/configuration/configure_input_player_widget.cpp b/src/yuzu/configuration/configure_input_player_widget.cpp
index 03d29f194e..2ba9d7290c 100644
--- a/src/yuzu/configuration/configure_input_player_widget.cpp
+++ b/src/yuzu/configuration/configure_input_player_widget.cpp
@@ -24,34 +24,6 @@ PlayerControlPreview::~PlayerControlPreview() {
     }
 };
 
-PlayerControlPreview::LedPattern PlayerControlPreview::GetColorPattern(std::size_t index,
-                                                                       bool player_on) {
-    if (!player_on) {
-        return {0, 0, 0, 0};
-    }
-
-    switch (index) {
-    case 0:
-        return {1, 0, 0, 0};
-    case 1:
-        return {1, 1, 0, 0};
-    case 2:
-        return {1, 1, 1, 0};
-    case 3:
-        return {1, 1, 1, 1};
-    case 4:
-        return {1, 0, 0, 1};
-    case 5:
-        return {1, 0, 1, 0};
-    case 6:
-        return {1, 0, 1, 1};
-    case 7:
-        return {0, 1, 1, 0};
-    default:
-        return {0, 0, 0, 0};
-    }
-}
-
 void PlayerControlPreview::SetController(Core::HID::EmulatedController* controller_) {
     if (is_controller_set) {
         controller->DeleteCallback(callback_key);
@@ -160,8 +132,13 @@ void PlayerControlPreview::ControllerUpdate(Core::HID::ControllerTriggerType typ
 
     switch (type) {
     case Core::HID::ControllerTriggerType::Connected:
+        is_connected = true;
+        led_pattern = controller->GetLedPattern();
+        needs_redraw = true;
+        break;
     case Core::HID::ControllerTriggerType::Disconnected:
-        is_connected = controller->IsConnected();
+        is_connected = false;
+        led_pattern.raw = 0;
         needs_redraw = true;
         break;
     case Core::HID::ControllerTriggerType::Type:
@@ -1853,10 +1830,14 @@ void PlayerControlPreview::DrawLeftBody(QPainter& p, const QPointF center) {
     const float led_size = 5.0f;
     const QPointF led_position = sideview_center + QPointF(0, -36);
     int led_count = 0;
-    for (const auto& color : led_color) {
-        p.setBrush(color);
-        DrawRectangle(p, led_position + QPointF(0, 12 * led_count++), led_size, led_size);
-    }
+    p.setBrush(led_pattern.position1 ? colors.led_on : colors.led_off);
+    DrawRectangle(p, led_position + QPointF(0, 12 * led_count++), led_size, led_size);
+    p.setBrush(led_pattern.position2 ? colors.led_on : colors.led_off);
+    DrawRectangle(p, led_position + QPointF(0, 12 * led_count++), led_size, led_size);
+    p.setBrush(led_pattern.position3 ? colors.led_on : colors.led_off);
+    DrawRectangle(p, led_position + QPointF(0, 12 * led_count++), led_size, led_size);
+    p.setBrush(led_pattern.position4 ? colors.led_on : colors.led_off);
+    DrawRectangle(p, led_position + QPointF(0, 12 * led_count++), led_size, led_size);
 }
 
 void PlayerControlPreview::DrawRightBody(QPainter& p, const QPointF center) {
@@ -1949,10 +1930,14 @@ void PlayerControlPreview::DrawRightBody(QPainter& p, const QPointF center) {
     const float led_size = 5.0f;
     const QPointF led_position = sideview_center + QPointF(0, -36);
     int led_count = 0;
-    for (const auto& color : led_color) {
-        p.setBrush(color);
-        DrawRectangle(p, led_position + QPointF(0, 12 * led_count++), led_size, led_size);
-    }
+    p.setBrush(led_pattern.position1 ? colors.led_on : colors.led_off);
+    DrawRectangle(p, led_position + QPointF(0, 12 * led_count++), led_size, led_size);
+    p.setBrush(led_pattern.position2 ? colors.led_on : colors.led_off);
+    DrawRectangle(p, led_position + QPointF(0, 12 * led_count++), led_size, led_size);
+    p.setBrush(led_pattern.position3 ? colors.led_on : colors.led_off);
+    DrawRectangle(p, led_position + QPointF(0, 12 * led_count++), led_size, led_size);
+    p.setBrush(led_pattern.position4 ? colors.led_on : colors.led_off);
+    DrawRectangle(p, led_position + QPointF(0, 12 * led_count++), led_size, led_size);
 }
 
 void PlayerControlPreview::DrawProTriggers(QPainter& p, const QPointF center,
diff --git a/src/yuzu/configuration/configure_input_player_widget.h b/src/yuzu/configuration/configure_input_player_widget.h
index b44a2e347d..16f9748f54 100644
--- a/src/yuzu/configuration/configure_input_player_widget.h
+++ b/src/yuzu/configuration/configure_input_player_widget.h
@@ -59,13 +59,6 @@ private:
         SR,
     };
 
-    struct LedPattern {
-        bool position1;
-        bool position2;
-        bool position3;
-        bool position4;
-    };
-
     struct ColorMapping {
         QColor outline{};
         QColor primary{};
@@ -88,7 +81,6 @@ private:
         QColor deadzone{};
     };
 
-    static LedPattern GetColorPattern(std::size_t index, bool player_on);
     void UpdateColors();
     void ResetInputs();
 
@@ -194,7 +186,7 @@ private:
     int callback_key;
     QColor button_color{};
     ColorMapping colors{};
-    std::array<QColor, 4> led_color{};
+    Core::HID::LedPattern led_pattern{0, 0, 0, 0};
     std::size_t player_index{};
     Core::HID::EmulatedController* controller;
     std::size_t button_mapping_index{Settings::NativeButton::NumButtons};
-- 
cgit v1.2.3


From 0292fe01987c5580ab39a9ba74f86b5da9fe2c30 Mon Sep 17 00:00:00 2001
From: german77 <juangerman-13@hotmail.com>
Date: Fri, 15 Oct 2021 19:07:47 -0500
Subject: kraken: Fix errors from rebase and format files

---
 src/core/hid/emulated_controller.cpp               |  6 +++++-
 src/core/hle/service/hid/hid.cpp                   |  1 -
 src/input_common/drivers/gc_adapter.cpp            |  3 ++-
 src/input_common/drivers/gc_adapter.h              |  2 +-
 src/input_common/drivers/sdl_driver.h              |  2 +-
 src/input_common/helpers/stick_from_buttons.cpp    |  3 +--
 src/input_common/helpers/stick_from_buttons.h      |  3 +--
 src/input_common/helpers/touch_from_buttons.cpp    |  4 +---
 src/input_common/input_engine.h                    | 10 +++++----
 src/input_common/input_poller.cpp                  |  8 +++----
 src/input_common/input_poller.h                    | 10 ++++-----
 src/input_common/main.cpp                          |  6 ++++--
 src/yuzu/applets/qt_controller.h                   |  1 -
 src/yuzu/configuration/configure_dialog.cpp        |  2 +-
 src/yuzu/configuration/configure_input.cpp         |  9 ++++----
 .../configure_input_player_widget.cpp              | 25 ++++++++++++----------
 .../configuration/configure_input_player_widget.h  | 16 +++++++++++++-
 src/yuzu/debugger/controller.cpp                   |  9 ++++++--
 src/yuzu/debugger/controller.h                     |  9 +++++++-
 src/yuzu/main.cpp                                  |  7 +++---
 20 files changed, 83 insertions(+), 53 deletions(-)

(limited to 'src/input_common/main.cpp')

diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index b9d16657a5..b04ab4cd84 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -91,6 +91,7 @@ void EmulatedController::ReloadFromSettings() {
 }
 
 void EmulatedController::ReloadInput() {
+    // If you load any device here add the equivalent to the UnloadInput() function
     const auto player_index = NpadIdTypeToIndex(npad_id_type);
     const auto left_side = button_params[Settings::NativeButton::ZL];
     const auto right_side = button_params[Settings::NativeButton::ZR];
@@ -113,7 +114,7 @@ void EmulatedController::ReloadInput() {
     battery_devices[0] = Input::CreateDevice<Input::InputDevice>(left_side);
     battery_devices[1] = Input::CreateDevice<Input::InputDevice>(right_side);
 
-    button_params[Settings::NativeButton::ZL].Set("output",true);
+    button_params[Settings::NativeButton::ZL].Set("output", true);
     output_devices[0] =
         Input::CreateDevice<Input::OutputDevice>(button_params[Settings::NativeButton::ZL]);
 
@@ -179,6 +180,9 @@ void EmulatedController::UnloadInput() {
     for (auto& battery : battery_devices) {
         battery.reset();
     }
+    for (auto& output : output_devices) {
+        output.reset();
+    }
 }
 
 void EmulatedController::EnableConfiguration() {
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 18f29bb78d..5391334f43 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -8,7 +8,6 @@
 #include "common/settings.h"
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/frontend/input.h"
 #include "core/hardware_properties.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/k_readable_event.h"
diff --git a/src/input_common/drivers/gc_adapter.cpp b/src/input_common/drivers/gc_adapter.cpp
index 2aa5a16a6e..4a56abb997 100644
--- a/src/input_common/drivers/gc_adapter.cpp
+++ b/src/input_common/drivers/gc_adapter.cpp
@@ -322,7 +322,8 @@ bool GCAdapter::GetGCEndpoint(libusb_device* device) {
     return true;
 }
 
-Input::VibrationError GCAdapter::SetRumble(const PadIdentifier& identifier, const Input::VibrationStatus vibration) {
+Input::VibrationError GCAdapter::SetRumble(const PadIdentifier& identifier,
+                                           const Input::VibrationStatus vibration) {
     const auto mean_amplitude = (vibration.low_amplitude + vibration.high_amplitude) * 0.5f;
     const auto processed_amplitude =
         static_cast<u8>((mean_amplitude + std::pow(mean_amplitude, 0.3f)) * 0.5f * 0x8);
diff --git a/src/input_common/drivers/gc_adapter.h b/src/input_common/drivers/gc_adapter.h
index dd23dd9f3b..dd0e4aa1d5 100644
--- a/src/input_common/drivers/gc_adapter.h
+++ b/src/input_common/drivers/gc_adapter.h
@@ -25,7 +25,7 @@ public:
     ~GCAdapter();
 
     Input::VibrationError SetRumble(const PadIdentifier& identifier,
-                   const Input::VibrationStatus vibration) override;
+                                    const Input::VibrationStatus vibration) override;
 
     /// Used for automapping features
     std::vector<Common::ParamPackage> GetInputDevices() const override;
diff --git a/src/input_common/drivers/sdl_driver.h b/src/input_common/drivers/sdl_driver.h
index f66b33c775..1ff85f48de 100644
--- a/src/input_common/drivers/sdl_driver.h
+++ b/src/input_common/drivers/sdl_driver.h
@@ -59,7 +59,7 @@ public:
     u8 GetHatButtonId(const std::string direction_name) const override;
 
     Input::VibrationError SetRumble(const PadIdentifier& identifier,
-                   const Input::VibrationStatus vibration) override;
+                                    const Input::VibrationStatus vibration) override;
 
 private:
     void InitJoystick(int joystick_index);
diff --git a/src/input_common/helpers/stick_from_buttons.cpp b/src/input_common/helpers/stick_from_buttons.cpp
index 89ba4aeb12..38f1507462 100644
--- a/src/input_common/helpers/stick_from_buttons.cpp
+++ b/src/input_common/helpers/stick_from_buttons.cpp
@@ -251,8 +251,7 @@ private:
     std::chrono::time_point<std::chrono::steady_clock> last_update;
 };
 
-std::unique_ptr<Input::InputDevice> StickFromButton::Create(
-    const Common::ParamPackage& params) {
+std::unique_ptr<Input::InputDevice> StickFromButton::Create(const Common::ParamPackage& params) {
     const std::string null_engine = Common::ParamPackage{{"engine", "null"}}.Serialize();
     auto up = Input::CreateDeviceFromString<Input::InputDevice>(params.Get("up", null_engine));
     auto down = Input::CreateDeviceFromString<Input::InputDevice>(params.Get("down", null_engine));
diff --git a/src/input_common/helpers/stick_from_buttons.h b/src/input_common/helpers/stick_from_buttons.h
index 87165e022a..1d6e24c98e 100644
--- a/src/input_common/helpers/stick_from_buttons.h
+++ b/src/input_common/helpers/stick_from_buttons.h
@@ -25,8 +25,7 @@ public:
      *     - "modifier": a serialized ParamPackage for creating a button device as the modifier
      *     - "modifier_scale": a float for the multiplier the modifier gives to the position
      */
-    std::unique_ptr<Input::InputDevice> Create(
-        const Common::ParamPackage& params) override;
+    std::unique_ptr<Input::InputDevice> Create(const Common::ParamPackage& params) override;
 };
 
 } // namespace InputCommon
diff --git a/src/input_common/helpers/touch_from_buttons.cpp b/src/input_common/helpers/touch_from_buttons.cpp
index 6c9046ffb4..2abfaf841d 100644
--- a/src/input_common/helpers/touch_from_buttons.cpp
+++ b/src/input_common/helpers/touch_from_buttons.cpp
@@ -57,9 +57,7 @@ private:
     const Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
 };
 
-
-std::unique_ptr<Input::InputDevice> TouchFromButton::Create(
-    const Common::ParamPackage& params) {
+std::unique_ptr<Input::InputDevice> TouchFromButton::Create(const Common::ParamPackage& params) {
     const std::string null_engine = Common::ParamPackage{{"engine", "null"}}.Serialize();
     auto button =
         Input::CreateDeviceFromString<Input::InputDevice>(params.Get("button", null_engine));
diff --git a/src/input_common/input_engine.h b/src/input_common/input_engine.h
index 8a953c3820..31ce900d76 100644
--- a/src/input_common/input_engine.h
+++ b/src/input_common/input_engine.h
@@ -121,14 +121,16 @@ public:
     }
 
     // Sets rumble to a controller
-    virtual Input::VibrationError SetRumble([[maybe_unused]] const PadIdentifier& identifier,
-                           [[maybe_unused]] const Input::VibrationStatus vibration) {
+    virtual Input::VibrationError SetRumble(
+        [[maybe_unused]] const PadIdentifier& identifier,
+        [[maybe_unused]] const Input::VibrationStatus vibration) {
         return Input::VibrationError::NotSupported;
     }
 
     // Sets polling mode to a controller
-    virtual Input::PollingError SetPollingMode([[maybe_unused]] const PadIdentifier& identifier,
-                           [[maybe_unused]] const Input::PollingMode vibration) {
+    virtual Input::PollingError SetPollingMode(
+        [[maybe_unused]] const PadIdentifier& identifier,
+        [[maybe_unused]] const Input::PollingMode vibration) {
         return Input::PollingError::NotSupported;
     }
 
diff --git a/src/input_common/input_poller.cpp b/src/input_common/input_poller.cpp
index 781012886a..62ade951c9 100644
--- a/src/input_common/input_poller.cpp
+++ b/src/input_common/input_poller.cpp
@@ -597,7 +597,7 @@ public:
     explicit OutputFromIdentifier(PadIdentifier identifier_, InputEngine* input_engine_)
         : identifier(identifier_), input_engine(input_engine_) {}
 
-    virtual void SetLED( Input::LedStatus led_status) {
+    virtual void SetLED(Input::LedStatus led_status) {
         input_engine->SetLeds(identifier, led_status);
     }
 
@@ -847,8 +847,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateMotionDevice(Common::Par
 InputFactory::InputFactory(std::shared_ptr<InputEngine> input_engine_)
     : input_engine(std::move(input_engine_)) {}
 
-std::unique_ptr<Input::InputDevice> InputFactory::Create(
-    const Common::ParamPackage& params) {
+std::unique_ptr<Input::InputDevice> InputFactory::Create(const Common::ParamPackage& params) {
     if (params.Has("button") && params.Has("axis")) {
         return CreateTriggerDevice(params);
     }
@@ -883,8 +882,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::Create(
 OutputFactory::OutputFactory(std::shared_ptr<InputEngine> input_engine_)
     : input_engine(std::move(input_engine_)) {}
 
-std::unique_ptr<Input::OutputDevice> OutputFactory::Create(
-    const Common::ParamPackage& params) {
+std::unique_ptr<Input::OutputDevice> OutputFactory::Create(const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
         .guid = Common::UUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
diff --git a/src/input_common/input_poller.h b/src/input_common/input_poller.h
index 16cade5faf..1357e104be 100644
--- a/src/input_common/input_poller.h
+++ b/src/input_common/input_poller.h
@@ -29,8 +29,7 @@ public:
      * @param    - "pad": slot of the connected controller
      * @return an unique ouput device with the parameters specified
      */
-    std::unique_ptr<Input::OutputDevice> Create(
-        const Common::ParamPackage& params) override;
+    std::unique_ptr<Input::OutputDevice> Create(const Common::ParamPackage& params) override;
 
 private:
     std::shared_ptr<InputEngine> input_engine;
@@ -41,8 +40,8 @@ public:
     explicit InputFactory(std::shared_ptr<InputEngine> input_engine_);
 
     /**
-     * Creates an input device from the parameters given. Identifies the type of input to be returned
-     * if it contains the following parameters:
+     * Creates an input device from the parameters given. Identifies the type of input to be
+     * returned if it contains the following parameters:
      * - button: Contains "button" or "code"
      * - hat_button: Contains "hat"
      * - analog: Contains "axis"
@@ -65,8 +64,7 @@ public:
      * @param    - "battery": Only used as a placeholder to set the input type
      * @return an unique input device with the parameters specified
      */
-    std::unique_ptr<Input::InputDevice> Create(
-        const Common::ParamPackage& params) override;
+    std::unique_ptr<Input::InputDevice> Create(const Common::ParamPackage& params) override;
 
 private:
     /**
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index b7fe9cb373..7807dd38ff 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -48,8 +48,10 @@ struct InputSubsystem::Impl {
         gcadapter->SetMappingCallback(mapping_callback);
         gcadapter_input_factory = std::make_shared<InputFactory>(gcadapter);
         gcadapter_output_factory = std::make_shared<OutputFactory>(gcadapter);
-        Input::RegisterFactory<Input::InputDevice>(gcadapter->GetEngineName(), gcadapter_input_factory);
-        Input::RegisterFactory<Input::OutputDevice>(gcadapter->GetEngineName(), gcadapter_output_factory);
+        Input::RegisterFactory<Input::InputDevice>(gcadapter->GetEngineName(),
+                                                   gcadapter_input_factory);
+        Input::RegisterFactory<Input::OutputDevice>(gcadapter->GetEngineName(),
+                                                    gcadapter_output_factory);
 
         udp_client = std::make_shared<CemuhookUDP::UDPClient>("cemuhookudp");
         udp_client->SetMappingCallback(mapping_callback);
diff --git a/src/yuzu/applets/qt_controller.h b/src/yuzu/applets/qt_controller.h
index 98060e6f81..ca09fde04f 100644
--- a/src/yuzu/applets/qt_controller.h
+++ b/src/yuzu/applets/qt_controller.h
@@ -106,7 +106,6 @@ private:
     Core::Frontend::ControllerParameters parameters;
 
     InputCommon::InputSubsystem* input_subsystem;
-    Core::System& system;
 
     std::unique_ptr<InputProfiles> input_profiles;
 
diff --git a/src/yuzu/configuration/configure_dialog.cpp b/src/yuzu/configuration/configure_dialog.cpp
index 642a5f9660..1eb9d70e53 100644
--- a/src/yuzu/configuration/configure_dialog.cpp
+++ b/src/yuzu/configuration/configure_dialog.cpp
@@ -74,7 +74,7 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry,
     hotkeys_tab->Populate(registry);
     setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
 
-    input_tab->Initialize(input_subsystem);
+    input_tab->Initialize(input_subsystem, system_);
 
     general_tab->SetResetCallback([&] { this->close(); });
 
diff --git a/src/yuzu/configuration/configure_input.cpp b/src/yuzu/configuration/configure_input.cpp
index 61513865f4..a8611f77f9 100644
--- a/src/yuzu/configuration/configure_input.cpp
+++ b/src/yuzu/configuration/configure_input.cpp
@@ -146,10 +146,11 @@ void ConfigureInput::Initialize(InputCommon::InputSubsystem* input_subsystem, Co
     advanced = new ConfigureInputAdvanced(this);
     ui->tabAdvanced->setLayout(new QHBoxLayout(ui->tabAdvanced));
     ui->tabAdvanced->layout()->addWidget(advanced);
-    connect(advanced, &ConfigureInputAdvanced::CallDebugControllerDialog, [this, input_subsystem] {
-        CallConfigureDialog<ConfigureDebugController>(*this, input_subsystem, profiles.get(),
-                                                      system);
-    });
+    connect(advanced, &ConfigureInputAdvanced::CallDebugControllerDialog,
+            [this, input_subsystem, &system] {
+                CallConfigureDialog<ConfigureDebugController>(*this, input_subsystem,
+                                                              profiles.get(), system);
+            });
     connect(advanced, &ConfigureInputAdvanced::CallMouseConfigDialog, [this, input_subsystem] {
         CallConfigureDialog<ConfigureMouseAdvanced>(*this, input_subsystem);
     });
diff --git a/src/yuzu/configuration/configure_input_player_widget.cpp b/src/yuzu/configuration/configure_input_player_widget.cpp
index 2ba9d7290c..446b72e553 100644
--- a/src/yuzu/configuration/configure_input_player_widget.cpp
+++ b/src/yuzu/configuration/configure_input_player_widget.cpp
@@ -19,15 +19,11 @@ PlayerControlPreview::PlayerControlPreview(QWidget* parent) : QFrame(parent) {
 }
 
 PlayerControlPreview::~PlayerControlPreview() {
-    if (is_controller_set) {
-        controller->DeleteCallback(callback_key);
-    }
+    UnloadController();
 };
 
 void PlayerControlPreview::SetController(Core::HID::EmulatedController* controller_) {
-    if (is_controller_set) {
-        controller->DeleteCallback(callback_key);
-    }
+    UnloadController();
     is_controller_set = true;
     controller = controller_;
     Core::HID::ControllerUpdateCallback engine_callback{
@@ -36,14 +32,21 @@ void PlayerControlPreview::SetController(Core::HID::EmulatedController* controll
     ControllerUpdate(Core::HID::ControllerTriggerType::All);
 }
 
-void PlayerControlPreview::BeginMappingButton(std::size_t index) {
-    button_mapping_index = index;
+void PlayerControlPreview::UnloadController() {
+    if (is_controller_set) {
+        controller->DeleteCallback(callback_key);
+        is_controller_set = false;
+    }
+}
+
+void PlayerControlPreview::BeginMappingButton(std::size_t button_id) {
+    button_mapping_index = button_id;
     mapping_active = true;
 }
 
-void PlayerControlPreview::BeginMappingAnalog(std::size_t index) {
-    button_mapping_index = Settings::NativeButton::LStick + index;
-    analog_mapping_index = index;
+void PlayerControlPreview::BeginMappingAnalog(std::size_t stick_id) {
+    button_mapping_index = Settings::NativeButton::LStick + stick_id;
+    analog_mapping_index = stick_id;
     mapping_active = true;
 }
 
diff --git a/src/yuzu/configuration/configure_input_player_widget.h b/src/yuzu/configuration/configure_input_player_widget.h
index 16f9748f54..333c3fc56b 100644
--- a/src/yuzu/configuration/configure_input_player_widget.h
+++ b/src/yuzu/configuration/configure_input_player_widget.h
@@ -25,11 +25,25 @@ public:
     explicit PlayerControlPreview(QWidget* parent);
     ~PlayerControlPreview() override;
 
+    // Sets the emulated controller to be displayed
     void SetController(Core::HID::EmulatedController* controller);
+
+    // Disables events from the emulated controller
+    void UnloadController();
+
+    // Starts blinking animation at the button specified
     void BeginMappingButton(std::size_t button_id);
-    void BeginMappingAnalog(std::size_t button_id);
+
+    // Starts moving animation at the stick specified
+    void BeginMappingAnalog(std::size_t stick_id);
+
+    // Stops any ongoing animation
     void EndMapping();
+
+    // Handles emulated controller events
     void ControllerUpdate(Core::HID::ControllerTriggerType type);
+
+    // Updates input on sheduled interval
     void UpdateInput();
 
 protected:
diff --git a/src/yuzu/debugger/controller.cpp b/src/yuzu/debugger/controller.cpp
index d8e41f8b69..3619aed260 100644
--- a/src/yuzu/debugger/controller.cpp
+++ b/src/yuzu/debugger/controller.cpp
@@ -10,7 +10,8 @@
 #include "yuzu/configuration/configure_input_player_widget.h"
 #include "yuzu/debugger/controller.h"
 
-ControllerDialog::ControllerDialog(QWidget* parent) : QWidget(parent, Qt::Dialog) {
+ControllerDialog::ControllerDialog(Core::System& system, QWidget* parent)
+    : QWidget(parent, Qt::Dialog) {
     setObjectName(QStringLiteral("Controller"));
     setWindowTitle(tr("Controller P1"));
     resize(500, 350);
@@ -20,7 +21,7 @@ ControllerDialog::ControllerDialog(QWidget* parent) : QWidget(parent, Qt::Dialog
                    Qt::WindowMaximizeButtonHint);
 
     widget = new PlayerControlPreview(this);
-    widget->SetController(Core::System::GetInstance().HIDCore().GetEmulatedController(
+    widget->SetController(system.HIDCore().GetEmulatedController(
         Core::HID::NpadIdType::Player1));
     QLayout* layout = new QVBoxLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
@@ -45,6 +46,10 @@ QAction* ControllerDialog::toggleViewAction() {
     return toggle_view_action;
 }
 
+void ControllerDialog::UnloadController() {
+    widget->UnloadController();
+}
+
 void ControllerDialog::showEvent(QShowEvent* ev) {
     if (toggle_view_action) {
         toggle_view_action->setChecked(isVisible());
diff --git a/src/yuzu/debugger/controller.h b/src/yuzu/debugger/controller.h
index 697489cbbd..33f617b9b9 100644
--- a/src/yuzu/debugger/controller.h
+++ b/src/yuzu/debugger/controller.h
@@ -11,6 +11,10 @@ class QHideEvent;
 class QShowEvent;
 class PlayerControlPreview;
 
+namespace Core {
+class System;
+}
+
 namespace InputCommon {
 class InputSubsystem;
 }
@@ -19,11 +23,14 @@ class ControllerDialog : public QWidget {
     Q_OBJECT
 
 public:
-    explicit ControllerDialog(QWidget* parent = nullptr);
+    explicit ControllerDialog(Core::System& system, QWidget* parent = nullptr);
 
     /// Returns a QAction that can be used to toggle visibility of this dialog.
     QAction* toggleViewAction();
 
+    // Disables events from the emulated controller
+    void UnloadController();
+
 protected:
     void showEvent(QShowEvent* ev) override;
     void hideEvent(QHideEvent* ev) override;
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index 19cb5313fd..ae997ccfa3 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -228,7 +228,7 @@ GMainWindow::GMainWindow()
     ConnectMenuEvents();
     ConnectWidgetEvents();
 
-    Core::System::GetInstance().HIDCore().ReloadInputDevices();
+    system->HIDCore().ReloadInputDevices();
 
     const auto branch_name = std::string(Common::g_scm_branch);
     const auto description = std::string(Common::g_scm_desc);
@@ -924,7 +924,7 @@ void GMainWindow::InitializeDebugWidgets() {
     waitTreeWidget->hide();
     debug_menu->addAction(waitTreeWidget->toggleViewAction());
 
-    controller_dialog = new ControllerDialog(this);
+    controller_dialog = new ControllerDialog(*system, this);
     controller_dialog->hide();
     debug_menu->addAction(controller_dialog->toggleViewAction());
 
@@ -3372,7 +3372,8 @@ void GMainWindow::closeEvent(QCloseEvent* event) {
     UpdateUISettings();
     game_list->SaveInterfaceLayout();
     hotkey_registry.SaveHotkeys();
-    Core::System::GetInstance().HIDCore().UnloadInputDevices();
+    controller_dialog->UnloadController();
+    system->HIDCore().UnloadInputDevices();
 
     // Shutdown session if the emu thread is active...
     if (emu_thread != nullptr) {
-- 
cgit v1.2.3


From 6774c7988b5a6973cad09b18b2e7bcd0a66f1f8a Mon Sep 17 00:00:00 2001
From: german77 <juangerman-13@hotmail.com>
Date: Wed, 20 Oct 2021 17:53:14 -0500
Subject: configuration: Migrate controller settings to emulated controller

---
 src/core/hid/emulated_controller.cpp               |   1 -
 src/core/hid/emulated_controller.h                 |   2 +-
 src/core/hid/hid_core.cpp                          |  21 +++
 src/core/hid/hid_core.h                            |  10 +-
 .../hle/service/am/applets/applet_controller.cpp   |  14 +-
 src/input_common/main.cpp                          |  10 ++
 src/yuzu/applets/qt_controller.cpp                 | 143 +++++++++------------
 src/yuzu/applets/qt_controller.h                   |  14 +-
 src/yuzu/applets/qt_software_keyboard.cpp          |  21 +--
 src/yuzu/configuration/configure_input.cpp         |  17 ++-
 .../configure_input_player_widget.cpp              |   4 +-
 src/yuzu/main.cpp                                  |  11 +-
 12 files changed, 141 insertions(+), 127 deletions(-)

(limited to 'src/input_common/main.cpp')

diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index 7b0c4a49b1..6622603277 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -91,7 +91,6 @@ void EmulatedController::ReloadFromSettings() {
 }
 
 void EmulatedController::ReloadInput() {
-    // LOG_ERROR(Service_HID, "reload config {}", NpadIdTypeToIndex(npad_id_type));
     // If you load any device here add the equivalent to the UnloadInput() function
     const auto left_side = button_params[Settings::NativeButton::ZL];
     const auto right_side = button_params[Settings::NativeButton::ZR];
diff --git a/src/core/hid/emulated_controller.h b/src/core/hid/emulated_controller.h
index 3a0b20cf81..f3ee707264 100644
--- a/src/core/hid/emulated_controller.h
+++ b/src/core/hid/emulated_controller.h
@@ -329,7 +329,7 @@ private:
      * @param type: Input type of the event to trigger
      * @param is_service_update: indicates if this event should be sended to only services
      */
-    void TriggerOnChange(ControllerTriggerType type, bool  is_service_update);
+    void TriggerOnChange(ControllerTriggerType type, bool is_service_update);
 
     NpadIdType npad_id_type;
     NpadType npad_type{NpadType::None};
diff --git a/src/core/hid/hid_core.cpp b/src/core/hid/hid_core.cpp
index ee76db1106..bd17081bdf 100644
--- a/src/core/hid/hid_core.cpp
+++ b/src/core/hid/hid_core.cpp
@@ -111,6 +111,27 @@ NpadStyleTag HIDCore::GetSupportedStyleTag() const {
     return supported_style_tag;
 }
 
+s8 HIDCore::GetPlayerCount() const {
+    s8 active_players = 0;
+    for (std::size_t player_index = 0; player_index < 8; player_index++) {
+        const auto* controller = GetEmulatedControllerByIndex(player_index);
+        if (controller->IsConnected()) {
+            active_players++;
+        }
+    }
+    return active_players;
+}
+
+NpadIdType HIDCore::GetFirstNpadId() const {
+    for (std::size_t player_index = 0; player_index < 10; player_index++) {
+        const auto* controller = GetEmulatedControllerByIndex(player_index);
+        if (controller->IsConnected()) {
+            return controller->GetNpadIdType();
+        }
+    }
+    return NpadIdType::Player1;
+}
+
 void HIDCore::ReloadInputDevices() {
     player_1->ReloadFromSettings();
     player_2->ReloadFromSettings();
diff --git a/src/core/hid/hid_core.h b/src/core/hid/hid_core.h
index f11f48b617..196466a72c 100644
--- a/src/core/hid/hid_core.h
+++ b/src/core/hid/hid_core.h
@@ -35,10 +35,16 @@ public:
     void SetSupportedStyleTag(NpadStyleTag style_tag);
     NpadStyleTag GetSupportedStyleTag() const;
 
-    // Reloads all input devices from settings
+    /// Counts the connected players from P1-P8
+    s8 GetPlayerCount() const;
+
+    /// Returns the first connected npad id
+    NpadIdType GetFirstNpadId() const;
+
+    /// Reloads all input devices from settings
     void ReloadInputDevices();
 
-    // Removes all callbacks from input common
+    /// Removes all callbacks from input common
     void UnloadInputDevices();
 
 private:
diff --git a/src/core/hle/service/am/applets/applet_controller.cpp b/src/core/hle/service/am/applets/applet_controller.cpp
index c1b6cd1266..658265a004 100644
--- a/src/core/hle/service/am/applets/applet_controller.cpp
+++ b/src/core/hle/service/am/applets/applet_controller.cpp
@@ -243,19 +243,11 @@ void Controller::Execute() {
 void Controller::ConfigurationComplete() {
     ControllerSupportResultInfo result_info{};
 
-    const auto& players = Settings::values.players.GetValue();
-
     // If enable_single_mode is enabled, player_count is 1 regardless of any other parameters.
     // Otherwise, only count connected players from P1-P8.
-    result_info.player_count =
-        is_single_mode
-            ? 1
-            : static_cast<s8>(std::count_if(players.begin(), players.end() - 2,
-                                            [](const auto& player) { return player.connected; }));
-
-    result_info.selected_id = HID::Controller_NPad::IndexToNPad(std::distance(
-        players.begin(), std::find_if(players.begin(), players.end(),
-                                      [](const auto& player) { return player.connected; })));
+    result_info.player_count = is_single_mode ? 1 : system.HIDCore().GetPlayerCount();
+
+    result_info.selected_id = static_cast<u32>(system.HIDCore().GetFirstNpadId());
 
     result_info.result = 0;
 
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index 7807dd38ff..b048783c91 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -32,12 +32,17 @@ struct InputSubsystem::Impl {
         keyboard = std::make_shared<Keyboard>("keyboard");
         keyboard->SetMappingCallback(mapping_callback);
         keyboard_factory = std::make_shared<InputFactory>(keyboard);
+        keyboard_output_factory = std::make_shared<OutputFactory>(keyboard);
         Input::RegisterFactory<Input::InputDevice>(keyboard->GetEngineName(), keyboard_factory);
+        Input::RegisterFactory<Input::OutputDevice>(keyboard->GetEngineName(),
+                                                    keyboard_output_factory);
 
         mouse = std::make_shared<Mouse>("mouse");
         mouse->SetMappingCallback(mapping_callback);
         mouse_factory = std::make_shared<InputFactory>(mouse);
+        mouse_output_factory = std::make_shared<OutputFactory>(mouse);
         Input::RegisterFactory<Input::InputDevice>(mouse->GetEngineName(), mouse_factory);
+        Input::RegisterFactory<Input::OutputDevice>(mouse->GetEngineName(), mouse_output_factory);
 
         touch_screen = std::make_shared<TouchScreen>("touch");
         touch_screen_factory = std::make_shared<InputFactory>(touch_screen);
@@ -61,7 +66,9 @@ struct InputSubsystem::Impl {
         tas_input = std::make_shared<TasInput::Tas>("tas");
         tas_input->SetMappingCallback(mapping_callback);
         tas_input_factory = std::make_shared<InputFactory>(tas_input);
+        tas_output_factory = std::make_shared<OutputFactory>(tas_input);
         Input::RegisterFactory<Input::InputDevice>(tas_input->GetEngineName(), tas_input_factory);
+        Input::RegisterFactory<Input::OutputDevice>(tas_input->GetEngineName(), tas_output_factory);
 
 #ifdef HAVE_SDL2
         sdl = std::make_shared<SDLDriver>("sdl");
@@ -268,7 +275,10 @@ struct InputSubsystem::Impl {
     std::shared_ptr<InputFactory> udp_client_factory;
     std::shared_ptr<InputFactory> tas_input_factory;
 
+    std::shared_ptr<OutputFactory> keyboard_output_factory;
+    std::shared_ptr<OutputFactory> mouse_output_factory;
     std::shared_ptr<OutputFactory> gcadapter_output_factory;
+    std::shared_ptr<OutputFactory> tas_output_factory;
 
 #ifdef HAVE_SDL2
     std::shared_ptr<SDLDriver> sdl;
diff --git a/src/yuzu/applets/qt_controller.cpp b/src/yuzu/applets/qt_controller.cpp
index 2cd5ed7185..32cb5b5fff 100644
--- a/src/yuzu/applets/qt_controller.cpp
+++ b/src/yuzu/applets/qt_controller.cpp
@@ -9,6 +9,8 @@
 #include "common/param_package.h"
 #include "common/string_util.h"
 #include "core/core.h"
+#include "core/hid/emulated_controller.h"
+#include "core/hid/hid_types.h"
 #include "core/hle/lock.h"
 #include "core/hle/service/hid/controllers/npad.h"
 #include "core/hle/service/hid/hid.h"
@@ -26,48 +28,31 @@ namespace {
 
 constexpr std::size_t HANDHELD_INDEX = 8;
 
-constexpr std::array<std::array<bool, 4>, 8> led_patterns{{
-    {true, false, false, false},
-    {true, true, false, false},
-    {true, true, true, false},
-    {true, true, true, true},
-    {true, false, false, true},
-    {true, false, true, false},
-    {true, false, true, true},
-    {false, true, true, false},
-}};
-
-void UpdateController(Settings::ControllerType controller_type, std::size_t npad_index,
-                      bool connected, Core::System& system) {
-    if (!system.IsPoweredOn()) {
-        return;
+void UpdateController(Core::HID::EmulatedController* controller, Core::HID::NpadType controller_type, bool connected) {
+    if (controller->IsConnected()) {
+        controller->Disconnect();
+    }
+    controller->SetNpadType(controller_type);
+    if (connected) {
+        controller->Connect();
     }
-
-    auto& npad =
-        system.ServiceManager()
-            .GetService<Service::HID::Hid>("hid")
-            ->GetAppletResource()
-            ->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad);
-
-    npad.UpdateControllerAt(Core::HID::EmulatedController::MapSettingsTypeToNPad(controller_type),
-                            npad_index, connected);
 }
 
 // Returns true if the given controller type is compatible with the given parameters.
-bool IsControllerCompatible(Settings::ControllerType controller_type,
+bool IsControllerCompatible(Core::HID::NpadType controller_type,
                             Core::Frontend::ControllerParameters parameters) {
     switch (controller_type) {
-    case Settings::ControllerType::ProController:
+    case Core::HID::NpadType::ProController:
         return parameters.allow_pro_controller;
-    case Settings::ControllerType::DualJoyconDetached:
+    case Core::HID::NpadType::JoyconDual:
         return parameters.allow_dual_joycons;
-    case Settings::ControllerType::LeftJoycon:
+    case Core::HID::NpadType::JoyconLeft:
         return parameters.allow_left_joycon;
-    case Settings::ControllerType::RightJoycon:
+    case Core::HID::NpadType::JoyconRight:
         return parameters.allow_right_joycon;
-    case Settings::ControllerType::Handheld:
+    case Core::HID::NpadType::Handheld:
         return parameters.enable_single_mode && parameters.allow_handheld;
-    case Settings::ControllerType::GameCube:
+    case Core::HID::NpadType::GameCube:
         return parameters.allow_gamecube_controller;
     default:
         return false;
@@ -198,7 +183,7 @@ QtControllerSelectorDialog::QtControllerSelectorDialog(
             connect(emulated_controllers[i], qOverload<int>(&QComboBox::currentIndexChanged),
                     [this, i](int index) {
                         UpdateDockedState(GetControllerTypeFromIndex(index, i) ==
-                                          Settings::ControllerType::Handheld);
+                                          Core::HID::NpadType::Handheld);
                     });
         }
     }
@@ -251,17 +236,17 @@ void QtControllerSelectorDialog::ApplyConfiguration() {
 }
 
 void QtControllerSelectorDialog::LoadConfiguration() {
+    const auto* handheld = system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
     for (std::size_t index = 0; index < NUM_PLAYERS; ++index) {
-        const auto connected =
-            Settings::values.players.GetValue()[index].connected ||
-            (index == 0 && Settings::values.players.GetValue()[HANDHELD_INDEX].connected);
+        const auto* controller = system.HIDCore().GetEmulatedControllerByIndex(index);
+        const auto connected = controller->IsConnected() || (index == 0 && handheld->IsConnected());
         player_groupboxes[index]->setChecked(connected);
         connected_controller_checkboxes[index]->setChecked(connected);
-        emulated_controllers[index]->setCurrentIndex(GetIndexFromControllerType(
-            Settings::values.players.GetValue()[index].controller_type, index));
+        emulated_controllers[index]->setCurrentIndex(
+            GetIndexFromControllerType(controller->GetNpadType(), index));
     }
 
-    UpdateDockedState(Settings::values.players.GetValue()[HANDHELD_INDEX].connected);
+    UpdateDockedState(handheld->IsConnected());
 
     ui->vibrationGroup->setChecked(Settings::values.vibration_enabled.GetValue());
     ui->motionGroup->setChecked(Settings::values.motion_enabled.GetValue());
@@ -417,33 +402,32 @@ void QtControllerSelectorDialog::SetEmulatedControllers(std::size_t player_index
     emulated_controllers[player_index]->clear();
 
     pairs.emplace_back(emulated_controllers[player_index]->count(),
-                       Settings::ControllerType::ProController);
+                       Core::HID::NpadType::ProController);
     emulated_controllers[player_index]->addItem(tr("Pro Controller"));
 
     pairs.emplace_back(emulated_controllers[player_index]->count(),
-                       Settings::ControllerType::DualJoyconDetached);
+                       Core::HID::NpadType::JoyconDual);
     emulated_controllers[player_index]->addItem(tr("Dual Joycons"));
 
     pairs.emplace_back(emulated_controllers[player_index]->count(),
-                       Settings::ControllerType::LeftJoycon);
+                       Core::HID::NpadType::JoyconLeft);
     emulated_controllers[player_index]->addItem(tr("Left Joycon"));
 
     pairs.emplace_back(emulated_controllers[player_index]->count(),
-                       Settings::ControllerType::RightJoycon);
+                       Core::HID::NpadType::JoyconRight);
     emulated_controllers[player_index]->addItem(tr("Right Joycon"));
 
     if (player_index == 0) {
         pairs.emplace_back(emulated_controllers[player_index]->count(),
-                           Settings::ControllerType::Handheld);
+                           Core::HID::NpadType::Handheld);
         emulated_controllers[player_index]->addItem(tr("Handheld"));
     }
 
-    pairs.emplace_back(emulated_controllers[player_index]->count(),
-                       Settings::ControllerType::GameCube);
+    pairs.emplace_back(emulated_controllers[player_index]->count(), Core::HID::NpadType::GameCube);
     emulated_controllers[player_index]->addItem(tr("GameCube Controller"));
 }
 
-Settings::ControllerType QtControllerSelectorDialog::GetControllerTypeFromIndex(
+Core::HID::NpadType QtControllerSelectorDialog::GetControllerTypeFromIndex(
     int index, std::size_t player_index) const {
     const auto& pairs = index_controller_type_pairs[player_index];
 
@@ -451,13 +435,13 @@ Settings::ControllerType QtControllerSelectorDialog::GetControllerTypeFromIndex(
                                  [index](const auto& pair) { return pair.first == index; });
 
     if (it == pairs.end()) {
-        return Settings::ControllerType::ProController;
+        return Core::HID::NpadType::ProController;
     }
 
     return it->second;
 }
 
-int QtControllerSelectorDialog::GetIndexFromControllerType(Settings::ControllerType type,
+int QtControllerSelectorDialog::GetIndexFromControllerType(Core::HID::NpadType type,
                                                            std::size_t player_index) const {
     const auto& pairs = index_controller_type_pairs[player_index];
 
@@ -481,16 +465,16 @@ void QtControllerSelectorDialog::UpdateControllerIcon(std::size_t player_index)
     const QString stylesheet = [this, player_index] {
         switch (GetControllerTypeFromIndex(emulated_controllers[player_index]->currentIndex(),
                                            player_index)) {
-        case Settings::ControllerType::ProController:
-        case Settings::ControllerType::GameCube:
+        case Core::HID::NpadType::ProController:
+        case Core::HID::NpadType::GameCube:
             return QStringLiteral("image: url(:/controller/applet_pro_controller%0); ");
-        case Settings::ControllerType::DualJoyconDetached:
+        case Core::HID::NpadType::JoyconDual:
             return QStringLiteral("image: url(:/controller/applet_dual_joycon%0); ");
-        case Settings::ControllerType::LeftJoycon:
+        case Core::HID::NpadType::JoyconLeft:
             return QStringLiteral("image: url(:/controller/applet_joycon_left%0); ");
-        case Settings::ControllerType::RightJoycon:
+        case Core::HID::NpadType::JoyconRight:
             return QStringLiteral("image: url(:/controller/applet_joycon_right%0); ");
-        case Settings::ControllerType::Handheld:
+        case Core::HID::NpadType::Handheld:
             return QStringLiteral("image: url(:/controller/applet_handheld%0); ");
         default:
             return QString{};
@@ -518,54 +502,42 @@ void QtControllerSelectorDialog::UpdateControllerIcon(std::size_t player_index)
 }
 
 void QtControllerSelectorDialog::UpdateControllerState(std::size_t player_index) {
-    auto& player = Settings::values.players.GetValue()[player_index];
+    auto* controller = system.HIDCore().GetEmulatedControllerByIndex(player_index);
 
     const auto controller_type = GetControllerTypeFromIndex(
         emulated_controllers[player_index]->currentIndex(), player_index);
     const auto player_connected = player_groupboxes[player_index]->isChecked() &&
-                                  controller_type != Settings::ControllerType::Handheld;
+                                  controller_type != Core::HID::NpadType::Handheld;
 
-    if (player.controller_type == controller_type && player.connected == player_connected) {
+    if (controller->GetNpadType() == controller_type &&
+        controller->IsConnected() == player_connected) {
         // Set vibration devices in the event that the input device has changed.
         ConfigureVibration::SetVibrationDevices(player_index);
         return;
     }
 
     // Disconnect the controller first.
-    UpdateController(controller_type, player_index, false, system);
-
-    player.controller_type = controller_type;
-    player.connected = player_connected;
+    UpdateController(controller, controller_type, false);
 
     ConfigureVibration::SetVibrationDevices(player_index);
 
     // Handheld
     if (player_index == 0) {
-        auto& handheld = Settings::values.players.GetValue()[HANDHELD_INDEX];
-        if (controller_type == Settings::ControllerType::Handheld) {
-            handheld = player;
+        if (controller_type == Core::HID::NpadType::Handheld) {
+            auto* handheld =
+                system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
+            UpdateController(handheld, Core::HID::NpadType::Handheld,
+                             player_groupboxes[player_index]->isChecked());
         }
-        handheld.connected = player_groupboxes[player_index]->isChecked() &&
-                             controller_type == Settings::ControllerType::Handheld;
-        UpdateController(Settings::ControllerType::Handheld, 8, handheld.connected, system);
     }
 
-    if (!player.connected) {
-        return;
-    }
-
-    // This emulates a delay between disconnecting and reconnecting controllers as some games
-    // do not respond to a change in controller type if it was instantaneous.
-    using namespace std::chrono_literals;
-    std::this_thread::sleep_for(60ms);
-
-    UpdateController(controller_type, player_index, player_connected, system);
+    UpdateController(controller, controller_type, player_connected);
 }
 
 void QtControllerSelectorDialog::UpdateLEDPattern(std::size_t player_index) {
     if (!player_groupboxes[player_index]->isChecked() ||
         GetControllerTypeFromIndex(emulated_controllers[player_index]->currentIndex(),
-                                   player_index) == Settings::ControllerType::Handheld) {
+                                   player_index) == Core::HID::NpadType::Handheld) {
         led_patterns_boxes[player_index][0]->setChecked(false);
         led_patterns_boxes[player_index][1]->setChecked(false);
         led_patterns_boxes[player_index][2]->setChecked(false);
@@ -573,10 +545,12 @@ void QtControllerSelectorDialog::UpdateLEDPattern(std::size_t player_index) {
         return;
     }
 
-    led_patterns_boxes[player_index][0]->setChecked(led_patterns[player_index][0]);
-    led_patterns_boxes[player_index][1]->setChecked(led_patterns[player_index][1]);
-    led_patterns_boxes[player_index][2]->setChecked(led_patterns[player_index][2]);
-    led_patterns_boxes[player_index][3]->setChecked(led_patterns[player_index][3]);
+    const auto* controller = system.HIDCore().GetEmulatedControllerByIndex(player_index);
+    const auto led_pattern = controller->GetLedPattern();
+    led_patterns_boxes[player_index][0]->setChecked(led_pattern.position1);
+    led_patterns_boxes[player_index][1]->setChecked(led_pattern.position2);
+    led_patterns_boxes[player_index][2]->setChecked(led_pattern.position3);
+    led_patterns_boxes[player_index][3]->setChecked(led_pattern.position4);
 }
 
 void QtControllerSelectorDialog::UpdateBorderColor(std::size_t player_index) {
@@ -656,10 +630,9 @@ void QtControllerSelectorDialog::DisableUnsupportedPlayers() {
     }
 
     for (std::size_t index = max_supported_players; index < NUM_PLAYERS; ++index) {
+        auto* controller = system.HIDCore().GetEmulatedControllerByIndex(index);
         // Disconnect any unsupported players here and disable or hide them if applicable.
-        Settings::values.players.GetValue()[index].connected = false;
-        UpdateController(Settings::values.players.GetValue()[index].controller_type, index, false,
-                         system);
+        UpdateController(controller, controller->GetNpadType(), false);
         // Hide the player widgets when max_supported_controllers is less than or equal to 4.
         if (max_supported_players <= 4) {
             player_widgets[index]->hide();
diff --git a/src/yuzu/applets/qt_controller.h b/src/yuzu/applets/qt_controller.h
index ca09fde04f..dd981f4795 100644
--- a/src/yuzu/applets/qt_controller.h
+++ b/src/yuzu/applets/qt_controller.h
@@ -23,10 +23,6 @@ namespace InputCommon {
 class InputSubsystem;
 }
 
-namespace Settings {
-enum class ControllerType;
-}
-
 namespace Ui {
 class QtControllerSelectorDialog;
 }
@@ -35,6 +31,10 @@ namespace Core {
 class System;
 }
 
+namespace Core::HID {
+enum class NpadType : u8;
+}
+
 class QtControllerSelectorDialog final : public QDialog {
     Q_OBJECT
 
@@ -74,10 +74,10 @@ private:
     void SetEmulatedControllers(std::size_t player_index);
 
     // Gets the Controller Type for a given controller combobox index per player.
-    Settings::ControllerType GetControllerTypeFromIndex(int index, std::size_t player_index) const;
+    Core::HID::NpadType GetControllerTypeFromIndex(int index, std::size_t player_index) const;
 
     // Gets the controller combobox index for a given Controller Type per player.
-    int GetIndexFromControllerType(Settings::ControllerType type, std::size_t player_index) const;
+    int GetIndexFromControllerType(Core::HID::NpadType type, std::size_t player_index) const;
 
     // Updates the controller icons per player.
     void UpdateControllerIcon(std::size_t player_index);
@@ -139,7 +139,7 @@ private:
     std::array<QComboBox*, NUM_PLAYERS> emulated_controllers;
 
     /// Pairs of emulated controller index and Controller Type enum per player.
-    std::array<std::vector<std::pair<int, Settings::ControllerType>>, NUM_PLAYERS>
+    std::array<std::vector<std::pair<int, Core::HID::NpadType>>, NUM_PLAYERS>
         index_controller_type_pairs;
 
     // Labels representing the number of connected controllers
diff --git a/src/yuzu/applets/qt_software_keyboard.cpp b/src/yuzu/applets/qt_software_keyboard.cpp
index 7e87312322..3d91f80341 100644
--- a/src/yuzu/applets/qt_software_keyboard.cpp
+++ b/src/yuzu/applets/qt_software_keyboard.cpp
@@ -10,6 +10,8 @@
 #include "common/settings.h"
 #include "common/string_util.h"
 #include "core/core.h"
+#include "core/hid/emulated_controller.h"
+#include "core/hid/hid_core.h"
 #include "core/hid/hid_types.h"
 #include "core/hid/input_interpreter.h"
 #include "ui_qt_software_keyboard.h"
@@ -796,9 +798,10 @@ void QtSoftwareKeyboardDialog::SetTextDrawType() {
 }
 
 void QtSoftwareKeyboardDialog::SetControllerImage() {
-    const auto controller_type = Settings::values.players.GetValue()[8].connected
-                                     ? Settings::values.players.GetValue()[8].controller_type
-                                     : Settings::values.players.GetValue()[0].controller_type;
+    const auto* handheld = system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
+    const auto* player_1 = system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
+    const auto controller_type =
+        handheld->IsConnected() ? handheld->GetNpadType() : player_1->GetNpadType();
 
     const QString theme = [] {
         if (QIcon::themeName().contains(QStringLiteral("dark")) ||
@@ -810,8 +813,8 @@ void QtSoftwareKeyboardDialog::SetControllerImage() {
     }();
 
     switch (controller_type) {
-    case Settings::ControllerType::ProController:
-    case Settings::ControllerType::GameCube:
+    case Core::HID::NpadType::ProController:
+    case Core::HID::NpadType::GameCube:
         ui->icon_controller->setStyleSheet(
             QStringLiteral("image: url(:/overlay/controller_pro%1.png);").arg(theme));
         ui->icon_controller_shift->setStyleSheet(
@@ -819,7 +822,7 @@ void QtSoftwareKeyboardDialog::SetControllerImage() {
         ui->icon_controller_num->setStyleSheet(
             QStringLiteral("image: url(:/overlay/controller_pro%1.png);").arg(theme));
         break;
-    case Settings::ControllerType::DualJoyconDetached:
+    case Core::HID::NpadType::JoyconDual:
         ui->icon_controller->setStyleSheet(
             QStringLiteral("image: url(:/overlay/controller_dual_joycon%1.png);").arg(theme));
         ui->icon_controller_shift->setStyleSheet(
@@ -827,7 +830,7 @@ void QtSoftwareKeyboardDialog::SetControllerImage() {
         ui->icon_controller_num->setStyleSheet(
             QStringLiteral("image: url(:/overlay/controller_dual_joycon%1.png);").arg(theme));
         break;
-    case Settings::ControllerType::LeftJoycon:
+    case Core::HID::NpadType::JoyconLeft:
         ui->icon_controller->setStyleSheet(
             QStringLiteral("image: url(:/overlay/controller_single_joycon_left%1.png);")
                 .arg(theme));
@@ -838,7 +841,7 @@ void QtSoftwareKeyboardDialog::SetControllerImage() {
             QStringLiteral("image: url(:/overlay/controller_single_joycon_left%1.png);")
                 .arg(theme));
         break;
-    case Settings::ControllerType::RightJoycon:
+    case Core::HID::NpadType::JoyconRight:
         ui->icon_controller->setStyleSheet(
             QStringLiteral("image: url(:/overlay/controller_single_joycon_right%1.png);")
                 .arg(theme));
@@ -849,7 +852,7 @@ void QtSoftwareKeyboardDialog::SetControllerImage() {
             QStringLiteral("image: url(:/overlay/controller_single_joycon_right%1.png);")
                 .arg(theme));
         break;
-    case Settings::ControllerType::Handheld:
+    case Core::HID::NpadType::Handheld:
         ui->icon_controller->setStyleSheet(
             QStringLiteral("image: url(:/overlay/controller_handheld%1.png);").arg(theme));
         ui->icon_controller_shift->setStyleSheet(
diff --git a/src/yuzu/configuration/configure_input.cpp b/src/yuzu/configuration/configure_input.cpp
index 67faa8be8a..dece27fdeb 100644
--- a/src/yuzu/configuration/configure_input.cpp
+++ b/src/yuzu/configuration/configure_input.cpp
@@ -211,8 +211,10 @@ void ConfigureInput::RetranslateUI() {
 }
 
 void ConfigureInput::LoadConfiguration() {
+    const auto* handheld = system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
+
     LoadPlayerControllerIndices();
-    UpdateDockedState(Settings::values.players.GetValue()[8].connected);
+    UpdateDockedState(handheld->IsConnected());
 
     ui->vibrationGroup->setChecked(Settings::values.vibration_enabled.GetValue());
     ui->motionGroup->setChecked(Settings::values.motion_enabled.GetValue());
@@ -220,9 +222,16 @@ void ConfigureInput::LoadConfiguration() {
 
 void ConfigureInput::LoadPlayerControllerIndices() {
     for (std::size_t i = 0; i < player_connected.size(); ++i) {
-        const auto connected = Settings::values.players.GetValue()[i].connected ||
-                               (i == 0 && Settings::values.players.GetValue()[8].connected);
-        player_connected[i]->setChecked(connected);
+        if (i == 0) {
+            auto* handheld =
+                system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
+            if (handheld->IsConnected()) {
+                player_connected[i]->setChecked(true);
+                continue;
+            }
+        }
+        const auto* controller = system.HIDCore().GetEmulatedControllerByIndex(i);
+        player_connected[i]->setChecked(controller->IsConnected());
     }
 }
 
diff --git a/src/yuzu/configuration/configure_input_player_widget.cpp b/src/yuzu/configuration/configure_input_player_widget.cpp
index 93f7eddc92..be87204fc3 100644
--- a/src/yuzu/configuration/configure_input_player_widget.cpp
+++ b/src/yuzu/configuration/configure_input_player_widget.cpp
@@ -104,8 +104,8 @@ void PlayerControlPreview::UpdateColors() {
     colors.left = colors.primary;
     colors.right = colors.primary;
     // Possible alternative to set colors from settings
-    // colors.left = QColor(Settings::values.players.GetValue()[player_index].body_color_left);
-    // colors.right = QColor(Settings::values.players.GetValue()[player_index].body_color_right);
+    // colors.left = QColor(controller->GetColors().left.body);
+    // colors.right = QColor(controller->GetColors().right.body);
 }
 
 void PlayerControlPreview::ResetInputs() {
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index ae997ccfa3..46a5f62adf 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -832,15 +832,16 @@ void GMainWindow::InitializeWidgets() {
     dock_status_button->setFocusPolicy(Qt::NoFocus);
     connect(dock_status_button, &QPushButton::clicked, [&] {
         const bool is_docked = Settings::values.use_docked_mode.GetValue();
-        auto& controller_type = Settings::values.players.GetValue()[0].controller_type;
+        auto* player_1 = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
+        auto* handheld = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
 
-        if (!is_docked && controller_type == Settings::ControllerType::Handheld) {
+        if (!is_docked && handheld->IsConnected()) {
             QMessageBox::warning(this, tr("Invalid config detected"),
                                  tr("Handheld controller can't be used on docked mode. Pro "
                                     "controller will be selected."));
-            controller_type = Settings::ControllerType::ProController;
-            ConfigureDialog configure_dialog(this, hotkey_registry, input_subsystem.get(), *system);
-            configure_dialog.ApplyConfiguration();
+            handheld->Disconnect();
+            player_1->SetNpadType(Core::HID::NpadType::ProController);
+            player_1->Connect();
         }
 
         Settings::values.use_docked_mode.SetValue(!is_docked);
-- 
cgit v1.2.3


From b3f59b44076a9cfa405bf907b1e49d4b3e1279c5 Mon Sep 17 00:00:00 2001
From: german77 <juangerman-13@hotmail.com>
Date: Thu, 21 Oct 2021 13:56:52 -0500
Subject: kraken: Address comments from review

review fixes
---
 src/core/frontend/applets/controller.cpp      | 51 +++++++++++----------------
 src/core/frontend/applets/controller.h        |  8 ++---
 src/core/hid/emulated_console.cpp             |  2 --
 src/core/hid/emulated_controller.cpp          | 12 +++++--
 src/core/hid/emulated_controller.h            |  1 -
 src/core/hid/hid_core.cpp                     |  4 +--
 src/core/hid/hid_core.h                       |  3 ++
 src/core/hle/service/am/applets/applets.cpp   |  2 +-
 src/core/hle/service/hid/controllers/npad.cpp | 10 +++---
 src/core/hle/service/hid/controllers/npad.h   |  2 +-
 src/core/hle/service/hid/hid.cpp              |  3 +-
 src/input_common/drivers/udp_client.cpp       |  2 ++
 src/input_common/drivers/udp_client.h         |  4 +--
 src/input_common/helpers/stick_from_buttons.h |  1 -
 src/input_common/main.cpp                     |  7 ++--
 15 files changed, 56 insertions(+), 56 deletions(-)

(limited to 'src/input_common/main.cpp')

diff --git a/src/core/frontend/applets/controller.cpp b/src/core/frontend/applets/controller.cpp
index ca1edce15f..30500ef1ef 100644
--- a/src/core/frontend/applets/controller.cpp
+++ b/src/core/frontend/applets/controller.cpp
@@ -5,16 +5,16 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/frontend/applets/controller.h"
-#include "core/hle/service/hid/controllers/npad.h"
-#include "core/hle/service/hid/hid.h"
-#include "core/hle/service/sm/sm.h"
+#include "core/hid/emulated_controller.h"
+#include "core/hid/hid_core.h"
+#include "core/hid/hid_types.h"
 
 namespace Core::Frontend {
 
 ControllerApplet::~ControllerApplet() = default;
 
-DefaultControllerApplet::DefaultControllerApplet(Service::SM::ServiceManager& service_manager_)
-    : service_manager{service_manager_} {}
+DefaultControllerApplet::DefaultControllerApplet(HID::HIDCore& hid_core_)
+    : hid_core{hid_core_} {}
 
 DefaultControllerApplet::~DefaultControllerApplet() = default;
 
@@ -22,24 +22,20 @@ void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callb
                                                      const ControllerParameters& parameters) const {
     LOG_INFO(Service_HID, "called, deducing the best configuration based on the given parameters!");
 
-    auto& npad =
-        service_manager.GetService<Service::HID::Hid>("hid")
-            ->GetAppletResource()
-            ->GetController<Service::HID::Controller_NPad>(Service::HID::HidController::NPad);
-
-    auto& players = Settings::values.players.GetValue();
-
     const std::size_t min_supported_players =
         parameters.enable_single_mode ? 1 : parameters.min_players;
 
     // Disconnect Handheld first.
-    npad.DisconnectNpadAtIndex(8);
+    auto* handheld =hid_core.GetEmulatedController(Core::HID::NpadIdType::Handheld);
+    handheld->Disconnect();
 
     // Deduce the best configuration based on the input parameters.
-    for (std::size_t index = 0; index < players.size() - 2; ++index) {
+    for (std::size_t index = 0; index < hid_core.available_controllers - 2; ++index) {
+        auto* controller = hid_core.GetEmulatedControllerByIndex(index);
+
         // First, disconnect all controllers regardless of the value of keep_controllers_connected.
         // This makes it easy to connect the desired controllers.
-        npad.DisconnectNpadAtIndex(index);
+        controller->Disconnect();
 
         // Only connect the minimum number of required players.
         if (index >= min_supported_players) {
@@ -49,32 +45,27 @@ void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callb
         // Connect controllers based on the following priority list from highest to lowest priority:
         // Pro Controller -> Dual Joycons -> Left Joycon/Right Joycon -> Handheld
         if (parameters.allow_pro_controller) {
-            npad.AddNewControllerAt(Core::HID::EmulatedController::MapSettingsTypeToNPad(
-                                        Settings::ControllerType::ProController),
-                                    index);
+            controller->SetNpadType(Core::HID::NpadType::ProController);
+            controller->Connect();
         } else if (parameters.allow_dual_joycons) {
-            npad.AddNewControllerAt(Core::HID::EmulatedController::MapSettingsTypeToNPad(
-                                        Settings::ControllerType::DualJoyconDetached),
-                                    index);
+            controller->SetNpadType(Core::HID::NpadType::JoyconDual);
+            controller->Connect();
         } else if (parameters.allow_left_joycon && parameters.allow_right_joycon) {
             // Assign left joycons to even player indices and right joycons to odd player indices.
             // We do this since Captain Toad Treasure Tracker expects a left joycon for Player 1 and
             // a right Joycon for Player 2 in 2 Player Assist mode.
             if (index % 2 == 0) {
-                npad.AddNewControllerAt(Core::HID::EmulatedController::MapSettingsTypeToNPad(
-                                            Settings::ControllerType::LeftJoycon),
-                                        index);
+                controller->SetNpadType(Core::HID::NpadType::JoyconLeft);
+                controller->Connect();
             } else {
-                npad.AddNewControllerAt(Core::HID::EmulatedController::MapSettingsTypeToNPad(
-                                            Settings::ControllerType::RightJoycon),
-                                        index);
+                controller->SetNpadType(Core::HID::NpadType::JoyconRight);
+                controller->Connect();
             }
         } else if (index == 0 && parameters.enable_single_mode && parameters.allow_handheld &&
                    !Settings::values.use_docked_mode.GetValue()) {
             // We should *never* reach here under any normal circumstances.
-            npad.AddNewControllerAt(Core::HID::EmulatedController::MapSettingsTypeToNPad(
-                                        Settings::ControllerType::Handheld),
-                                    index);
+            controller->SetNpadType(Core::HID::NpadType::Handheld);
+            controller->Connect();
         } else {
             UNREACHABLE_MSG("Unable to add a new controller based on the given parameters!");
         }
diff --git a/src/core/frontend/applets/controller.h b/src/core/frontend/applets/controller.h
index b0626a0f9c..014bc89011 100644
--- a/src/core/frontend/applets/controller.h
+++ b/src/core/frontend/applets/controller.h
@@ -8,8 +8,8 @@
 
 #include "common/common_types.h"
 
-namespace Service::SM {
-class ServiceManager;
+namespace Core::HID {
+class HIDCore;
 }
 
 namespace Core::Frontend {
@@ -44,14 +44,14 @@ public:
 
 class DefaultControllerApplet final : public ControllerApplet {
 public:
-    explicit DefaultControllerApplet(Service::SM::ServiceManager& service_manager_);
+    explicit DefaultControllerApplet(HID::HIDCore& hid_core_);
     ~DefaultControllerApplet() override;
 
     void ReconfigureControllers(std::function<void()> callback,
                                 const ControllerParameters& parameters) const override;
 
 private:
-    Service::SM::ServiceManager& service_manager;
+    HID::HIDCore& hid_core;
 };
 
 } // namespace Core::Frontend
diff --git a/src/core/hid/emulated_console.cpp b/src/core/hid/emulated_console.cpp
index e82cf59905..540fd107be 100644
--- a/src/core/hid/emulated_console.cpp
+++ b/src/core/hid/emulated_console.cpp
@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included
 
-#include <fmt/format.h>
-
 #include "core/hid/emulated_console.h"
 #include "core/hid/input_converter.h"
 
diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index 1ff3022c5f..d59758e999 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included
 
-#include <fmt/format.h>
-
 #include "core/hid/emulated_controller.h"
 #include "core/hid/input_converter.h"
 
@@ -635,6 +633,9 @@ void EmulatedController::SetBattery(Input::CallbackStatus callback, std::size_t
 }
 
 bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue vibration) {
+    if (device_index >= output_devices.size()) {
+        return false;
+    }
     if (!output_devices[device_index]) {
         return false;
     }
@@ -659,6 +660,9 @@ bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue v
 }
 
 bool EmulatedController::TestVibration(std::size_t device_index) {
+    if (device_index >= output_devices.size()) {
+        return false;
+    }
     if (!output_devices[device_index]) {
         return false;
     }
@@ -733,7 +737,9 @@ bool EmulatedController::IsConnected(bool temporary) const {
 }
 
 bool EmulatedController::IsVibrationEnabled() const {
-    return is_vibration_enabled;
+    const auto player_index = NpadIdTypeToIndex(npad_id_type);
+    const auto& player = Settings::values.players.GetValue()[player_index];
+    return player.vibration_enabled;
 }
 
 NpadIdType EmulatedController::GetNpadIdType() const {
diff --git a/src/core/hid/emulated_controller.h b/src/core/hid/emulated_controller.h
index f3ee707264..50f21ccd9c 100644
--- a/src/core/hid/emulated_controller.h
+++ b/src/core/hid/emulated_controller.h
@@ -337,7 +337,6 @@ private:
     bool is_connected{false};
     bool temporary_is_connected{false};
     bool is_configuring{false};
-    bool is_vibration_enabled{true};
     f32 motion_sensitivity{0.01f};
 
     ButtonParams button_params;
diff --git a/src/core/hid/hid_core.cpp b/src/core/hid/hid_core.cpp
index bd17081bdf..cc1b3c2950 100644
--- a/src/core/hid/hid_core.cpp
+++ b/src/core/hid/hid_core.cpp
@@ -113,7 +113,7 @@ NpadStyleTag HIDCore::GetSupportedStyleTag() const {
 
 s8 HIDCore::GetPlayerCount() const {
     s8 active_players = 0;
-    for (std::size_t player_index = 0; player_index < 8; player_index++) {
+    for (std::size_t player_index = 0; player_index < available_controllers -2; player_index++) {
         const auto* controller = GetEmulatedControllerByIndex(player_index);
         if (controller->IsConnected()) {
             active_players++;
@@ -123,7 +123,7 @@ s8 HIDCore::GetPlayerCount() const {
 }
 
 NpadIdType HIDCore::GetFirstNpadId() const {
-    for (std::size_t player_index = 0; player_index < 10; player_index++) {
+    for (std::size_t player_index = 0; player_index < available_controllers; player_index++) {
         const auto* controller = GetEmulatedControllerByIndex(player_index);
         if (controller->IsConnected()) {
             return controller->GetNpadIdType();
diff --git a/src/core/hid/hid_core.h b/src/core/hid/hid_core.h
index 196466a72c..a4a66a3a44 100644
--- a/src/core/hid/hid_core.h
+++ b/src/core/hid/hid_core.h
@@ -47,6 +47,9 @@ public:
     /// Removes all callbacks from input common
     void UnloadInputDevices();
 
+    /// Number of emulated controllers
+    const std::size_t available_controllers{10};
+
 private:
     std::unique_ptr<EmulatedController> player_1;
     std::unique_ptr<EmulatedController> player_2;
diff --git a/src/core/hle/service/am/applets/applets.cpp b/src/core/hle/service/am/applets/applets.cpp
index 7320b1c0fe..134ac1ee2c 100644
--- a/src/core/hle/service/am/applets/applets.cpp
+++ b/src/core/hle/service/am/applets/applets.cpp
@@ -231,7 +231,7 @@ void AppletManager::SetDefaultAppletFrontendSet() {
 void AppletManager::SetDefaultAppletsIfMissing() {
     if (frontend.controller == nullptr) {
         frontend.controller =
-            std::make_unique<Core::Frontend::DefaultControllerApplet>(system.ServiceManager());
+            std::make_unique<Core::Frontend::DefaultControllerApplet>(system.HIDCore());
     }
 
     if (frontend.error == nullptr) {
diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp
index 6b9d6d11c3..62b324080e 100644
--- a/src/core/hle/service/hid/controllers/npad.cpp
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@@ -608,15 +608,15 @@ void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing
         sixaxis_fullkey_state.sampling_number =
             npad.sixaxis_fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
         sixaxis_handheld_state.sampling_number =
-            npad.sixaxis_fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
+            npad.sixaxis_handheld_lifo.ReadCurrentEntry().state.sampling_number + 1;
         sixaxis_dual_left_state.sampling_number =
-            npad.sixaxis_fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
+            npad.sixaxis_dual_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
         sixaxis_dual_right_state.sampling_number =
-            npad.sixaxis_fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
+            npad.sixaxis_dual_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
         sixaxis_left_lifo_state.sampling_number =
-            npad.sixaxis_fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
+            npad.sixaxis_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
         sixaxis_right_lifo_state.sampling_number =
-            npad.sixaxis_fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
+            npad.sixaxis_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
 
         npad.sixaxis_fullkey_lifo.WriteNextEntry(sixaxis_fullkey_state);
         npad.sixaxis_handheld_lifo.WriteNextEntry(sixaxis_handheld_state);
diff --git a/src/core/hle/service/hid/controllers/npad.h b/src/core/hle/service/hid/controllers/npad.h
index d805ccb97a..1c6ea6f888 100644
--- a/src/core/hle/service/hid/controllers/npad.h
+++ b/src/core/hle/service/hid/controllers/npad.h
@@ -342,7 +342,7 @@ private:
         INSERT_PADDING_BYTES(0x4);
     };
 
-    // This is nn::hid::server::NpadGcTriggerState
+    // This is nn::hid::system::AppletFooterUiType
     enum class AppletFooterUiType : u8 {
         None = 0,
         HandheldNone = 1,
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 5391334f43..ac48f96d3b 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -8,7 +8,6 @@
 #include "common/settings.h"
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/hardware_properties.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/k_readable_event.h"
 #include "core/hle/kernel/k_shared_memory.h"
@@ -34,7 +33,7 @@
 namespace Service::HID {
 
 // Updating period for each HID device.
-// Period time is obtained by measuring the number of samples in a second
+// Period time is obtained by measuring the number of samples in a second on HW using a homebrew
 constexpr auto pad_update_ns = std::chrono::nanoseconds{4 * 1000 * 1000};    // (4ms, 250Hz)
 constexpr auto motion_update_ns = std::chrono::nanoseconds{5 * 1000 * 1000}; // (5ms, 200Hz)
 constexpr std::size_t SHARED_MEMORY_SIZE = 0x40000;
diff --git a/src/input_common/drivers/udp_client.cpp b/src/input_common/drivers/udp_client.cpp
index f0c0a6b8bf..192ab336b9 100644
--- a/src/input_common/drivers/udp_client.cpp
+++ b/src/input_common/drivers/udp_client.cpp
@@ -268,6 +268,8 @@ void UDPClient::OnPadData(Response::PadData data, std::size_t client) {
             SetButton(identifier, touch_id, true);
             continue;
         }
+        SetAxis(identifier, touch_id * 2, 0);
+        SetAxis(identifier, touch_id * 2 + 1, 0);
         SetButton(identifier, touch_id, false);
     }
 }
diff --git a/src/input_common/drivers/udp_client.h b/src/input_common/drivers/udp_client.h
index 58b2e921d1..639325b177 100644
--- a/src/input_common/drivers/udp_client.h
+++ b/src/input_common/drivers/udp_client.h
@@ -1,6 +1,6 @@
-// Copyright 2021 yuzu Emulator Project
+// Copyright 2018 Citra Emulator Project
 // Licensed under GPLv2 or any later version
-// Refer to the license.txt file included
+// Refer to the license.txt file included.
 
 #pragma once
 
diff --git a/src/input_common/helpers/stick_from_buttons.h b/src/input_common/helpers/stick_from_buttons.h
index 1d6e24c98e..82dff5ca87 100644
--- a/src/input_common/helpers/stick_from_buttons.h
+++ b/src/input_common/helpers/stick_from_buttons.h
@@ -1,4 +1,3 @@
-
 // Copyright 2017 Citra Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index b048783c91..8f7ce59b78 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -87,25 +87,30 @@ struct InputSubsystem::Impl {
 
     void Shutdown() {
         Input::UnregisterFactory<Input::InputDevice>(keyboard->GetEngineName());
+        Input::UnregisterFactory<Input::OutputDevice>(keyboard->GetEngineName());
         keyboard.reset();
 
         Input::UnregisterFactory<Input::InputDevice>(mouse->GetEngineName());
+        Input::UnregisterFactory<Input::OutputDevice>(mouse->GetEngineName());
         mouse.reset();
 
         Input::UnregisterFactory<Input::InputDevice>(touch_screen->GetEngineName());
         touch_screen.reset();
 
         Input::UnregisterFactory<Input::InputDevice>(gcadapter->GetEngineName());
+        Input::UnregisterFactory<Input::OutputDevice>(gcadapter->GetEngineName());
         gcadapter.reset();
 
         Input::UnregisterFactory<Input::InputDevice>(udp_client->GetEngineName());
         udp_client.reset();
 
         Input::UnregisterFactory<Input::InputDevice>(tas_input->GetEngineName());
+        Input::UnregisterFactory<Input::OutputDevice>(tas_input->GetEngineName());
         tas_input.reset();
 
 #ifdef HAVE_SDL2
         Input::UnregisterFactory<Input::InputDevice>(sdl->GetEngineName());
+        Input::UnregisterFactory<Input::OutputDevice>(sdl->GetEngineName());
         sdl.reset();
 #endif
 
@@ -124,8 +129,6 @@ struct InputSubsystem::Impl {
         devices.insert(devices.end(), mouse_devices.begin(), mouse_devices.end());
         auto gcadapter_devices = gcadapter->GetInputDevices();
         devices.insert(devices.end(), gcadapter_devices.begin(), gcadapter_devices.end());
-        auto tas_input_devices = tas_input->GetInputDevices();
-        devices.insert(devices.end(), tas_input_devices.begin(), tas_input_devices.end());
 #ifdef HAVE_SDL2
         auto sdl_devices = sdl->GetInputDevices();
         devices.insert(devices.end(), sdl_devices.begin(), sdl_devices.end());
-- 
cgit v1.2.3


From d1bac9024d8bec7c387f835934ef7847b0e42175 Mon Sep 17 00:00:00 2001
From: german77 <juangerman-13@hotmail.com>
Date: Sun, 24 Oct 2021 11:22:20 -0500
Subject: settings: Fix mouse and keyboard mappings

---
 src/core/hid/emulated_controller.cpp              |   8 +-
 src/core/hid/emulated_devices.cpp                 |  19 +--
 src/core/hid/emulated_devices.h                   |   3 +
 src/input_common/drivers/mouse.cpp                |  17 ++-
 src/input_common/drivers/mouse.h                  |   1 +
 src/input_common/input_engine.cpp                 |   2 +
 src/input_common/main.cpp                         |   3 +
 src/yuzu/configuration/configure_input_player.cpp | 147 +++++++++-------------
 src/yuzu/configuration/configure_vibration.cpp    |   4 +-
 src/yuzu/debugger/controller.cpp                  |   3 +-
 10 files changed, 102 insertions(+), 105 deletions(-)

(limited to 'src/input_common/main.cpp')

diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index 228f801833..bd0b89c056 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -246,7 +246,7 @@ std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices() const {
             devices.begin(), devices.end(), [param](const Common::ParamPackage param_) {
                 return param.Get("engine", "") == param_.Get("engine", "") &&
                        param.Get("guid", "") == param_.Get("guid", "") &&
-                       param.Get("port", "") == param_.Get("port", "");
+                       param.Get("port", 0) == param_.Get("port", 0);
             });
         if (devices_it != devices.end()) {
             continue;
@@ -254,7 +254,7 @@ std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices() const {
         Common::ParamPackage device{};
         device.Set("engine", param.Get("engine", ""));
         device.Set("guid", param.Get("guid", ""));
-        device.Set("port", param.Get("port", ""));
+        device.Set("port", param.Get("port", 0));
         devices.push_back(device);
     }
 
@@ -269,7 +269,7 @@ std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices() const {
             devices.begin(), devices.end(), [param](const Common::ParamPackage param_) {
                 return param.Get("engine", "") == param_.Get("engine", "") &&
                        param.Get("guid", "") == param_.Get("guid", "") &&
-                       param.Get("port", "") == param_.Get("port", "");
+                       param.Get("port", 0) == param_.Get("port", 0);
             });
         if (devices_it != devices.end()) {
             continue;
@@ -277,7 +277,7 @@ std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices() const {
         Common::ParamPackage device{};
         device.Set("engine", param.Get("engine", ""));
         device.Set("guid", param.Get("guid", ""));
-        device.Set("port", param.Get("port", ""));
+        device.Set("port", param.Get("port", 0));
         devices.push_back(device);
     }
     return devices;
diff --git a/src/core/hid/emulated_devices.cpp b/src/core/hid/emulated_devices.cpp
index 1c4065cd85..5afd83f62c 100644
--- a/src/core/hid/emulated_devices.cpp
+++ b/src/core/hid/emulated_devices.cpp
@@ -162,17 +162,22 @@ void EmulatedDevices::SetKeyboardButton(Input::CallbackStatus callback, std::siz
         return;
     }
 
-    // TODO(german77): Do this properly
-    // switch (index) {
-    // case Settings::NativeKeyboard::A:
-    //    interface_status.keyboard_state.a.Assign(current_status.value);
-    //    break;
-    //    ....
-    // }
+    UpdateKey(index, current_status.value);
 
     TriggerOnChange(DeviceTriggerType::Keyboard);
 }
 
+void EmulatedDevices::UpdateKey(std::size_t key_index, bool status) {
+    constexpr u8 KEYS_PER_BYTE = 8;
+    auto& entry = device_status.keyboard_state.key[key_index / KEYS_PER_BYTE];
+    const u8 mask = 1 << (key_index % KEYS_PER_BYTE);
+    if (status) {
+        entry = entry | mask;
+    } else {
+        entry = entry & ~mask;
+    }
+}
+
 void EmulatedDevices::SetKeyboardModifier(Input::CallbackStatus callback, std::size_t index) {
     if (index >= device_status.keyboard_moddifier_values.size()) {
         return;
diff --git a/src/core/hid/emulated_devices.h b/src/core/hid/emulated_devices.h
index c6c19fae4e..7ed95eac6b 100644
--- a/src/core/hid/emulated_devices.h
+++ b/src/core/hid/emulated_devices.h
@@ -143,6 +143,9 @@ public:
     void DeleteCallback(int key);
 
 private:
+    /// Helps assigning a value to keyboard_state
+    void UpdateKey(std::size_t key_index, bool status);
+
     /**
      * Updates the touch status of the console
      * @param callback: A CallbackStatus containing the key status
diff --git a/src/input_common/drivers/mouse.cpp b/src/input_common/drivers/mouse.cpp
index 2c2432fb72..1c32b54bea 100644
--- a/src/input_common/drivers/mouse.cpp
+++ b/src/input_common/drivers/mouse.cpp
@@ -121,12 +121,27 @@ void Mouse::StopPanning() {
 std::vector<Common::ParamPackage> Mouse::GetInputDevices() const {
     std::vector<Common::ParamPackage> devices;
     devices.emplace_back(Common::ParamPackage{
-        {"engine", "keyboard"},
+        {"engine", GetEngineName()},
         {"display", "Keyboard/Mouse"},
     });
     return devices;
 }
 
+AnalogMapping Mouse::GetAnalogMappingForDevice(
+    [[maybe_unused]] const Common::ParamPackage& params) {
+    // Only overwrite different buttons from default
+    AnalogMapping mapping = {};
+    Common::ParamPackage right_analog_params;
+    right_analog_params.Set("engine", GetEngineName());
+    right_analog_params.Set("axis_x", 0);
+    right_analog_params.Set("axis_y", 1);
+    right_analog_params.Set("threshold", 0.5f);
+    right_analog_params.Set("range", 1.0f);
+    right_analog_params.Set("deadzone", 0.0f);
+    mapping.insert_or_assign(Settings::NativeAnalog::RStick, std::move(right_analog_params));
+    return mapping;
+}
+
 std::string Mouse::GetUIName(const Common::ParamPackage& params) const {
     if (params.Has("button")) {
         return fmt::format("Mouse {}", params.Get("button", 0));
diff --git a/src/input_common/drivers/mouse.h b/src/input_common/drivers/mouse.h
index e8355751a4..d3178b1a9b 100644
--- a/src/input_common/drivers/mouse.h
+++ b/src/input_common/drivers/mouse.h
@@ -55,6 +55,7 @@ public:
     void ReleaseAllButtons();
 
     std::vector<Common::ParamPackage> GetInputDevices() const override;
+    AnalogMapping GetAnalogMappingForDevice(const Common::ParamPackage& params) override;
     std::string GetUIName(const Common::ParamPackage& params) const override;
 
 private:
diff --git a/src/input_common/input_engine.cpp b/src/input_common/input_engine.cpp
index 1534f24b04..9cfe0f2323 100644
--- a/src/input_common/input_engine.cpp
+++ b/src/input_common/input_engine.cpp
@@ -202,6 +202,8 @@ void InputEngine::TriggerOnButtonChange(const PadIdentifier& identifier, int but
     if (!configuring || !mapping_callback.on_data) {
         return;
     }
+
+    PreSetButton(identifier, button);
     if (value == GetButton(identifier, button)) {
         return;
     }
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index 8f7ce59b78..07d514ad73 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -143,6 +143,9 @@ struct InputSubsystem::Impl {
             return {};
         }
         const std::string engine = params.Get("engine", "");
+        if (engine == mouse->GetEngineName()) {
+            return mouse->GetAnalogMappingForDevice(params);
+        }
         if (engine == gcadapter->GetEngineName()) {
             return gcadapter->GetAnalogMappingForDevice(params);
         }
diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp
index cd33b57118..4160963333 100644
--- a/src/yuzu/configuration/configure_input_player.cpp
+++ b/src/yuzu/configuration/configure_input_player.cpp
@@ -478,37 +478,39 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
     UpdateControllerEnabledButtons();
     UpdateControllerButtonNames();
     UpdateMotionButtons();
-    connect(ui->comboControllerType, qOverload<int>(&QComboBox::currentIndexChanged), [this, player_index](int) {
-        UpdateControllerAvailableButtons();
-        UpdateControllerEnabledButtons();
-        UpdateControllerButtonNames();
-        UpdateMotionButtons();
-        const Core::HID::NpadType type = GetControllerTypeFromIndex(ui->comboControllerType->currentIndex());
-
-        if (player_index == 0) {
-            auto* emulated_controller_p1 =
-                system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
-            auto* emulated_controller_hanheld =
-                system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
-            bool is_connected = emulated_controller->IsConnected(true);
-
-            emulated_controller_p1->SetNpadType(type);
-            emulated_controller_hanheld->SetNpadType(type);
-            if (is_connected) {
-                if (type == Core::HID::NpadType::Handheld) {
-                    emulated_controller_p1->Disconnect();
-                    emulated_controller_hanheld->Connect();
-                    emulated_controller = emulated_controller_hanheld;
-                } else {
-                    emulated_controller_hanheld->Disconnect();
-                    emulated_controller_p1->Connect();
-                    emulated_controller = emulated_controller_p1;
+    connect(ui->comboControllerType, qOverload<int>(&QComboBox::currentIndexChanged),
+            [this, player_index](int) {
+                UpdateControllerAvailableButtons();
+                UpdateControllerEnabledButtons();
+                UpdateControllerButtonNames();
+                UpdateMotionButtons();
+                const Core::HID::NpadType type =
+                    GetControllerTypeFromIndex(ui->comboControllerType->currentIndex());
+
+                if (player_index == 0) {
+                    auto* emulated_controller_p1 =
+                        system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
+                    auto* emulated_controller_hanheld =
+                        system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
+                    bool is_connected = emulated_controller->IsConnected(true);
+
+                    emulated_controller_p1->SetNpadType(type);
+                    emulated_controller_hanheld->SetNpadType(type);
+                    if (is_connected) {
+                        if (type == Core::HID::NpadType::Handheld) {
+                            emulated_controller_p1->Disconnect();
+                            emulated_controller_hanheld->Connect();
+                            emulated_controller = emulated_controller_hanheld;
+                        } else {
+                            emulated_controller_hanheld->Disconnect();
+                            emulated_controller_p1->Connect();
+                            emulated_controller = emulated_controller_p1;
+                        }
+                    }
+                    ui->controllerFrame->SetController(emulated_controller);
                 }
-            }
-            ui->controllerFrame->SetController(emulated_controller);
-        }
-        emulated_controller->SetNpadType(type);
-    });
+                emulated_controller->SetNpadType(type);
+            });
 
     connect(ui->comboDevices, qOverload<int>(&QComboBox::activated), this,
             &ConfigureInputPlayer::UpdateMappingWithDefaults);
@@ -555,7 +557,7 @@ ConfigureInputPlayer::~ConfigureInputPlayer() {
     } else {
         emulated_controller->DisableConfiguration();
     }
-};
+}
 
 void ConfigureInputPlayer::ApplyConfiguration() {
     if (player_index == 0) {
@@ -642,7 +644,7 @@ void ConfigureInputPlayer::UpdateInputDeviceCombobox() {
 
     const auto first_engine = devices[0].Get("engine", "");
     const auto first_guid = devices[0].Get("guid", "");
-    const auto first_port = devices[0].Get("port", "");
+    const auto first_port = devices[0].Get("port", 0);
 
     if (devices.size() == 1) {
         const auto devices_it =
@@ -650,7 +652,7 @@ void ConfigureInputPlayer::UpdateInputDeviceCombobox() {
                          [first_engine, first_guid, first_port](const Common::ParamPackage param) {
                              return param.Get("engine", "") == first_engine &&
                                     param.Get("guid", "") == first_guid &&
-                                    param.Get("port", "") == first_port;
+                                    param.Get("port", 0) == first_port;
                          });
         const int device_index =
             devices_it != input_devices.end()
@@ -662,7 +664,7 @@ void ConfigureInputPlayer::UpdateInputDeviceCombobox() {
 
     const auto second_engine = devices[1].Get("engine", "");
     const auto second_guid = devices[1].Get("guid", "");
-    const auto second_port = devices[1].Get("port", "");
+    const auto second_port = devices[1].Get("port", 0);
 
     const bool is_keyboard_mouse = (first_engine == "keyboard" || first_engine == "mouse") &&
                                    (second_engine == "keyboard" || second_engine == "mouse");
@@ -684,7 +686,7 @@ void ConfigureInputPlayer::UpdateInputDeviceCombobox() {
                      param.Get("guid2", "") == second_guid) ||
                     (param.Get("guid", "") == second_guid && param.Get("guid2", "") == first_guid);
                 return param.Get("engine", "") == first_engine && is_guid_valid &&
-                       param.Get("port", "") == first_port;
+                       param.Get("port", 0) == first_port;
             });
         const int device_index =
             devices_it != input_devices.end()
@@ -1096,8 +1098,8 @@ void ConfigureInputPlayer::UpdateMappingWithDefaults() {
         emulated_controller->SetMotionParam(motion_id, {});
     }
 
-    // Reset keyboard bindings
-    if (ui->comboDevices->currentIndex() == 1) {
+    // Reset keyboard or mouse bindings
+    if (ui->comboDevices->currentIndex() == 1 || ui->comboDevices->currentIndex() == 2) {
         for (int button_id = 0; button_id < Settings::NativeButton::NumButtons; ++button_id) {
             emulated_controller->SetButtonParam(
                 button_id, Common::ParamPackage{InputCommon::GenerateKeyboardParam(
@@ -1122,63 +1124,30 @@ void ConfigureInputPlayer::UpdateMappingWithDefaults() {
                                Config::default_motions[motion_id])});
         }
 
-        UpdateUI();
-        return;
-    }
-
-    // Reset keyboard with mouse bindings
-    if (ui->comboDevices->currentIndex() == 2) {
-        for (int button_id = 0; button_id < Settings::NativeButton::NumButtons; ++button_id) {
-            emulated_controller->SetButtonParam(
-                button_id, Common::ParamPackage{InputCommon::GenerateKeyboardParam(
-                               Config::default_buttons[button_id])});
-        }
-
-        Common::ParamPackage left_analog_param{};
-        for (int sub_button_id = 0; sub_button_id < ANALOG_SUB_BUTTONS_NUM; ++sub_button_id) {
-            Common::ParamPackage params{InputCommon::GenerateKeyboardParam(
-                Config::default_analogs[Settings::NativeAnalog::LStick][sub_button_id])};
-            SetAnalogParam(params, left_analog_param, analog_sub_buttons[sub_button_id]);
-        }
-        left_analog_param.Set("modifier",
-                              InputCommon::GenerateKeyboardParam(
-                                  Config::default_stick_mod[Settings::NativeAnalog::LStick]));
-        emulated_controller->SetStickParam(Settings::NativeAnalog::LStick, left_analog_param);
-
-        Common::ParamPackage right_analog_param{};
-        right_analog_param.Set("engine", "mouse");
-        right_analog_param.Set("port", 0);
-        right_analog_param.Set("axis_x", 0);
-        right_analog_param.Set("axis_y", 1);
-        emulated_controller->SetStickParam(Settings::NativeAnalog::RStick,
-                                           std::move(right_analog_param));
-
-        for (int motion_id = 0; motion_id < Settings::NativeMotion::NumMotions; ++motion_id) {
-            emulated_controller->SetMotionParam(
-                motion_id, Common::ParamPackage{InputCommon::GenerateKeyboardParam(
-                               Config::default_motions[motion_id])});
+        // If mouse is selected we want to override with mappings from the driver
+        if (ui->comboDevices->currentIndex() == 1) {
+            UpdateUI();
+            return;
         }
-
-        UpdateUI();
-        return;
     }
 
     // Reset controller bindings
     const auto& device = input_devices[ui->comboDevices->currentIndex()];
-    auto button_mapping = input_subsystem->GetButtonMappingForDevice(device);
-    auto analog_mapping = input_subsystem->GetAnalogMappingForDevice(device);
-    auto motion_mapping = input_subsystem->GetMotionMappingForDevice(device);
-    for (std::size_t i = 0; i < button_mapping.size(); ++i) {
-        emulated_controller->SetButtonParam(
-            i, button_mapping[static_cast<Settings::NativeButton::Values>(i)]);
+    auto button_mappings = input_subsystem->GetButtonMappingForDevice(device);
+    auto analog_mappings = input_subsystem->GetAnalogMappingForDevice(device);
+    auto motion_mappings = input_subsystem->GetMotionMappingForDevice(device);
+
+    for (const auto& button_mapping : button_mappings) {
+        const std::size_t index = button_mapping.first;
+        emulated_controller->SetButtonParam(index, button_mapping.second);
     }
-    for (std::size_t i = 0; i < analog_mapping.size(); ++i) {
-        emulated_controller->SetStickParam(
-            i, analog_mapping[static_cast<Settings::NativeAnalog::Values>(i)]);
+    for (const auto& analog_mapping : analog_mappings) {
+        const std::size_t index = analog_mapping.first;
+        emulated_controller->SetStickParam(index, analog_mapping.second);
     }
-    for (std::size_t i = 0; i < motion_mapping.size(); ++i) {
-        emulated_controller->SetMotionParam(
-            i, motion_mapping[static_cast<Settings::NativeMotion::Values>(i)]);
+    for (const auto& motion_mapping : motion_mappings) {
+        const std::size_t index = motion_mapping.first;
+        emulated_controller->SetMotionParam(index, motion_mapping.second);
     }
 
     UpdateUI();
@@ -1237,7 +1206,7 @@ bool ConfigureInputPlayer::IsInputAcceptable(const Common::ParamPackage& params)
     }
 
     // Keyboard/Mouse
-    if (ui->comboDevices->currentIndex() == 2) {
+    if (ui->comboDevices->currentIndex() == 1 || ui->comboDevices->currentIndex() == 2) {
         return params.Get("engine", "") == "keyboard" || params.Get("engine", "") == "mouse";
     }
 
@@ -1245,7 +1214,7 @@ bool ConfigureInputPlayer::IsInputAcceptable(const Common::ParamPackage& params)
     return params.Get("engine", "") == current_input_device.Get("engine", "") &&
            (params.Get("guid", "") == current_input_device.Get("guid", "") ||
             params.Get("guid", "") == current_input_device.Get("guid2", "")) &&
-           params.Get("port", "") == current_input_device.Get("port", "");
+           params.Get("port", 0) == current_input_device.Get("port", 0);
 }
 
 void ConfigureInputPlayer::mousePressEvent(QMouseEvent* event) {
diff --git a/src/yuzu/configuration/configure_vibration.cpp b/src/yuzu/configuration/configure_vibration.cpp
index 46a0f30258..f1ce7205d5 100644
--- a/src/yuzu/configuration/configure_vibration.cpp
+++ b/src/yuzu/configuration/configure_vibration.cpp
@@ -97,7 +97,7 @@ void ConfigureVibration::SetVibrationDevices(std::size_t player_index) {
 
         const auto engine = param.Get("engine", "");
         const auto guid = param.Get("guid", "");
-        const auto port = param.Get("port", "");
+        const auto port = param.Get("port", 0);
 
         if (engine.empty() || engine == "keyboard" || engine == "mouse" || engine == "tas") {
             continue;
@@ -105,7 +105,7 @@ void ConfigureVibration::SetVibrationDevices(std::size_t player_index) {
 
         vibration_param_str += fmt::format("engine:{}", engine);
 
-        if (!port.empty()) {
+        if (port != 0) {
             vibration_param_str += fmt::format(",port:{}", port);
         }
         if (!guid.empty()) {
diff --git a/src/yuzu/debugger/controller.cpp b/src/yuzu/debugger/controller.cpp
index 3619aed260..f93a46421b 100644
--- a/src/yuzu/debugger/controller.cpp
+++ b/src/yuzu/debugger/controller.cpp
@@ -21,8 +21,7 @@ ControllerDialog::ControllerDialog(Core::System& system, QWidget* parent)
                    Qt::WindowMaximizeButtonHint);
 
     widget = new PlayerControlPreview(this);
-    widget->SetController(system.HIDCore().GetEmulatedController(
-        Core::HID::NpadIdType::Player1));
+    widget->SetController(system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1));
     QLayout* layout = new QVBoxLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
     layout->addWidget(widget);
-- 
cgit v1.2.3


From 9f91335a718fbbe6066e017dcf389f669b7cf6bf Mon Sep 17 00:00:00 2001
From: german77 <juangerman-13@hotmail.com>
Date: Sat, 30 Oct 2021 22:23:10 -0500
Subject: kraken: Address comments from review

start lion review
---
 src/common/input.h                                 |   4 +-
 src/common/settings.h                              |   1 -
 src/core/hid/emulated_console.cpp                  |  17 +-
 src/core/hid/emulated_console.h                    |  15 +-
 src/core/hid/emulated_controller.cpp               |  88 ++++-----
 src/core/hid/emulated_controller.h                 |  42 +++--
 src/core/hid/emulated_devices.cpp                  |  37 ++--
 src/core/hid/emulated_devices.h                    |  28 +--
 src/core/hid/input_converter.cpp                   |  75 ++++----
 src/core/hid/input_converter.h                     |  17 +-
 src/core/hle/service/hid/controllers/debug_pad.cpp |   3 -
 src/core/hle/service/hid/controllers/keyboard.cpp  |   1 -
 src/core/hle/service/hid/controllers/npad.h        |   3 +-
 src/core/hle/service/hid/ring_lifo.h               |   6 +-
 src/input_common/drivers/gc_adapter.cpp            |  10 +-
 src/input_common/drivers/gc_adapter.h              |   7 +-
 src/input_common/drivers/keyboard.h                |   2 +-
 src/input_common/drivers/mouse.h                   |   2 +-
 src/input_common/drivers/sdl_driver.cpp            |  16 +-
 src/input_common/drivers/sdl_driver.h              |   7 +-
 src/input_common/drivers/touch_screen.h            |   2 +-
 src/input_common/helpers/stick_from_buttons.cpp    |  70 +++----
 src/input_common/helpers/stick_from_buttons.h      |   4 +-
 src/input_common/helpers/touch_from_buttons.cpp    |  29 +--
 src/input_common/helpers/touch_from_buttons.h      |   4 +-
 src/input_common/input_engine.h                    |  14 +-
 src/input_common/input_poller.cpp                  | 202 +++++++++++----------
 src/input_common/input_poller.h                    |  32 ++--
 src/input_common/main.cpp                          |  76 ++++----
 .../configure_input_player_widget.cpp              | 105 ++++++-----
 .../configuration/configure_input_player_widget.h  |  81 +++++----
 31 files changed, 534 insertions(+), 466 deletions(-)

(limited to 'src/input_common/main.cpp')

diff --git a/src/common/input.h b/src/common/input.h
index cb84f1005a..6d3227f5e2 100644
--- a/src/common/input.h
+++ b/src/common/input.h
@@ -12,7 +12,7 @@
 #include "common/logging/log.h"
 #include "common/param_package.h"
 
-namespace Input {
+namespace Common::Input {
 
 enum class InputType {
     None,
@@ -296,4 +296,4 @@ std::unique_ptr<InputDeviceType> CreateDevice(const Common::ParamPackage package
     return pair->second->Create(package);
 }
 
-} // namespace Input
+} // namespace Common::Input
diff --git a/src/common/settings.h b/src/common/settings.h
index dac44d0006..95225fba7e 100644
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -6,7 +6,6 @@
 
 #include <algorithm>
 #include <array>
-#include <atomic>
 #include <map>
 #include <optional>
 #include <string>
diff --git a/src/core/hid/emulated_console.cpp b/src/core/hid/emulated_console.cpp
index d1d4a5355c..c259de0f17 100644
--- a/src/core/hid/emulated_console.cpp
+++ b/src/core/hid/emulated_console.cpp
@@ -55,21 +55,21 @@ void EmulatedConsole::SetTouchParams() {
 
 void EmulatedConsole::ReloadInput() {
     SetTouchParams();
-    motion_devices = Input::CreateDevice<Input::InputDevice>(motion_params);
+    motion_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(motion_params);
     if (motion_devices) {
-        Input::InputCallback motion_callback{
-            [this](Input::CallbackStatus callback) { SetMotion(callback); }};
+        Common::Input::InputCallback motion_callback{
+            [this](Common::Input::CallbackStatus callback) { SetMotion(callback); }};
         motion_devices->SetCallback(motion_callback);
     }
 
     std::size_t index = 0;
     for (auto& touch_device : touch_devices) {
-        touch_device = Input::CreateDevice<Input::InputDevice>(touch_params[index]);
+        touch_device = Common::Input::CreateDevice<Common::Input::InputDevice>(touch_params[index]);
         if (!touch_device) {
             continue;
         }
-        Input::InputCallback touch_callback{
-            [this, index](Input::CallbackStatus callback) { SetTouch(callback, index); }};
+        Common::Input::InputCallback touch_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetTouch(callback, index); }};
         touch_device->SetCallback(touch_callback);
         index++;
     }
@@ -117,7 +117,7 @@ void EmulatedConsole::SetMotionParam(Common::ParamPackage param) {
     ReloadInput();
 }
 
-void EmulatedConsole::SetMotion(Input::CallbackStatus callback) {
+void EmulatedConsole::SetMotion(Common::Input::CallbackStatus callback) {
     std::lock_guard lock{mutex};
     auto& raw_status = console.motion_values.raw_status;
     auto& emulated = console.motion_values.emulated;
@@ -152,7 +152,8 @@ void EmulatedConsole::SetMotion(Input::CallbackStatus callback) {
     TriggerOnChange(ConsoleTriggerType::Motion);
 }
 
-void EmulatedConsole::SetTouch(Input::CallbackStatus callback, [[maybe_unused]] std::size_t index) {
+void EmulatedConsole::SetTouch(Common::Input::CallbackStatus callback,
+                               [[maybe_unused]] std::size_t index) {
     if (index >= console.touch_values.size()) {
         return;
     }
diff --git a/src/core/hid/emulated_console.h b/src/core/hid/emulated_console.h
index f26f24f2ec..9aec482a6d 100644
--- a/src/core/hid/emulated_console.h
+++ b/src/core/hid/emulated_console.h
@@ -4,10 +4,13 @@
 
 #pragma once
 
+#include <array>
 #include <functional>
+#include <memory>
 #include <mutex>
 #include <unordered_map>
 
+#include "common/common_types.h"
 #include "common/input.h"
 #include "common/param_package.h"
 #include "common/point.h"
@@ -20,18 +23,18 @@
 namespace Core::HID {
 
 struct ConsoleMotionInfo {
-    Input::MotionStatus raw_status{};
+    Common::Input::MotionStatus raw_status{};
     MotionInput emulated{};
 };
 
-using ConsoleMotionDevices = std::unique_ptr<Input::InputDevice>;
-using TouchDevices = std::array<std::unique_ptr<Input::InputDevice>, 16>;
+using ConsoleMotionDevices = std::unique_ptr<Common::Input::InputDevice>;
+using TouchDevices = std::array<std::unique_ptr<Common::Input::InputDevice>, 16>;
 
 using ConsoleMotionParams = Common::ParamPackage;
 using TouchParams = std::array<Common::ParamPackage, 16>;
 
 using ConsoleMotionValues = ConsoleMotionInfo;
-using TouchValues = std::array<Input::TouchStatus, 16>;
+using TouchValues = std::array<Common::Input::TouchStatus, 16>;
 
 struct TouchFinger {
     u64 last_touch{};
@@ -151,14 +154,14 @@ private:
      * Updates the motion status of the console
      * @param A CallbackStatus containing gyro and accelerometer data
      */
-    void SetMotion(Input::CallbackStatus callback);
+    void SetMotion(Common::Input::CallbackStatus callback);
 
     /**
      * Updates the touch status of the console
      * @param callback: A CallbackStatus containing the touch position
      * @param index: Finger ID to be updated
      */
-    void SetTouch(Input::CallbackStatus callback, std::size_t index);
+    void SetTouch(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Triggers a callback that something has changed on the console status
diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index 69568f4e92..49893cdbda 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -110,25 +110,25 @@ void EmulatedController::LoadDevices() {
 
     std::transform(button_params.begin() + Settings::NativeButton::BUTTON_HID_BEGIN,
                    button_params.begin() + Settings::NativeButton::BUTTON_NS_END,
-                   button_devices.begin(), Input::CreateDevice<Input::InputDevice>);
+                   button_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
     std::transform(stick_params.begin() + Settings::NativeAnalog::STICK_HID_BEGIN,
                    stick_params.begin() + Settings::NativeAnalog::STICK_HID_END,
-                   stick_devices.begin(), Input::CreateDevice<Input::InputDevice>);
+                   stick_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
     std::transform(motion_params.begin() + Settings::NativeMotion::MOTION_HID_BEGIN,
                    motion_params.begin() + Settings::NativeMotion::MOTION_HID_END,
-                   motion_devices.begin(), Input::CreateDevice<Input::InputDevice>);
+                   motion_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>);
     std::transform(trigger_params.begin(), trigger_params.end(), trigger_devices.begin(),
-                   Input::CreateDevice<Input::InputDevice>);
+                   Common::Input::CreateDevice<Common::Input::InputDevice>);
     std::transform(battery_params.begin(), battery_params.begin(), battery_devices.end(),
-                   Input::CreateDevice<Input::InputDevice>);
+                   Common::Input::CreateDevice<Common::Input::InputDevice>);
     std::transform(output_params.begin(), output_params.end(), output_devices.begin(),
-                   Input::CreateDevice<Input::OutputDevice>);
+                   Common::Input::CreateDevice<Common::Input::OutputDevice>);
 
     // Initialize TAS devices
     std::transform(tas_button_params.begin(), tas_button_params.end(), tas_button_devices.begin(),
-                   Input::CreateDevice<Input::InputDevice>);
+                   Common::Input::CreateDevice<Common::Input::InputDevice>);
     std::transform(tas_stick_params.begin(), tas_stick_params.end(), tas_stick_devices.begin(),
-                   Input::CreateDevice<Input::InputDevice>);
+                   Common::Input::CreateDevice<Common::Input::InputDevice>);
 }
 
 void EmulatedController::LoadTASParams() {
@@ -178,8 +178,8 @@ void EmulatedController::ReloadInput() {
         if (!button_devices[index]) {
             continue;
         }
-        Input::InputCallback button_callback{
-            [this, index](Input::CallbackStatus callback) { SetButton(callback, index); }};
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetButton(callback, index); }};
         button_devices[index]->SetCallback(button_callback);
         button_devices[index]->ForceUpdate();
     }
@@ -188,8 +188,8 @@ void EmulatedController::ReloadInput() {
         if (!stick_devices[index]) {
             continue;
         }
-        Input::InputCallback stick_callback{
-            [this, index](Input::CallbackStatus callback) { SetStick(callback, index); }};
+        Common::Input::InputCallback stick_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetStick(callback, index); }};
         stick_devices[index]->SetCallback(stick_callback);
         stick_devices[index]->ForceUpdate();
     }
@@ -198,8 +198,8 @@ void EmulatedController::ReloadInput() {
         if (!trigger_devices[index]) {
             continue;
         }
-        Input::InputCallback trigger_callback{
-            [this, index](Input::CallbackStatus callback) { SetTrigger(callback, index); }};
+        Common::Input::InputCallback trigger_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetTrigger(callback, index); }};
         trigger_devices[index]->SetCallback(trigger_callback);
         trigger_devices[index]->ForceUpdate();
     }
@@ -208,8 +208,8 @@ void EmulatedController::ReloadInput() {
         if (!battery_devices[index]) {
             continue;
         }
-        Input::InputCallback battery_callback{
-            [this, index](Input::CallbackStatus callback) { SetBattery(callback, index); }};
+        Common::Input::InputCallback battery_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetBattery(callback, index); }};
         battery_devices[index]->SetCallback(battery_callback);
         battery_devices[index]->ForceUpdate();
     }
@@ -218,8 +218,8 @@ void EmulatedController::ReloadInput() {
         if (!motion_devices[index]) {
             continue;
         }
-        Input::InputCallback motion_callback{
-            [this, index](Input::CallbackStatus callback) { SetMotion(callback, index); }};
+        Common::Input::InputCallback motion_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetMotion(callback, index); }};
         motion_devices[index]->SetCallback(motion_callback);
         motion_devices[index]->ForceUpdate();
     }
@@ -229,8 +229,8 @@ void EmulatedController::ReloadInput() {
         if (!tas_button_devices[index]) {
             continue;
         }
-        Input::InputCallback button_callback{
-            [this, index](Input::CallbackStatus callback) { SetButton(callback, index); }};
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetButton(callback, index); }};
         tas_button_devices[index]->SetCallback(button_callback);
     }
 
@@ -238,8 +238,8 @@ void EmulatedController::ReloadInput() {
         if (!tas_stick_devices[index]) {
             continue;
         }
-        Input::InputCallback stick_callback{
-            [this, index](Input::CallbackStatus callback) { SetStick(callback, index); }};
+        Common::Input::InputCallback stick_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetStick(callback, index); }};
         tas_stick_devices[index]->SetCallback(stick_callback);
     }
 }
@@ -418,7 +418,7 @@ void EmulatedController::SetMotionParam(std::size_t index, Common::ParamPackage
     ReloadInput();
 }
 
-void EmulatedController::SetButton(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedController::SetButton(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= controller.button_values.size()) {
         return;
     }
@@ -548,7 +548,7 @@ void EmulatedController::SetButton(Input::CallbackStatus callback, std::size_t i
     TriggerOnChange(ControllerTriggerType::Button, true);
 }
 
-void EmulatedController::SetStick(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedController::SetStick(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= controller.stick_values.size()) {
         return;
     }
@@ -587,7 +587,7 @@ void EmulatedController::SetStick(Input::CallbackStatus callback, std::size_t in
     TriggerOnChange(ControllerTriggerType::Stick, true);
 }
 
-void EmulatedController::SetTrigger(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedController::SetTrigger(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= controller.trigger_values.size()) {
         return;
     }
@@ -618,7 +618,7 @@ void EmulatedController::SetTrigger(Input::CallbackStatus callback, std::size_t
     TriggerOnChange(ControllerTriggerType::Trigger, true);
 }
 
-void EmulatedController::SetMotion(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedController::SetMotion(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= controller.motion_values.size()) {
         return;
     }
@@ -655,7 +655,7 @@ void EmulatedController::SetMotion(Input::CallbackStatus callback, std::size_t i
     TriggerOnChange(ControllerTriggerType::Motion, true);
 }
 
-void EmulatedController::SetBattery(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedController::SetBattery(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= controller.battery_values.size()) {
         return;
     }
@@ -671,25 +671,25 @@ void EmulatedController::SetBattery(Input::CallbackStatus callback, std::size_t
     bool is_powered = false;
     BatteryLevel battery_level = 0;
     switch (controller.battery_values[index]) {
-    case Input::BatteryLevel::Charging:
+    case Common::Input::BatteryLevel::Charging:
         is_charging = true;
         is_powered = true;
         battery_level = 6;
         break;
-    case Input::BatteryLevel::Medium:
+    case Common::Input::BatteryLevel::Medium:
         battery_level = 6;
         break;
-    case Input::BatteryLevel::Low:
+    case Common::Input::BatteryLevel::Low:
         battery_level = 4;
         break;
-    case Input::BatteryLevel::Critical:
+    case Common::Input::BatteryLevel::Critical:
         battery_level = 2;
         break;
-    case Input::BatteryLevel::Empty:
+    case Common::Input::BatteryLevel::Empty:
         battery_level = 0;
         break;
-    case Input::BatteryLevel::None:
-    case Input::BatteryLevel::Full:
+    case Common::Input::BatteryLevel::None:
+    case Common::Input::BatteryLevel::Full:
     default:
         is_powered = true;
         battery_level = 8;
@@ -739,18 +739,19 @@ bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue v
 
     // Exponential amplification is too strong at low amplitudes. Switch to a linear
     // amplification if strength is set below 0.7f
-    const Input::VibrationAmplificationType type =
-        strength > 0.7f ? Input::VibrationAmplificationType::Exponential
-                        : Input::VibrationAmplificationType::Linear;
+    const Common::Input::VibrationAmplificationType type =
+        strength > 0.7f ? Common::Input::VibrationAmplificationType::Exponential
+                        : Common::Input::VibrationAmplificationType::Linear;
 
-    const Input::VibrationStatus status = {
+    const Common::Input::VibrationStatus status = {
         .low_amplitude = std::min(vibration.low_amplitude * strength, 1.0f),
         .low_frequency = vibration.low_frequency,
         .high_amplitude = std::min(vibration.high_amplitude * strength, 1.0f),
         .high_frequency = vibration.high_frequency,
         .type = type,
     };
-    return output_devices[device_index]->SetVibration(status) == Input::VibrationError::None;
+    return output_devices[device_index]->SetVibration(status) ==
+           Common::Input::VibrationError::None;
 }
 
 bool EmulatedController::TestVibration(std::size_t device_index) {
@@ -762,14 +763,15 @@ bool EmulatedController::TestVibration(std::size_t device_index) {
     }
 
     // Send a slight vibration to test for rumble support
-    constexpr Input::VibrationStatus status = {
+    constexpr Common::Input::VibrationStatus status = {
         .low_amplitude = 0.001f,
         .low_frequency = 160.0f,
         .high_amplitude = 0.001f,
         .high_frequency = 320.0f,
-        .type = Input::VibrationAmplificationType::Linear,
+        .type = Common::Input::VibrationAmplificationType::Linear,
     };
-    return output_devices[device_index]->SetVibration(status) == Input::VibrationError::None;
+    return output_devices[device_index]->SetVibration(status) ==
+           Common::Input::VibrationError::None;
 }
 
 void EmulatedController::SetLedPattern() {
@@ -779,7 +781,7 @@ void EmulatedController::SetLedPattern() {
         }
 
         const LedPattern pattern = GetLedPattern();
-        const Input::LedStatus status = {
+        const Common::Input::LedStatus status = {
             .led_1 = pattern.position1 != 0,
             .led_2 = pattern.position2 != 0,
             .led_3 = pattern.position3 != 0,
diff --git a/src/core/hid/emulated_controller.h b/src/core/hid/emulated_controller.h
index fea401365a..dd9a93364a 100644
--- a/src/core/hid/emulated_controller.h
+++ b/src/core/hid/emulated_controller.h
@@ -4,10 +4,13 @@
 
 #pragma once
 
+#include <array>
 #include <functional>
+#include <memory>
 #include <mutex>
 #include <unordered_map>
 
+#include "common/common_types.h"
 #include "common/input.h"
 #include "common/param_package.h"
 #include "common/point.h"
@@ -20,20 +23,22 @@
 namespace Core::HID {
 const std::size_t max_emulated_controllers = 2;
 struct ControllerMotionInfo {
-    Input::MotionStatus raw_status{};
+    Common::Input::MotionStatus raw_status{};
     MotionInput emulated{};
 };
 
 using ButtonDevices =
-    std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeButton::NumButtons>;
+    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeButton::NumButtons>;
 using StickDevices =
-    std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeAnalog::NumAnalogs>;
+    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeAnalog::NumAnalogs>;
 using ControllerMotionDevices =
-    std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeMotion::NumMotions>;
+    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeMotion::NumMotions>;
 using TriggerDevices =
-    std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeTrigger::NumTriggers>;
-using BatteryDevices = std::array<std::unique_ptr<Input::InputDevice>, max_emulated_controllers>;
-using OutputDevices = std::array<std::unique_ptr<Input::OutputDevice>, max_emulated_controllers>;
+    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeTrigger::NumTriggers>;
+using BatteryDevices =
+    std::array<std::unique_ptr<Common::Input::InputDevice>, max_emulated_controllers>;
+using OutputDevices =
+    std::array<std::unique_ptr<Common::Input::OutputDevice>, max_emulated_controllers>;
 
 using ButtonParams = std::array<Common::ParamPackage, Settings::NativeButton::NumButtons>;
 using StickParams = std::array<Common::ParamPackage, Settings::NativeAnalog::NumAnalogs>;
@@ -42,13 +47,14 @@ using TriggerParams = std::array<Common::ParamPackage, Settings::NativeTrigger::
 using BatteryParams = std::array<Common::ParamPackage, max_emulated_controllers>;
 using OutputParams = std::array<Common::ParamPackage, max_emulated_controllers>;
 
-using ButtonValues = std::array<Input::ButtonStatus, Settings::NativeButton::NumButtons>;
-using SticksValues = std::array<Input::StickStatus, Settings::NativeAnalog::NumAnalogs>;
-using TriggerValues = std::array<Input::TriggerStatus, Settings::NativeTrigger::NumTriggers>;
+using ButtonValues = std::array<Common::Input::ButtonStatus, Settings::NativeButton::NumButtons>;
+using SticksValues = std::array<Common::Input::StickStatus, Settings::NativeAnalog::NumAnalogs>;
+using TriggerValues =
+    std::array<Common::Input::TriggerStatus, Settings::NativeTrigger::NumTriggers>;
 using ControllerMotionValues = std::array<ControllerMotionInfo, Settings::NativeMotion::NumMotions>;
-using ColorValues = std::array<Input::BodyColorStatus, max_emulated_controllers>;
-using BatteryValues = std::array<Input::BatteryStatus, max_emulated_controllers>;
-using VibrationValues = std::array<Input::VibrationStatus, max_emulated_controllers>;
+using ColorValues = std::array<Common::Input::BodyColorStatus, max_emulated_controllers>;
+using BatteryValues = std::array<Common::Input::BatteryStatus, max_emulated_controllers>;
+using VibrationValues = std::array<Common::Input::VibrationStatus, max_emulated_controllers>;
 
 struct AnalogSticks {
     AnalogStickState left{};
@@ -307,35 +313,35 @@ private:
      * @param callback: A CallbackStatus containing the button status
      * @param index: Button ID of the to be updated
      */
-    void SetButton(Input::CallbackStatus callback, std::size_t index);
+    void SetButton(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the analog stick status of the controller
      * @param callback: A CallbackStatus containing the analog stick status
      * @param index: stick ID of the to be updated
      */
-    void SetStick(Input::CallbackStatus callback, std::size_t index);
+    void SetStick(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the trigger status of the controller
      * @param callback: A CallbackStatus containing the trigger status
      * @param index: trigger ID of the to be updated
      */
-    void SetTrigger(Input::CallbackStatus callback, std::size_t index);
+    void SetTrigger(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the motion status of the controller
      * @param callback: A CallbackStatus containing gyro and accelerometer data
      * @param index: motion ID of the to be updated
      */
-    void SetMotion(Input::CallbackStatus callback, std::size_t index);
+    void SetMotion(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the battery status of the controller
      * @param callback: A CallbackStatus containing the battery status
      * @param index: Button ID of the to be updated
      */
-    void SetBattery(Input::CallbackStatus callback, std::size_t index);
+    void SetBattery(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Triggers a callback that something has changed on the controller status
diff --git a/src/core/hid/emulated_devices.cpp b/src/core/hid/emulated_devices.cpp
index eb59c310c7..c76a86b6c4 100644
--- a/src/core/hid/emulated_devices.cpp
+++ b/src/core/hid/emulated_devices.cpp
@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included
 
+#include <algorithm>
 #include <fmt/format.h>
 
 #include "core/hid/emulated_devices.h"
@@ -25,21 +26,25 @@ void EmulatedDevices::ReloadFromSettings() {
 void EmulatedDevices::ReloadInput() {
     std::transform(mouse_button_params.begin() + Settings::NativeMouseButton::MOUSE_HID_BEGIN,
                    mouse_button_params.begin() + Settings::NativeMouseButton::MOUSE_HID_END,
-                   mouse_button_devices.begin(), Input::CreateDevice<Input::InputDevice>);
+                   mouse_button_devices.begin(),
+                   Common::Input::CreateDevice<Common::Input::InputDevice>);
 
     std::transform(Settings::values.keyboard_keys.begin(), Settings::values.keyboard_keys.end(),
-                   keyboard_devices.begin(), Input::CreateDeviceFromString<Input::InputDevice>);
+                   keyboard_devices.begin(),
+                   Common::Input::CreateDeviceFromString<Common::Input::InputDevice>);
 
     std::transform(Settings::values.keyboard_mods.begin(), Settings::values.keyboard_mods.end(),
                    keyboard_modifier_devices.begin(),
-                   Input::CreateDeviceFromString<Input::InputDevice>);
+                   Common::Input::CreateDeviceFromString<Common::Input::InputDevice>);
 
     for (std::size_t index = 0; index < mouse_button_devices.size(); ++index) {
         if (!mouse_button_devices[index]) {
             continue;
         }
-        Input::InputCallback button_callback{
-            [this, index](Input::CallbackStatus callback) { SetMouseButton(callback, index); }};
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) {
+                SetMouseButton(callback, index);
+            }};
         mouse_button_devices[index]->SetCallback(button_callback);
     }
 
@@ -47,8 +52,10 @@ void EmulatedDevices::ReloadInput() {
         if (!keyboard_devices[index]) {
             continue;
         }
-        Input::InputCallback button_callback{
-            [this, index](Input::CallbackStatus callback) { SetKeyboardButton(callback, index); }};
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) {
+                SetKeyboardButton(callback, index);
+            }};
         keyboard_devices[index]->SetCallback(button_callback);
     }
 
@@ -56,9 +63,10 @@ void EmulatedDevices::ReloadInput() {
         if (!keyboard_modifier_devices[index]) {
             continue;
         }
-        Input::InputCallback button_callback{[this, index](Input::CallbackStatus callback) {
-            SetKeyboardModifier(callback, index);
-        }};
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) {
+                SetKeyboardModifier(callback, index);
+            }};
         keyboard_modifier_devices[index]->SetCallback(button_callback);
     }
 }
@@ -122,7 +130,7 @@ void EmulatedDevices::SetMouseButtonParam(std::size_t index, Common::ParamPackag
     ReloadInput();
 }
 
-void EmulatedDevices::SetKeyboardButton(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedDevices::SetKeyboardButton(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= device_status.keyboard_values.size()) {
         return;
     }
@@ -170,7 +178,7 @@ void EmulatedDevices::SetKeyboardButton(Input::CallbackStatus callback, std::siz
 void EmulatedDevices::UpdateKey(std::size_t key_index, bool status) {
     constexpr u8 KEYS_PER_BYTE = 8;
     auto& entry = device_status.keyboard_state.key[key_index / KEYS_PER_BYTE];
-    const u8 mask = 1 << (key_index % KEYS_PER_BYTE);
+    const u8 mask = static_cast<u8>(1 << (key_index % KEYS_PER_BYTE));
     if (status) {
         entry = entry | mask;
     } else {
@@ -178,7 +186,8 @@ void EmulatedDevices::UpdateKey(std::size_t key_index, bool status) {
     }
 }
 
-void EmulatedDevices::SetKeyboardModifier(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedDevices::SetKeyboardModifier(Common::Input::CallbackStatus callback,
+                                          std::size_t index) {
     if (index >= device_status.keyboard_moddifier_values.size()) {
         return;
     }
@@ -247,7 +256,7 @@ void EmulatedDevices::SetKeyboardModifier(Input::CallbackStatus callback, std::s
     TriggerOnChange(DeviceTriggerType::KeyboardModdifier);
 }
 
-void EmulatedDevices::SetMouseButton(Input::CallbackStatus callback, std::size_t index) {
+void EmulatedDevices::SetMouseButton(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= device_status.mouse_button_values.size()) {
         return;
     }
diff --git a/src/core/hid/emulated_devices.h b/src/core/hid/emulated_devices.h
index 7ed95eac6b..418b2f9b55 100644
--- a/src/core/hid/emulated_devices.h
+++ b/src/core/hid/emulated_devices.h
@@ -4,10 +4,13 @@
 
 #pragma once
 
+#include <array>
 #include <functional>
+#include <memory>
 #include <mutex>
 #include <unordered_map>
 
+#include "common/common_types.h"
 #include "common/input.h"
 #include "common/param_package.h"
 #include "common/settings.h"
@@ -16,21 +19,22 @@
 
 namespace Core::HID {
 
-using KeyboardDevices =
-    std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeKeyboard::NumKeyboardKeys>;
-using KeyboardModifierDevices =
-    std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeKeyboard::NumKeyboardMods>;
-using MouseButtonDevices =
-    std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeMouseButton::NumMouseButtons>;
+using KeyboardDevices = std::array<std::unique_ptr<Common::Input::InputDevice>,
+                                   Settings::NativeKeyboard::NumKeyboardKeys>;
+using KeyboardModifierDevices = std::array<std::unique_ptr<Common::Input::InputDevice>,
+                                           Settings::NativeKeyboard::NumKeyboardMods>;
+using MouseButtonDevices = std::array<std::unique_ptr<Common::Input::InputDevice>,
+                                      Settings::NativeMouseButton::NumMouseButtons>;
 
 using MouseButtonParams =
     std::array<Common::ParamPackage, Settings::NativeMouseButton::NumMouseButtons>;
 
-using KeyboardValues = std::array<Input::ButtonStatus, Settings::NativeKeyboard::NumKeyboardKeys>;
+using KeyboardValues =
+    std::array<Common::Input::ButtonStatus, Settings::NativeKeyboard::NumKeyboardKeys>;
 using KeyboardModifierValues =
-    std::array<Input::ButtonStatus, Settings::NativeKeyboard::NumKeyboardMods>;
+    std::array<Common::Input::ButtonStatus, Settings::NativeKeyboard::NumKeyboardMods>;
 using MouseButtonValues =
-    std::array<Input::ButtonStatus, Settings::NativeMouseButton::NumMouseButtons>;
+    std::array<Common::Input::ButtonStatus, Settings::NativeMouseButton::NumMouseButtons>;
 
 struct MousePosition {
     s32 x;
@@ -151,21 +155,21 @@ private:
      * @param callback: A CallbackStatus containing the key status
      * @param index: key ID to be updated
      */
-    void SetKeyboardButton(Input::CallbackStatus callback, std::size_t index);
+    void SetKeyboardButton(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the touch status of the console
      * @param callback: A CallbackStatus containing the modifier key status
      * @param index: modifier key ID to be updated
      */
-    void SetKeyboardModifier(Input::CallbackStatus callback, std::size_t index);
+    void SetKeyboardModifier(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the touch status of the console
      * @param callback: A CallbackStatus containing the button status
      * @param index: Button ID of the to be updated
      */
-    void SetMouseButton(Input::CallbackStatus callback, std::size_t index);
+    void SetMouseButton(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Triggers a callback that something has changed on the device status
diff --git a/src/core/hid/input_converter.cpp b/src/core/hid/input_converter.cpp
index e2598f367c..14204917e1 100644
--- a/src/core/hid/input_converter.cpp
+++ b/src/core/hid/input_converter.cpp
@@ -9,35 +9,35 @@
 
 namespace Core::HID {
 
-Input::BatteryStatus TransformToBattery(const Input::CallbackStatus& callback) {
-    Input::BatteryStatus battery{Input::BatteryStatus::None};
+Common::Input::BatteryStatus TransformToBattery(const Common::Input::CallbackStatus& callback) {
+    Common::Input::BatteryStatus battery{Common::Input::BatteryStatus::None};
     switch (callback.type) {
-    case Input::InputType::Analog:
-    case Input::InputType::Trigger: {
+    case Common::Input::InputType::Analog:
+    case Common::Input::InputType::Trigger: {
         const auto value = TransformToTrigger(callback).analog.value;
-        battery = Input::BatteryLevel::Empty;
+        battery = Common::Input::BatteryLevel::Empty;
         if (value > 0.2f) {
-            battery = Input::BatteryLevel::Critical;
+            battery = Common::Input::BatteryLevel::Critical;
         }
         if (value > 0.4f) {
-            battery = Input::BatteryLevel::Low;
+            battery = Common::Input::BatteryLevel::Low;
         }
         if (value > 0.6f) {
-            battery = Input::BatteryLevel::Medium;
+            battery = Common::Input::BatteryLevel::Medium;
         }
         if (value > 0.8f) {
-            battery = Input::BatteryLevel::Full;
+            battery = Common::Input::BatteryLevel::Full;
         }
         if (value >= 1.0f) {
-            battery = Input::BatteryLevel::Charging;
+            battery = Common::Input::BatteryLevel::Charging;
         }
         break;
     }
-    case Input::InputType::Button:
-        battery = callback.button_status.value ? Input::BatteryLevel::Charging
-                                               : Input::BatteryLevel::Critical;
+    case Common::Input::InputType::Button:
+        battery = callback.button_status.value ? Common::Input::BatteryLevel::Charging
+                                               : Common::Input::BatteryLevel::Critical;
         break;
-    case Input::InputType::Battery:
+    case Common::Input::InputType::Battery:
         battery = callback.battery_status;
         break;
     default:
@@ -48,14 +48,14 @@ Input::BatteryStatus TransformToBattery(const Input::CallbackStatus& callback) {
     return battery;
 }
 
-Input::ButtonStatus TransformToButton(const Input::CallbackStatus& callback) {
-    Input::ButtonStatus status{};
+Common::Input::ButtonStatus TransformToButton(const Common::Input::CallbackStatus& callback) {
+    Common::Input::ButtonStatus status{};
     switch (callback.type) {
-    case Input::InputType::Analog:
-    case Input::InputType::Trigger:
+    case Common::Input::InputType::Analog:
+    case Common::Input::InputType::Trigger:
         status.value = TransformToTrigger(callback).pressed;
         break;
-    case Input::InputType::Button:
+    case Common::Input::InputType::Button:
         status = callback.button_status;
         break;
     default:
@@ -70,15 +70,15 @@ Input::ButtonStatus TransformToButton(const Input::CallbackStatus& callback) {
     return status;
 }
 
-Input::MotionStatus TransformToMotion(const Input::CallbackStatus& callback) {
-    Input::MotionStatus status{};
+Common::Input::MotionStatus TransformToMotion(const Common::Input::CallbackStatus& callback) {
+    Common::Input::MotionStatus status{};
     switch (callback.type) {
-    case Input::InputType::Button: {
+    case Common::Input::InputType::Button: {
         if (TransformToButton(callback).value) {
             std::random_device device;
             std::mt19937 gen(device());
             std::uniform_int_distribution<s16> distribution(-1000, 1000);
-            Input::AnalogProperties properties{
+            Common::Input::AnalogProperties properties{
                 .deadzone = 0.0,
                 .range = 1.0f,
                 .offset = 0.0,
@@ -116,7 +116,7 @@ Input::MotionStatus TransformToMotion(const Input::CallbackStatus& callback) {
         }
         break;
     }
-    case Input::InputType::Motion:
+    case Common::Input::InputType::Motion:
         status = callback.motion_status;
         break;
     default:
@@ -133,11 +133,11 @@ Input::MotionStatus TransformToMotion(const Input::CallbackStatus& callback) {
     return status;
 }
 
-Input::StickStatus TransformToStick(const Input::CallbackStatus& callback) {
-    Input::StickStatus status{};
+Common::Input::StickStatus TransformToStick(const Common::Input::CallbackStatus& callback) {
+    Common::Input::StickStatus status{};
 
     switch (callback.type) {
-    case Input::InputType::Stick:
+    case Common::Input::InputType::Stick:
         status = callback.stick_status;
         break;
     default:
@@ -160,11 +160,11 @@ Input::StickStatus TransformToStick(const Input::CallbackStatus& callback) {
     return status;
 }
 
-Input::TouchStatus TransformToTouch(const Input::CallbackStatus& callback) {
-    Input::TouchStatus status{};
+Common::Input::TouchStatus TransformToTouch(const Common::Input::CallbackStatus& callback) {
+    Common::Input::TouchStatus status{};
 
     switch (callback.type) {
-    case Input::InputType::Touch:
+    case Common::Input::InputType::Touch:
         status = callback.touch_status;
         break;
     default:
@@ -192,22 +192,22 @@ Input::TouchStatus TransformToTouch(const Input::CallbackStatus& callback) {
     return status;
 }
 
-Input::TriggerStatus TransformToTrigger(const Input::CallbackStatus& callback) {
-    Input::TriggerStatus status{};
+Common::Input::TriggerStatus TransformToTrigger(const Common::Input::CallbackStatus& callback) {
+    Common::Input::TriggerStatus status{};
     float& raw_value = status.analog.raw_value;
     bool calculate_button_value = true;
 
     switch (callback.type) {
-    case Input::InputType::Analog:
+    case Common::Input::InputType::Analog:
         status.analog.properties = callback.analog_status.properties;
         raw_value = callback.analog_status.raw_value;
         break;
-    case Input::InputType::Button:
+    case Common::Input::InputType::Button:
         status.analog.properties.range = 1.0f;
         status.analog.properties.inverted = callback.button_status.inverted;
         raw_value = callback.button_status.value ? 1.0f : 0.0f;
         break;
-    case Input::InputType::Trigger:
+    case Common::Input::InputType::Trigger:
         status = callback.trigger_status;
         calculate_button_value = false;
         break;
@@ -234,7 +234,7 @@ Input::TriggerStatus TransformToTrigger(const Input::CallbackStatus& callback) {
     return status;
 }
 
-void SanitizeAnalog(Input::AnalogStatus& analog, bool clamp_value) {
+void SanitizeAnalog(Common::Input::AnalogStatus& analog, bool clamp_value) {
     const auto& properties = analog.properties;
     float& raw_value = analog.raw_value;
     float& value = analog.value;
@@ -274,7 +274,8 @@ void SanitizeAnalog(Input::AnalogStatus& analog, bool clamp_value) {
     }
 }
 
-void SanitizeStick(Input::AnalogStatus& analog_x, Input::AnalogStatus& analog_y, bool clamp_value) {
+void SanitizeStick(Common::Input::AnalogStatus& analog_x, Common::Input::AnalogStatus& analog_y,
+                   bool clamp_value) {
     const auto& properties_x = analog_x.properties;
     const auto& properties_y = analog_y.properties;
     float& raw_x = analog_x.raw_value;
diff --git a/src/core/hid/input_converter.h b/src/core/hid/input_converter.h
index 3cc32e26a9..b38e657b08 100644
--- a/src/core/hid/input_converter.h
+++ b/src/core/hid/input_converter.h
@@ -16,7 +16,7 @@ namespace Core::HID {
  * @param Supported callbacks: Analog, Battery, Trigger.
  * @return A valid BatteryStatus object.
  */
-Input::BatteryStatus TransformToBattery(const Input::CallbackStatus& callback);
+Common::Input::BatteryStatus TransformToBattery(const Common::Input::CallbackStatus& callback);
 
 /**
  * Converts raw input data into a valid button status. Applies invert properties to the output.
@@ -24,7 +24,7 @@ Input::BatteryStatus TransformToBattery(const Input::CallbackStatus& callback);
  * @param Supported callbacks: Analog, Button, Trigger.
  * @return A valid TouchStatus object.
  */
-Input::ButtonStatus TransformToButton(const Input::CallbackStatus& callback);
+Common::Input::ButtonStatus TransformToButton(const Common::Input::CallbackStatus& callback);
 
 /**
  * Converts raw input data into a valid motion status.
@@ -32,7 +32,7 @@ Input::ButtonStatus TransformToButton(const Input::CallbackStatus& callback);
  * @param Supported callbacks: Motion.
  * @return A valid TouchStatus object.
  */
-Input::MotionStatus TransformToMotion(const Input::CallbackStatus& callback);
+Common::Input::MotionStatus TransformToMotion(const Common::Input::CallbackStatus& callback);
 
 /**
  * Converts raw input data into a valid stick status. Applies offset, deadzone, range and invert
@@ -41,7 +41,7 @@ Input::MotionStatus TransformToMotion(const Input::CallbackStatus& callback);
  * @param Supported callbacks: Stick.
  * @return A valid StickStatus object.
  */
-Input::StickStatus TransformToStick(const Input::CallbackStatus& callback);
+Common::Input::StickStatus TransformToStick(const Common::Input::CallbackStatus& callback);
 
 /**
  * Converts raw input data into a valid touch status.
@@ -49,7 +49,7 @@ Input::StickStatus TransformToStick(const Input::CallbackStatus& callback);
  * @param Supported callbacks: Touch.
  * @return A valid TouchStatus object.
  */
-Input::TouchStatus TransformToTouch(const Input::CallbackStatus& callback);
+Common::Input::TouchStatus TransformToTouch(const Common::Input::CallbackStatus& callback);
 
 /**
  * Converts raw input data into a valid trigger status. Applies offset, deadzone, range and
@@ -58,20 +58,21 @@ Input::TouchStatus TransformToTouch(const Input::CallbackStatus& callback);
  * @param Supported callbacks: Analog, Button, Trigger.
  * @return A valid TriggerStatus object.
  */
-Input::TriggerStatus TransformToTrigger(const Input::CallbackStatus& callback);
+Common::Input::TriggerStatus TransformToTrigger(const Common::Input::CallbackStatus& callback);
 
 /**
  * Converts raw analog data into a valid analog value
  * @param An analog object containing raw data and properties, bool that determines if the value
  * needs to be clamped between -1.0f and 1.0f.
  */
-void SanitizeAnalog(Input::AnalogStatus& analog, bool clamp_value);
+void SanitizeAnalog(Common::Input::AnalogStatus& analog, bool clamp_value);
 
 /**
  * Converts raw stick data into a valid stick value
  * @param Two analog objects containing raw data and properties, bool that determines if the value
  * needs to be clamped into the unit circle.
  */
-void SanitizeStick(Input::AnalogStatus& analog_x, Input::AnalogStatus& analog_y, bool clamp_value);
+void SanitizeStick(Common::Input::AnalogStatus& analog_x, Common::Input::AnalogStatus& analog_y,
+                   bool clamp_value);
 
 } // namespace Core::HID
diff --git a/src/core/hle/service/hid/controllers/debug_pad.cpp b/src/core/hle/service/hid/controllers/debug_pad.cpp
index 345134357d..b009ed086e 100644
--- a/src/core/hle/service/hid/controllers/debug_pad.cpp
+++ b/src/core/hle/service/hid/controllers/debug_pad.cpp
@@ -13,9 +13,6 @@
 
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x00000;
-constexpr s32 HID_JOYSTICK_MAX = 0x7fff;
-[[maybe_unused]] constexpr s32 HID_JOYSTICK_MIN = -0x7fff;
-enum class JoystickId : std::size_t { Joystick_Left, Joystick_Right };
 
 Controller_DebugPad::Controller_DebugPad(Core::System& system_) : ControllerBase{system_} {
     controller = system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Other);
diff --git a/src/core/hle/service/hid/controllers/keyboard.cpp b/src/core/hle/service/hid/controllers/keyboard.cpp
index f4d49965ff..60dc62f2c8 100644
--- a/src/core/hle/service/hid/controllers/keyboard.cpp
+++ b/src/core/hle/service/hid/controllers/keyboard.cpp
@@ -12,7 +12,6 @@
 
 namespace Service::HID {
 constexpr std::size_t SHARED_MEMORY_OFFSET = 0x3800;
-constexpr u8 KEYS_PER_BYTE = 8;
 
 Controller_Keyboard::Controller_Keyboard(Core::System& system_) : ControllerBase{system_} {
     emulated_devices = system.HIDCore().GetEmulatedDevices();
diff --git a/src/core/hle/service/hid/controllers/npad.h b/src/core/hle/service/hid/controllers/npad.h
index af4934c558..4a9c9cc1ab 100644
--- a/src/core/hle/service/hid/controllers/npad.h
+++ b/src/core/hle/service/hid/controllers/npad.h
@@ -403,8 +403,7 @@ private:
         AppletFooterUiType type;
         INSERT_PADDING_BYTES(0x5B); // Reserved
     };
-    static_assert(sizeof(AppletFooterUi) == 0x60,
-                  "AppletFooterUi is an invalid size");
+    static_assert(sizeof(AppletFooterUi) == 0x60, "AppletFooterUi is an invalid size");
 
     // This is nn::hid::NpadLarkType
     enum class NpadLarkType : u32 {
diff --git a/src/core/hle/service/hid/ring_lifo.h b/src/core/hle/service/hid/ring_lifo.h
index 382350a2d2..6209ed0d15 100644
--- a/src/core/hle/service/hid/ring_lifo.h
+++ b/src/core/hle/service/hid/ring_lifo.h
@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include <array>
+
 #include "common/common_types.h"
 #include "common/swap.h"
 
@@ -29,10 +31,10 @@ struct Lifo {
     }
 
     const AtomicStorage<State>& ReadPreviousEntry() const {
-        return entries[GetPreviuousEntryIndex()];
+        return entries[GetPreviousEntryIndex()];
     }
 
-    std::size_t GetPreviuousEntryIndex() const {
+    std::size_t GetPreviousEntryIndex() const {
         return (buffer_tail + total_buffer_count - 1) % total_buffer_count;
     }
 
diff --git a/src/input_common/drivers/gc_adapter.cpp b/src/input_common/drivers/gc_adapter.cpp
index 62dc287119..2550f8cba5 100644
--- a/src/input_common/drivers/gc_adapter.cpp
+++ b/src/input_common/drivers/gc_adapter.cpp
@@ -248,7 +248,7 @@ bool GCAdapter::Setup() {
         std::size_t port = 0;
         for (GCController& pad : pads) {
             pad.identifier = {
-                .guid = Common::UUID{""},
+                .guid = Common::UUID{Common::INVALID_UUID},
                 .port = port++,
                 .pad = 0,
             };
@@ -325,8 +325,8 @@ bool GCAdapter::GetGCEndpoint(libusb_device* device) {
     return true;
 }
 
-Input::VibrationError GCAdapter::SetRumble(const PadIdentifier& identifier,
-                                           const Input::VibrationStatus vibration) {
+Common::Input::VibrationError GCAdapter::SetRumble(const PadIdentifier& identifier,
+                                                   const Common::Input::VibrationStatus vibration) {
     const auto mean_amplitude = (vibration.low_amplitude + vibration.high_amplitude) * 0.5f;
     const auto processed_amplitude =
         static_cast<u8>((mean_amplitude + std::pow(mean_amplitude, 0.3f)) * 0.5f * 0x8);
@@ -334,9 +334,9 @@ Input::VibrationError GCAdapter::SetRumble(const PadIdentifier& identifier,
     pads[identifier.port].rumble_amplitude = processed_amplitude;
 
     if (!rumble_enabled) {
-        return Input::VibrationError::Disabled;
+        return Common::Input::VibrationError::Disabled;
     }
-    return Input::VibrationError::None;
+    return Common::Input::VibrationError::None;
 }
 
 void GCAdapter::UpdateVibrations() {
diff --git a/src/input_common/drivers/gc_adapter.h b/src/input_common/drivers/gc_adapter.h
index b82e4803dd..fba90352e9 100644
--- a/src/input_common/drivers/gc_adapter.h
+++ b/src/input_common/drivers/gc_adapter.h
@@ -4,8 +4,11 @@
 
 #pragma once
 
+#include <array>
+#include <memory>
 #include <mutex>
 #include <stop_token>
+#include <string>
 #include <thread>
 
 #include "input_common/input_engine.h"
@@ -24,8 +27,8 @@ public:
     explicit GCAdapter(const std::string input_engine_);
     ~GCAdapter();
 
-    Input::VibrationError SetRumble(const PadIdentifier& identifier,
-                                    const Input::VibrationStatus vibration) override;
+    Common::Input::VibrationError SetRumble(
+        const PadIdentifier& identifier, const Common::Input::VibrationStatus vibration) override;
 
     /// Used for automapping features
     std::vector<Common::ParamPackage> GetInputDevices() const override;
diff --git a/src/input_common/drivers/keyboard.h b/src/input_common/drivers/keyboard.h
index a3e0d8a617..58df150507 100644
--- a/src/input_common/drivers/keyboard.h
+++ b/src/input_common/drivers/keyboard.h
@@ -35,7 +35,7 @@ public:
 
 private:
     const PadIdentifier identifier = {
-        .guid = Common::UUID{""},
+        .guid = Common::UUID{Common::INVALID_UUID},
         .port = 0,
         .pad = 0,
     };
diff --git a/src/input_common/drivers/mouse.h b/src/input_common/drivers/mouse.h
index d3178b1a9b..cf09184098 100644
--- a/src/input_common/drivers/mouse.h
+++ b/src/input_common/drivers/mouse.h
@@ -63,7 +63,7 @@ private:
     void StopPanning();
 
     const PadIdentifier identifier = {
-        .guid = Common::UUID{""},
+        .guid = Common::UUID{Common::INVALID_UUID},
         .port = 0,
         .pad = 0,
     };
diff --git a/src/input_common/drivers/sdl_driver.cpp b/src/input_common/drivers/sdl_driver.cpp
index 53e282ef3c..1e3741e0f8 100644
--- a/src/input_common/drivers/sdl_driver.cpp
+++ b/src/input_common/drivers/sdl_driver.cpp
@@ -92,7 +92,7 @@ public:
         return motion;
     }
 
-    bool RumblePlay(const Input::VibrationStatus vibration) {
+    bool RumblePlay(const Common::Input::VibrationStatus vibration) {
         constexpr u32 rumble_max_duration_ms = 1000;
         if (sdl_controller) {
             return SDL_GameControllerRumble(
@@ -515,8 +515,8 @@ std::vector<Common::ParamPackage> SDLDriver::GetInputDevices() const {
     }
     return devices;
 }
-Input::VibrationError SDLDriver::SetRumble(const PadIdentifier& identifier,
-                                           const Input::VibrationStatus vibration) {
+Common::Input::VibrationError SDLDriver::SetRumble(const PadIdentifier& identifier,
+                                                   const Common::Input::VibrationStatus vibration) {
     const auto joystick =
         GetSDLJoystickByGUID(identifier.guid.Format(), static_cast<int>(identifier.port));
     const auto process_amplitude_exp = [](f32 amplitude, f32 factor) {
@@ -527,7 +527,7 @@ Input::VibrationError SDLDriver::SetRumble(const PadIdentifier& identifier,
     f32 factor = 0.35f;
 
     // If vibration is set as a linear output use a flatter value
-    if (vibration.type == Input::VibrationAmplificationType::Linear) {
+    if (vibration.type == Common::Input::VibrationAmplificationType::Linear) {
         factor = 0.5f;
     }
 
@@ -536,19 +536,19 @@ Input::VibrationError SDLDriver::SetRumble(const PadIdentifier& identifier,
         factor = 1.0f;
     }
 
-    const Input::VibrationStatus new_vibration{
+    const Common::Input::VibrationStatus new_vibration{
         .low_amplitude = process_amplitude_exp(vibration.low_amplitude, factor),
         .low_frequency = vibration.low_frequency,
         .high_amplitude = process_amplitude_exp(vibration.high_amplitude, factor),
         .high_frequency = vibration.high_frequency,
-        .type = Input::VibrationAmplificationType::Exponential,
+        .type = Common::Input::VibrationAmplificationType::Exponential,
     };
 
     if (!joystick->RumblePlay(new_vibration)) {
-        return Input::VibrationError::Unknown;
+        return Common::Input::VibrationError::Unknown;
     }
 
-    return Input::VibrationError::None;
+    return Common::Input::VibrationError::None;
 }
 Common::ParamPackage SDLDriver::BuildAnalogParamPackageForButton(int port, std::string guid,
                                                                  s32 axis, float value) const {
diff --git a/src/input_common/drivers/sdl_driver.h b/src/input_common/drivers/sdl_driver.h
index 1ff85f48de..b879df8abf 100644
--- a/src/input_common/drivers/sdl_driver.h
+++ b/src/input_common/drivers/sdl_driver.h
@@ -58,8 +58,8 @@ public:
     std::string GetHatButtonName(u8 direction_value) const override;
     u8 GetHatButtonId(const std::string direction_name) const override;
 
-    Input::VibrationError SetRumble(const PadIdentifier& identifier,
-                                    const Input::VibrationStatus vibration) override;
+    Common::Input::VibrationError SetRumble(
+        const PadIdentifier& identifier, const Common::Input::VibrationStatus vibration) override;
 
 private:
     void InitJoystick(int joystick_index);
@@ -105,9 +105,6 @@ private:
     /// Returns true if the button is on the left joycon
     bool IsButtonOnLeftSide(Settings::NativeButton::Values button) const;
 
-    // Set to true if SDL supports game controller subsystem
-    bool has_gamecontroller = false;
-
     /// Map of GUID of a list of corresponding virtual Joysticks
     std::unordered_map<std::string, std::vector<std::shared_ptr<SDLJoystick>>> joystick_map;
     std::mutex joystick_map_mutex;
diff --git a/src/input_common/drivers/touch_screen.h b/src/input_common/drivers/touch_screen.h
index 5fbb2f47ff..d297d253ce 100644
--- a/src/input_common/drivers/touch_screen.h
+++ b/src/input_common/drivers/touch_screen.h
@@ -41,7 +41,7 @@ public:
 
 private:
     const PadIdentifier identifier = {
-        .guid = Common::UUID{""},
+        .guid = Common::UUID{Common::INVALID_UUID},
         .port = 0,
         .pad = 0,
     };
diff --git a/src/input_common/helpers/stick_from_buttons.cpp b/src/input_common/helpers/stick_from_buttons.cpp
index 806a0e8bba..1d5948f793 100644
--- a/src/input_common/helpers/stick_from_buttons.cpp
+++ b/src/input_common/helpers/stick_from_buttons.cpp
@@ -10,25 +10,27 @@
 
 namespace InputCommon {
 
-class Stick final : public Input::InputDevice {
+class Stick final : public Common::Input::InputDevice {
 public:
-    using Button = std::unique_ptr<Input::InputDevice>;
+    using Button = std::unique_ptr<Common::Input::InputDevice>;
 
     Stick(Button up_, Button down_, Button left_, Button right_, Button modifier_,
           float modifier_scale_, float modifier_angle_)
         : up(std::move(up_)), down(std::move(down_)), left(std::move(left_)),
           right(std::move(right_)), modifier(std::move(modifier_)), modifier_scale(modifier_scale_),
           modifier_angle(modifier_angle_) {
-        Input::InputCallback button_up_callback{
-            [this](Input::CallbackStatus callback_) { UpdateUpButtonStatus(callback_); }};
-        Input::InputCallback button_down_callback{
-            [this](Input::CallbackStatus callback_) { UpdateDownButtonStatus(callback_); }};
-        Input::InputCallback button_left_callback{
-            [this](Input::CallbackStatus callback_) { UpdateLeftButtonStatus(callback_); }};
-        Input::InputCallback button_right_callback{
-            [this](Input::CallbackStatus callback_) { UpdateRightButtonStatus(callback_); }};
-        Input::InputCallback button_modifier_callback{
-            [this](Input::CallbackStatus callback_) { UpdateModButtonStatus(callback_); }};
+        Common::Input::InputCallback button_up_callback{
+            [this](Common::Input::CallbackStatus callback_) { UpdateUpButtonStatus(callback_); }};
+        Common::Input::InputCallback button_down_callback{
+            [this](Common::Input::CallbackStatus callback_) { UpdateDownButtonStatus(callback_); }};
+        Common::Input::InputCallback button_left_callback{
+            [this](Common::Input::CallbackStatus callback_) { UpdateLeftButtonStatus(callback_); }};
+        Common::Input::InputCallback button_right_callback{
+            [this](Common::Input::CallbackStatus callback_) {
+                UpdateRightButtonStatus(callback_);
+            }};
+        Common::Input::InputCallback button_modifier_callback{
+            [this](Common::Input::CallbackStatus callback_) { UpdateModButtonStatus(callback_); }};
         up->SetCallback(button_up_callback);
         down->SetCallback(button_down_callback);
         left->SetCallback(button_left_callback);
@@ -129,27 +131,27 @@ public:
         }
     }
 
-    void UpdateUpButtonStatus(Input::CallbackStatus button_callback) {
+    void UpdateUpButtonStatus(Common::Input::CallbackStatus button_callback) {
         up_status = button_callback.button_status.value;
         UpdateStatus();
     }
 
-    void UpdateDownButtonStatus(Input::CallbackStatus button_callback) {
+    void UpdateDownButtonStatus(Common::Input::CallbackStatus button_callback) {
         down_status = button_callback.button_status.value;
         UpdateStatus();
     }
 
-    void UpdateLeftButtonStatus(Input::CallbackStatus button_callback) {
+    void UpdateLeftButtonStatus(Common::Input::CallbackStatus button_callback) {
         left_status = button_callback.button_status.value;
         UpdateStatus();
     }
 
-    void UpdateRightButtonStatus(Input::CallbackStatus button_callback) {
+    void UpdateRightButtonStatus(Common::Input::CallbackStatus button_callback) {
         right_status = button_callback.button_status.value;
         UpdateStatus();
     }
 
-    void UpdateModButtonStatus(Input::CallbackStatus button_callback) {
+    void UpdateModButtonStatus(Common::Input::CallbackStatus button_callback) {
         modifier_status = button_callback.button_status.value;
         UpdateStatus();
     }
@@ -193,8 +195,8 @@ public:
         }
 
         last_update = now;
-        Input::CallbackStatus status{
-            .type = Input::InputType::Stick,
+        Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Stick,
             .stick_status = GetStatus(),
         };
         TriggerOnChange(status);
@@ -209,15 +211,15 @@ public:
     }
 
     void SoftUpdate() override {
-        Input::CallbackStatus status{
-            .type = Input::InputType::Stick,
+        Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Stick,
             .stick_status = GetStatus(),
         };
         TriggerOnChange(status);
     }
 
-    Input::StickStatus GetStatus() const {
-        Input::StickStatus status{};
+    Common::Input::StickStatus GetStatus() const {
+        Common::Input::StickStatus status{};
         status.x.properties = properties;
         status.y.properties = properties;
         if (Settings::values.emulate_analog_keyboard) {
@@ -263,19 +265,23 @@ private:
     bool left_status;
     bool right_status;
     bool modifier_status;
-    const Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
+    const Common::Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
     std::chrono::time_point<std::chrono::steady_clock> last_update;
 };
 
-std::unique_ptr<Input::InputDevice> StickFromButton::Create(const Common::ParamPackage& params) {
+std::unique_ptr<Common::Input::InputDevice> StickFromButton::Create(
+    const Common::ParamPackage& params) {
     const std::string null_engine = Common::ParamPackage{{"engine", "null"}}.Serialize();
-    auto up = Input::CreateDeviceFromString<Input::InputDevice>(params.Get("up", null_engine));
-    auto down = Input::CreateDeviceFromString<Input::InputDevice>(params.Get("down", null_engine));
-    auto left = Input::CreateDeviceFromString<Input::InputDevice>(params.Get("left", null_engine));
-    auto right =
-        Input::CreateDeviceFromString<Input::InputDevice>(params.Get("right", null_engine));
-    auto modifier =
-        Input::CreateDeviceFromString<Input::InputDevice>(params.Get("modifier", null_engine));
+    auto up = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
+        params.Get("up", null_engine));
+    auto down = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
+        params.Get("down", null_engine));
+    auto left = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
+        params.Get("left", null_engine));
+    auto right = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
+        params.Get("right", null_engine));
+    auto modifier = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
+        params.Get("modifier", null_engine));
     auto modifier_scale = params.Get("modifier_scale", 0.5f);
     auto modifier_angle = params.Get("modifier_angle", 5.5f);
     return std::make_unique<Stick>(std::move(up), std::move(down), std::move(left),
diff --git a/src/input_common/helpers/stick_from_buttons.h b/src/input_common/helpers/stick_from_buttons.h
index 82dff5ca87..437ace4f7e 100644
--- a/src/input_common/helpers/stick_from_buttons.h
+++ b/src/input_common/helpers/stick_from_buttons.h
@@ -12,7 +12,7 @@ namespace InputCommon {
  * An analog device factory that takes direction button devices and combines them into a analog
  * device.
  */
-class StickFromButton final : public Input::Factory<Input::InputDevice> {
+class StickFromButton final : public Common::Input::Factory<Common::Input::InputDevice> {
 public:
     /**
      * Creates an analog device from direction button devices
@@ -24,7 +24,7 @@ public:
      *     - "modifier": a serialized ParamPackage for creating a button device as the modifier
      *     - "modifier_scale": a float for the multiplier the modifier gives to the position
      */
-    std::unique_ptr<Input::InputDevice> Create(const Common::ParamPackage& params) override;
+    std::unique_ptr<Common::Input::InputDevice> Create(const Common::ParamPackage& params) override;
 };
 
 } // namespace InputCommon
diff --git a/src/input_common/helpers/touch_from_buttons.cpp b/src/input_common/helpers/touch_from_buttons.cpp
index bb2bad5b11..fee41cae34 100644
--- a/src/input_common/helpers/touch_from_buttons.cpp
+++ b/src/input_common/helpers/touch_from_buttons.cpp
@@ -9,22 +9,22 @@
 
 namespace InputCommon {
 
-class TouchFromButtonDevice final : public Input::InputDevice {
+class TouchFromButtonDevice final : public Common::Input::InputDevice {
 public:
-    using Button = std::unique_ptr<Input::InputDevice>;
+    using Button = std::unique_ptr<Common::Input::InputDevice>;
     TouchFromButtonDevice(Button button_, u32 touch_id_, float x_, float y_)
         : button(std::move(button_)), touch_id(touch_id_), x(x_), y(y_) {
-        Input::InputCallback button_up_callback{
-            [this](Input::CallbackStatus callback_) { UpdateButtonStatus(callback_); }};
+        Common::Input::InputCallback button_up_callback{
+            [this](Common::Input::CallbackStatus callback_) { UpdateButtonStatus(callback_); }};
         button->SetCallback(button_up_callback);
         button->ForceUpdate();
     }
 
-    Input::TouchStatus GetStatus(bool pressed) const {
-        const Input::ButtonStatus button_status{
+    Common::Input::TouchStatus GetStatus(bool pressed) const {
+        const Common::Input::ButtonStatus button_status{
             .value = pressed,
         };
-        Input::TouchStatus status{
+        Common::Input::TouchStatus status{
             .pressed = button_status,
             .x = {},
             .y = {},
@@ -42,9 +42,9 @@ public:
         return status;
     }
 
-    void UpdateButtonStatus(Input::CallbackStatus button_callback) {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Touch,
+    void UpdateButtonStatus(Common::Input::CallbackStatus button_callback) {
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Touch,
             .touch_status = GetStatus(button_callback.button_status.value),
         };
         TriggerOnChange(status);
@@ -55,13 +55,14 @@ private:
     const u32 touch_id;
     const float x;
     const float y;
-    const Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
+    const Common::Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
 };
 
-std::unique_ptr<Input::InputDevice> TouchFromButton::Create(const Common::ParamPackage& params) {
+std::unique_ptr<Common::Input::InputDevice> TouchFromButton::Create(
+    const Common::ParamPackage& params) {
     const std::string null_engine = Common::ParamPackage{{"engine", "null"}}.Serialize();
-    auto button =
-        Input::CreateDeviceFromString<Input::InputDevice>(params.Get("button", null_engine));
+    auto button = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
+        params.Get("button", null_engine));
     const auto touch_id = params.Get("touch_id", 0);
     const float x = params.Get("x", 0.0f) / 1280.0f;
     const float y = params.Get("y", 0.0f) / 720.0f;
diff --git a/src/input_common/helpers/touch_from_buttons.h b/src/input_common/helpers/touch_from_buttons.h
index 21b353728a..628f182157 100644
--- a/src/input_common/helpers/touch_from_buttons.h
+++ b/src/input_common/helpers/touch_from_buttons.h
@@ -11,12 +11,12 @@ namespace InputCommon {
 /**
  * A touch device factory that takes a list of button devices and combines them into a touch device.
  */
-class TouchFromButton final : public Input::Factory<Input::InputDevice> {
+class TouchFromButton final : public Common::Input::Factory<Common::Input::InputDevice> {
 public:
     /**
      * Creates a touch device from a list of button devices
      */
-    std::unique_ptr<Input::InputDevice> Create(const Common::ParamPackage& params) override;
+    std::unique_ptr<Common::Input::InputDevice> Create(const Common::ParamPackage& params) override;
 };
 
 } // namespace InputCommon
diff --git a/src/input_common/input_engine.h b/src/input_common/input_engine.h
index 31ce900d76..ed79d3d934 100644
--- a/src/input_common/input_engine.h
+++ b/src/input_common/input_engine.h
@@ -116,22 +116,22 @@ public:
 
     // Sets a led pattern for a controller
     virtual void SetLeds([[maybe_unused]] const PadIdentifier& identifier,
-                         [[maybe_unused]] const Input::LedStatus led_status) {
+                         [[maybe_unused]] const Common::Input::LedStatus led_status) {
         return;
     }
 
     // Sets rumble to a controller
-    virtual Input::VibrationError SetRumble(
+    virtual Common::Input::VibrationError SetRumble(
         [[maybe_unused]] const PadIdentifier& identifier,
-        [[maybe_unused]] const Input::VibrationStatus vibration) {
-        return Input::VibrationError::NotSupported;
+        [[maybe_unused]] const Common::Input::VibrationStatus vibration) {
+        return Common::Input::VibrationError::NotSupported;
     }
 
     // Sets polling mode to a controller
-    virtual Input::PollingError SetPollingMode(
+    virtual Common::Input::PollingError SetPollingMode(
         [[maybe_unused]] const PadIdentifier& identifier,
-        [[maybe_unused]] const Input::PollingMode vibration) {
-        return Input::PollingError::NotSupported;
+        [[maybe_unused]] const Common::Input::PollingMode vibration) {
+        return Common::Input::PollingError::NotSupported;
     }
 
     // Returns the engine name
diff --git a/src/input_common/input_poller.cpp b/src/input_common/input_poller.cpp
index 6edb8d9005..2b3b779380 100644
--- a/src/input_common/input_poller.cpp
+++ b/src/input_common/input_poller.cpp
@@ -10,13 +10,13 @@
 
 namespace InputCommon {
 
-class DummyInput final : public Input::InputDevice {
+class DummyInput final : public Common::Input::InputDevice {
 public:
     explicit DummyInput() {}
     ~DummyInput() {}
 };
 
-class InputFromButton final : public Input::InputDevice {
+class InputFromButton final : public Common::Input::InputDevice {
 public:
     explicit InputFromButton(PadIdentifier identifier_, u32 button_, bool toggle_, bool inverted_,
                              InputEngine* input_engine_)
@@ -37,7 +37,7 @@ public:
         input_engine->DeleteCallback(callback_key);
     }
 
-    Input::ButtonStatus GetStatus() const {
+    Common::Input::ButtonStatus GetStatus() const {
         return {
             .value = input_engine->GetButton(identifier, button),
             .inverted = inverted,
@@ -46,8 +46,8 @@ public:
     }
 
     void ForceUpdate() {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Button,
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Button,
             .button_status = GetStatus(),
         };
 
@@ -56,8 +56,8 @@ public:
     }
 
     void OnChange() {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Button,
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Button,
             .button_status = GetStatus(),
         };
 
@@ -77,7 +77,7 @@ private:
     InputEngine* input_engine;
 };
 
-class InputFromHatButton final : public Input::InputDevice {
+class InputFromHatButton final : public Common::Input::InputDevice {
 public:
     explicit InputFromHatButton(PadIdentifier identifier_, u32 button_, u8 direction_, bool toggle_,
                                 bool inverted_, InputEngine* input_engine_)
@@ -98,7 +98,7 @@ public:
         input_engine->DeleteCallback(callback_key);
     }
 
-    Input::ButtonStatus GetStatus() const {
+    Common::Input::ButtonStatus GetStatus() const {
         return {
             .value = input_engine->GetHatButton(identifier, button, direction),
             .inverted = inverted,
@@ -107,8 +107,8 @@ public:
     }
 
     void ForceUpdate() {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Button,
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Button,
             .button_status = GetStatus(),
         };
 
@@ -117,8 +117,8 @@ public:
     }
 
     void OnChange() {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Button,
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Button,
             .button_status = GetStatus(),
         };
 
@@ -139,11 +139,12 @@ private:
     InputEngine* input_engine;
 };
 
-class InputFromStick final : public Input::InputDevice {
+class InputFromStick final : public Common::Input::InputDevice {
 public:
     explicit InputFromStick(PadIdentifier identifier_, u32 axis_x_, u32 axis_y_,
-                            Input::AnalogProperties properties_x_,
-                            Input::AnalogProperties properties_y_, InputEngine* input_engine_)
+                            Common::Input::AnalogProperties properties_x_,
+                            Common::Input::AnalogProperties properties_y_,
+                            InputEngine* input_engine_)
         : identifier(identifier_), axis_x(axis_x_), axis_y(axis_y_), properties_x(properties_x_),
           properties_y(properties_y_), input_engine(input_engine_) {
         UpdateCallback engine_callback{[this]() { OnChange(); }};
@@ -170,8 +171,8 @@ public:
         input_engine->DeleteCallback(callback_key_y);
     }
 
-    Input::StickStatus GetStatus() const {
-        Input::StickStatus status;
+    Common::Input::StickStatus GetStatus() const {
+        Common::Input::StickStatus status;
         status.x = {
             .raw_value = input_engine->GetAxis(identifier, axis_x),
             .properties = properties_x,
@@ -184,8 +185,8 @@ public:
     }
 
     void ForceUpdate() {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Stick,
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Stick,
             .stick_status = GetStatus(),
         };
 
@@ -195,8 +196,8 @@ public:
     }
 
     void OnChange() {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Stick,
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Stick,
             .stick_status = GetStatus(),
         };
 
@@ -212,8 +213,8 @@ private:
     const PadIdentifier identifier;
     const u32 axis_x;
     const u32 axis_y;
-    const Input::AnalogProperties properties_x;
-    const Input::AnalogProperties properties_y;
+    const Common::Input::AnalogProperties properties_x;
+    const Common::Input::AnalogProperties properties_y;
     int callback_key_x;
     int callback_key_y;
     float last_axis_x_value;
@@ -221,12 +222,13 @@ private:
     InputEngine* input_engine;
 };
 
-class InputFromTouch final : public Input::InputDevice {
+class InputFromTouch final : public Common::Input::InputDevice {
 public:
     explicit InputFromTouch(PadIdentifier identifier_, u32 touch_id_, u32 button_, bool toggle_,
                             bool inverted_, u32 axis_x_, u32 axis_y_,
-                            Input::AnalogProperties properties_x_,
-                            Input::AnalogProperties properties_y_, InputEngine* input_engine_)
+                            Common::Input::AnalogProperties properties_x_,
+                            Common::Input::AnalogProperties properties_y_,
+                            InputEngine* input_engine_)
         : identifier(identifier_), touch_id(touch_id_), button(button_), toggle(toggle_),
           inverted(inverted_), axis_x(axis_x_), axis_y(axis_y_), properties_x(properties_x_),
           properties_y(properties_y_), input_engine(input_engine_) {
@@ -263,8 +265,8 @@ public:
         input_engine->DeleteCallback(callback_key_y);
     }
 
-    Input::TouchStatus GetStatus() const {
-        Input::TouchStatus status;
+    Common::Input::TouchStatus GetStatus() const {
+        Common::Input::TouchStatus status;
         status.id = touch_id;
         status.pressed = {
             .value = input_engine->GetButton(identifier, button),
@@ -283,8 +285,8 @@ public:
     }
 
     void OnChange() {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Touch,
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Touch,
             .touch_status = GetStatus(),
         };
 
@@ -306,8 +308,8 @@ private:
     const bool inverted;
     const u32 axis_x;
     const u32 axis_y;
-    const Input::AnalogProperties properties_x;
-    const Input::AnalogProperties properties_y;
+    const Common::Input::AnalogProperties properties_x;
+    const Common::Input::AnalogProperties properties_y;
     int callback_key_button;
     int callback_key_x;
     int callback_key_y;
@@ -317,10 +319,10 @@ private:
     InputEngine* input_engine;
 };
 
-class InputFromTrigger final : public Input::InputDevice {
+class InputFromTrigger final : public Common::Input::InputDevice {
 public:
     explicit InputFromTrigger(PadIdentifier identifier_, u32 button_, bool toggle_, bool inverted_,
-                              u32 axis_, Input::AnalogProperties properties_,
+                              u32 axis_, Common::Input::AnalogProperties properties_,
                               InputEngine* input_engine_)
         : identifier(identifier_), button(button_), toggle(toggle_), inverted(inverted_),
           axis(axis_), properties(properties_), input_engine(input_engine_) {
@@ -348,8 +350,8 @@ public:
         input_engine->DeleteCallback(axis_callback_key);
     }
 
-    Input::TriggerStatus GetStatus() const {
-        const Input::AnalogStatus analog_status{
+    Common::Input::TriggerStatus GetStatus() const {
+        const Common::Input::AnalogStatus analog_status{
             .raw_value = input_engine->GetAxis(identifier, axis),
             .properties = properties,
         };
@@ -360,8 +362,8 @@ public:
     }
 
     void OnChange() {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Trigger,
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Trigger,
             .trigger_status = GetStatus(),
         };
 
@@ -379,7 +381,7 @@ private:
     const bool toggle;
     const bool inverted;
     const u32 axis;
-    const Input::AnalogProperties properties;
+    const Common::Input::AnalogProperties properties;
     int callback_key_button;
     int axis_callback_key;
     bool last_button_value;
@@ -387,10 +389,11 @@ private:
     InputEngine* input_engine;
 };
 
-class InputFromAnalog final : public Input::InputDevice {
+class InputFromAnalog final : public Common::Input::InputDevice {
 public:
     explicit InputFromAnalog(PadIdentifier identifier_, u32 axis_,
-                             Input::AnalogProperties properties_, InputEngine* input_engine_)
+                             Common::Input::AnalogProperties properties_,
+                             InputEngine* input_engine_)
         : identifier(identifier_), axis(axis_), properties(properties_),
           input_engine(input_engine_) {
         UpdateCallback engine_callback{[this]() { OnChange(); }};
@@ -408,7 +411,7 @@ public:
         input_engine->DeleteCallback(callback_key);
     }
 
-    Input::AnalogStatus GetStatus() const {
+    Common::Input::AnalogStatus GetStatus() const {
         return {
             .raw_value = input_engine->GetAxis(identifier, axis),
             .properties = properties,
@@ -416,8 +419,8 @@ public:
     }
 
     void OnChange() {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Analog,
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Analog,
             .analog_status = GetStatus(),
         };
 
@@ -430,13 +433,13 @@ public:
 private:
     const PadIdentifier identifier;
     const u32 axis;
-    const Input::AnalogProperties properties;
+    const Common::Input::AnalogProperties properties;
     int callback_key;
     float last_axis_value;
     InputEngine* input_engine;
 };
 
-class InputFromBattery final : public Input::InputDevice {
+class InputFromBattery final : public Common::Input::InputDevice {
 public:
     explicit InputFromBattery(PadIdentifier identifier_, InputEngine* input_engine_)
         : identifier(identifier_), input_engine(input_engine_) {
@@ -447,7 +450,7 @@ public:
             .index = 0,
             .callback = engine_callback,
         };
-        last_battery_value = Input::BatteryStatus::Charging;
+        last_battery_value = Common::Input::BatteryStatus::Charging;
         callback_key = input_engine->SetCallback(input_identifier);
     }
 
@@ -455,13 +458,13 @@ public:
         input_engine->DeleteCallback(callback_key);
     }
 
-    Input::BatteryStatus GetStatus() const {
-        return static_cast<Input::BatteryLevel>(input_engine->GetBattery(identifier));
+    Common::Input::BatteryStatus GetStatus() const {
+        return static_cast<Common::Input::BatteryLevel>(input_engine->GetBattery(identifier));
     }
 
     void ForceUpdate() {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Battery,
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Battery,
             .battery_status = GetStatus(),
         };
 
@@ -470,8 +473,8 @@ public:
     }
 
     void OnChange() {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Battery,
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Battery,
             .battery_status = GetStatus(),
         };
 
@@ -484,11 +487,11 @@ public:
 private:
     const PadIdentifier identifier;
     int callback_key;
-    Input::BatteryStatus last_battery_value;
+    Common::Input::BatteryStatus last_battery_value;
     InputEngine* input_engine;
 };
 
-class InputFromMotion final : public Input::InputDevice {
+class InputFromMotion final : public Common::Input::InputDevice {
 public:
     explicit InputFromMotion(PadIdentifier identifier_, u32 motion_sensor_,
                              InputEngine* input_engine_)
@@ -507,10 +510,10 @@ public:
         input_engine->DeleteCallback(callback_key);
     }
 
-    Input::MotionStatus GetStatus() const {
+    Common::Input::MotionStatus GetStatus() const {
         const auto basic_motion = input_engine->GetMotion(identifier, motion_sensor);
-        Input::MotionStatus status{};
-        const Input::AnalogProperties properties = {
+        Common::Input::MotionStatus status{};
+        const Common::Input::AnalogProperties properties = {
             .deadzone = 0.001f,
             .range = 1.0f,
             .offset = 0.0f,
@@ -526,8 +529,8 @@ public:
     }
 
     void OnChange() {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Motion,
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Motion,
             .motion_status = GetStatus(),
         };
 
@@ -541,12 +544,13 @@ private:
     InputEngine* input_engine;
 };
 
-class InputFromAxisMotion final : public Input::InputDevice {
+class InputFromAxisMotion final : public Common::Input::InputDevice {
 public:
     explicit InputFromAxisMotion(PadIdentifier identifier_, u32 axis_x_, u32 axis_y_, u32 axis_z_,
-                                 Input::AnalogProperties properties_x_,
-                                 Input::AnalogProperties properties_y_,
-                                 Input::AnalogProperties properties_z_, InputEngine* input_engine_)
+                                 Common::Input::AnalogProperties properties_x_,
+                                 Common::Input::AnalogProperties properties_y_,
+                                 Common::Input::AnalogProperties properties_z_,
+                                 InputEngine* input_engine_)
         : identifier(identifier_), axis_x(axis_x_), axis_y(axis_y_), axis_z(axis_z_),
           properties_x(properties_x_), properties_y(properties_y_), properties_z(properties_z_),
           input_engine(input_engine_) {
@@ -583,8 +587,8 @@ public:
         input_engine->DeleteCallback(callback_key_z);
     }
 
-    Input::MotionStatus GetStatus() const {
-        Input::MotionStatus status{};
+    Common::Input::MotionStatus GetStatus() const {
+        Common::Input::MotionStatus status{};
         status.gyro.x = {
             .raw_value = input_engine->GetAxis(identifier, axis_x),
             .properties = properties_x,
@@ -601,8 +605,8 @@ public:
     }
 
     void ForceUpdate() {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Motion,
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Motion,
             .motion_status = GetStatus(),
         };
 
@@ -613,8 +617,8 @@ public:
     }
 
     void OnChange() {
-        const Input::CallbackStatus status{
-            .type = Input::InputType::Motion,
+        const Common::Input::CallbackStatus status{
+            .type = Common::Input::InputType::Motion,
             .motion_status = GetStatus(),
         };
 
@@ -633,9 +637,9 @@ private:
     const u32 axis_x;
     const u32 axis_y;
     const u32 axis_z;
-    const Input::AnalogProperties properties_x;
-    const Input::AnalogProperties properties_y;
-    const Input::AnalogProperties properties_z;
+    const Common::Input::AnalogProperties properties_x;
+    const Common::Input::AnalogProperties properties_y;
+    const Common::Input::AnalogProperties properties_z;
     int callback_key_x;
     int callback_key_y;
     int callback_key_z;
@@ -645,20 +649,21 @@ private:
     InputEngine* input_engine;
 };
 
-class OutputFromIdentifier final : public Input::OutputDevice {
+class OutputFromIdentifier final : public Common::Input::OutputDevice {
 public:
     explicit OutputFromIdentifier(PadIdentifier identifier_, InputEngine* input_engine_)
         : identifier(identifier_), input_engine(input_engine_) {}
 
-    virtual void SetLED(Input::LedStatus led_status) {
+    virtual void SetLED(Common::Input::LedStatus led_status) {
         input_engine->SetLeds(identifier, led_status);
     }
 
-    virtual Input::VibrationError SetVibration(Input::VibrationStatus vibration_status) {
+    virtual Common::Input::VibrationError SetVibration(
+        Common::Input::VibrationStatus vibration_status) {
         return input_engine->SetRumble(identifier, vibration_status);
     }
 
-    virtual Input::PollingError SetPollingMode(Input::PollingMode polling_mode) {
+    virtual Common::Input::PollingError SetPollingMode(Common::Input::PollingMode polling_mode) {
         return input_engine->SetPollingMode(identifier, polling_mode);
     }
 
@@ -667,7 +672,7 @@ private:
     InputEngine* input_engine;
 };
 
-std::unique_ptr<Input::InputDevice> InputFactory::CreateButtonDevice(
+std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateButtonDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
         .guid = Common::UUID{params.Get("guid", "")},
@@ -690,7 +695,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateButtonDevice(
                                              input_engine.get());
 }
 
-std::unique_ptr<Input::InputDevice> InputFactory::CreateHatButtonDevice(
+std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateHatButtonDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
         .guid = Common::UUID{params.Get("guid", "")},
@@ -709,7 +714,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateHatButtonDevice(
                                                 input_engine.get());
 }
 
-std::unique_ptr<Input::InputDevice> InputFactory::CreateStickDevice(
+std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateStickDevice(
     const Common::ParamPackage& params) {
     const auto deadzone = std::clamp(params.Get("deadzone", 0.15f), 0.0f, 1.0f);
     const auto range = std::clamp(params.Get("range", 1.0f), 0.25f, 1.50f);
@@ -721,7 +726,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateStickDevice(
     };
 
     const auto axis_x = static_cast<u32>(params.Get("axis_x", 0));
-    const Input::AnalogProperties properties_x = {
+    const Common::Input::AnalogProperties properties_x = {
         .deadzone = deadzone,
         .range = range,
         .threshold = threshold,
@@ -730,7 +735,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateStickDevice(
     };
 
     const auto axis_y = static_cast<u32>(params.Get("axis_y", 1));
-    const Input::AnalogProperties properties_y = {
+    const Common::Input::AnalogProperties properties_y = {
         .deadzone = deadzone,
         .range = range,
         .threshold = threshold,
@@ -744,7 +749,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateStickDevice(
                                             input_engine.get());
 }
 
-std::unique_ptr<Input::InputDevice> InputFactory::CreateAnalogDevice(
+std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateAnalogDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
         .guid = Common::UUID{params.Get("guid", "")},
@@ -753,7 +758,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateAnalogDevice(
     };
 
     const auto axis = static_cast<u32>(params.Get("axis", 0));
-    const Input::AnalogProperties properties = {
+    const Common::Input::AnalogProperties properties = {
         .deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, 1.0f),
         .range = std::clamp(params.Get("range", 1.0f), 0.25f, 1.50f),
         .threshold = std::clamp(params.Get("threshold", 0.5f), 0.0f, 1.0f),
@@ -765,7 +770,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateAnalogDevice(
     return std::make_unique<InputFromAnalog>(identifier, axis, properties, input_engine.get());
 }
 
-std::unique_ptr<Input::InputDevice> InputFactory::CreateTriggerDevice(
+std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateTriggerDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
         .guid = Common::UUID{params.Get("guid", "")},
@@ -778,7 +783,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateTriggerDevice(
     const auto inverted = params.Get("inverted", false);
 
     const auto axis = static_cast<u32>(params.Get("axis", 0));
-    const Input::AnalogProperties properties = {
+    const Common::Input::AnalogProperties properties = {
         .deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, 1.0f),
         .range = std::clamp(params.Get("range", 1.0f), 0.25f, 2.50f),
         .threshold = std::clamp(params.Get("threshold", 0.5f), 0.0f, 1.0f),
@@ -792,7 +797,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateTriggerDevice(
                                               properties, input_engine.get());
 }
 
-std::unique_ptr<Input::InputDevice> InputFactory::CreateTouchDevice(
+std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateTouchDevice(
     const Common::ParamPackage& params) {
     const auto touch_id = params.Get("touch_id", 0);
     const auto deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, 1.0f);
@@ -809,7 +814,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateTouchDevice(
     const auto inverted = params.Get("inverted", false);
 
     const auto axis_x = static_cast<u32>(params.Get("axis_x", 0));
-    const Input::AnalogProperties properties_x = {
+    const Common::Input::AnalogProperties properties_x = {
         .deadzone = deadzone,
         .range = range,
         .threshold = threshold,
@@ -818,7 +823,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateTouchDevice(
     };
 
     const auto axis_y = static_cast<u32>(params.Get("axis_y", 1));
-    const Input::AnalogProperties properties_y = {
+    const Common::Input::AnalogProperties properties_y = {
         .deadzone = deadzone,
         .range = range,
         .threshold = threshold,
@@ -833,7 +838,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateTouchDevice(
                                             axis_y, properties_x, properties_y, input_engine.get());
 }
 
-std::unique_ptr<Input::InputDevice> InputFactory::CreateBatteryDevice(
+std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateBatteryDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
         .guid = Common::UUID{params.Get("guid", "")},
@@ -845,7 +850,8 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateBatteryDevice(
     return std::make_unique<InputFromBattery>(identifier, input_engine.get());
 }
 
-std::unique_ptr<Input::InputDevice> InputFactory::CreateMotionDevice(Common::ParamPackage params) {
+std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateMotionDevice(
+    Common::ParamPackage params) {
     const PadIdentifier identifier = {
         .guid = Common::UUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
@@ -864,7 +870,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateMotionDevice(Common::Par
     const auto threshold = std::clamp(params.Get("threshold", 0.5f), 0.0f, 1.0f);
 
     const auto axis_x = static_cast<u32>(params.Get("axis_x", 0));
-    const Input::AnalogProperties properties_x = {
+    const Common::Input::AnalogProperties properties_x = {
         .deadzone = deadzone,
         .range = range,
         .threshold = threshold,
@@ -873,7 +879,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateMotionDevice(Common::Par
     };
 
     const auto axis_y = static_cast<u32>(params.Get("axis_y", 1));
-    const Input::AnalogProperties properties_y = {
+    const Common::Input::AnalogProperties properties_y = {
         .deadzone = deadzone,
         .range = range,
         .threshold = threshold,
@@ -882,7 +888,7 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateMotionDevice(Common::Par
     };
 
     const auto axis_z = static_cast<u32>(params.Get("axis_z", 1));
-    const Input::AnalogProperties properties_z = {
+    const Common::Input::AnalogProperties properties_z = {
         .deadzone = deadzone,
         .range = range,
         .threshold = threshold,
@@ -900,7 +906,8 @@ std::unique_ptr<Input::InputDevice> InputFactory::CreateMotionDevice(Common::Par
 InputFactory::InputFactory(std::shared_ptr<InputEngine> input_engine_)
     : input_engine(std::move(input_engine_)) {}
 
-std::unique_ptr<Input::InputDevice> InputFactory::Create(const Common::ParamPackage& params) {
+std::unique_ptr<Common::Input::InputDevice> InputFactory::Create(
+    const Common::ParamPackage& params) {
     if (params.Has("battery")) {
         return CreateBatteryDevice(params);
     }
@@ -935,7 +942,8 @@ std::unique_ptr<Input::InputDevice> InputFactory::Create(const Common::ParamPack
 OutputFactory::OutputFactory(std::shared_ptr<InputEngine> input_engine_)
     : input_engine(std::move(input_engine_)) {}
 
-std::unique_ptr<Input::OutputDevice> OutputFactory::Create(const Common::ParamPackage& params) {
+std::unique_ptr<Common::Input::OutputDevice> OutputFactory::Create(
+    const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
         .guid = Common::UUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
diff --git a/src/input_common/input_poller.h b/src/input_common/input_poller.h
index 1357e104be..573f09fded 100644
--- a/src/input_common/input_poller.h
+++ b/src/input_common/input_poller.h
@@ -17,7 +17,7 @@ class InputEngine;
  * An Input factory. It receives input events and forward them to all input devices it created.
  */
 
-class OutputFactory final : public Input::Factory<Input::OutputDevice> {
+class OutputFactory final : public Common::Input::Factory<Common::Input::OutputDevice> {
 public:
     explicit OutputFactory(std::shared_ptr<InputEngine> input_engine_);
 
@@ -29,13 +29,14 @@ public:
      * @param    - "pad": slot of the connected controller
      * @return an unique ouput device with the parameters specified
      */
-    std::unique_ptr<Input::OutputDevice> Create(const Common::ParamPackage& params) override;
+    std::unique_ptr<Common::Input::OutputDevice> Create(
+        const Common::ParamPackage& params) override;
 
 private:
     std::shared_ptr<InputEngine> input_engine;
 };
 
-class InputFactory final : public Input::Factory<Input::InputDevice> {
+class InputFactory final : public Common::Input::Factory<Common::Input::InputDevice> {
 public:
     explicit InputFactory(std::shared_ptr<InputEngine> input_engine_);
 
@@ -64,7 +65,7 @@ public:
      * @param    - "battery": Only used as a placeholder to set the input type
      * @return an unique input device with the parameters specified
      */
-    std::unique_ptr<Input::InputDevice> Create(const Common::ParamPackage& params) override;
+    std::unique_ptr<Common::Input::InputDevice> Create(const Common::ParamPackage& params) override;
 
 private:
     /**
@@ -79,7 +80,8 @@ private:
      * @param    - "pad": slot of the connected controller
      * @return an unique input device with the parameters specified
      */
-    std::unique_ptr<Input::InputDevice> CreateButtonDevice(const Common::ParamPackage& params);
+    std::unique_ptr<Common::Input::InputDevice> CreateButtonDevice(
+        const Common::ParamPackage& params);
 
     /**
      * Creates a hat button device from the parameters given.
@@ -93,7 +95,8 @@ private:
      * @param    - "pad": slot of the connected controller
      * @return an unique input device with the parameters specified
      */
-    std::unique_ptr<Input::InputDevice> CreateHatButtonDevice(const Common::ParamPackage& params);
+    std::unique_ptr<Common::Input::InputDevice> CreateHatButtonDevice(
+        const Common::ParamPackage& params);
 
     /**
      * Creates a stick device from the parameters given.
@@ -112,7 +115,8 @@ private:
      * @param    - "pad": slot of the connected controller
      * @return an unique input device with the parameters specified
      */
-    std::unique_ptr<Input::InputDevice> CreateStickDevice(const Common::ParamPackage& params);
+    std::unique_ptr<Common::Input::InputDevice> CreateStickDevice(
+        const Common::ParamPackage& params);
 
     /**
      * Creates an analog device from the parameters given.
@@ -128,7 +132,8 @@ private:
      * @param    - "pad": slot of the connected controller
      * @return an unique input device with the parameters specified
      */
-    std::unique_ptr<Input::InputDevice> CreateAnalogDevice(const Common::ParamPackage& params);
+    std::unique_ptr<Common::Input::InputDevice> CreateAnalogDevice(
+        const Common::ParamPackage& params);
 
     /**
      * Creates a trigger device from the parameters given.
@@ -148,7 +153,8 @@ private:
      * @param    - "pad": slot of the connected controller
      * @return an unique input device with the parameters specified
      */
-    std::unique_ptr<Input::InputDevice> CreateTriggerDevice(const Common::ParamPackage& params);
+    std::unique_ptr<Common::Input::InputDevice> CreateTriggerDevice(
+        const Common::ParamPackage& params);
 
     /**
      * Creates a touch device from the parameters given.
@@ -171,7 +177,8 @@ private:
      * @param    - "pad": slot of the connected controller
      * @return an unique input device with the parameters specified
      */
-    std::unique_ptr<Input::InputDevice> CreateTouchDevice(const Common::ParamPackage& params);
+    std::unique_ptr<Common::Input::InputDevice> CreateTouchDevice(
+        const Common::ParamPackage& params);
 
     /**
      * Creates a battery device from the parameters given.
@@ -181,7 +188,8 @@ private:
      * @param    - "pad": slot of the connected controller
      * @return an unique input device with the parameters specified
      */
-    std::unique_ptr<Input::InputDevice> CreateBatteryDevice(const Common::ParamPackage& params);
+    std::unique_ptr<Common::Input::InputDevice> CreateBatteryDevice(
+        const Common::ParamPackage& params);
 
     /**
      * Creates a motion device from the parameters given.
@@ -202,7 +210,7 @@ private:
      * @param    - "pad": slot of the connected controller
      * @return an unique input device with the parameters specified
      */
-    std::unique_ptr<Input::InputDevice> CreateMotionDevice(Common::ParamPackage params);
+    std::unique_ptr<Common::Input::InputDevice> CreateMotionDevice(Common::ParamPackage params);
 
     std::shared_ptr<InputEngine> input_engine;
 };
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index 07d514ad73..df36a337c7 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -33,89 +33,97 @@ struct InputSubsystem::Impl {
         keyboard->SetMappingCallback(mapping_callback);
         keyboard_factory = std::make_shared<InputFactory>(keyboard);
         keyboard_output_factory = std::make_shared<OutputFactory>(keyboard);
-        Input::RegisterFactory<Input::InputDevice>(keyboard->GetEngineName(), keyboard_factory);
-        Input::RegisterFactory<Input::OutputDevice>(keyboard->GetEngineName(),
-                                                    keyboard_output_factory);
+        Common::Input::RegisterFactory<Common::Input::InputDevice>(keyboard->GetEngineName(),
+                                                                   keyboard_factory);
+        Common::Input::RegisterFactory<Common::Input::OutputDevice>(keyboard->GetEngineName(),
+                                                                    keyboard_output_factory);
 
         mouse = std::make_shared<Mouse>("mouse");
         mouse->SetMappingCallback(mapping_callback);
         mouse_factory = std::make_shared<InputFactory>(mouse);
         mouse_output_factory = std::make_shared<OutputFactory>(mouse);
-        Input::RegisterFactory<Input::InputDevice>(mouse->GetEngineName(), mouse_factory);
-        Input::RegisterFactory<Input::OutputDevice>(mouse->GetEngineName(), mouse_output_factory);
+        Common::Input::RegisterFactory<Common::Input::InputDevice>(mouse->GetEngineName(),
+                                                                   mouse_factory);
+        Common::Input::RegisterFactory<Common::Input::OutputDevice>(mouse->GetEngineName(),
+                                                                    mouse_output_factory);
 
         touch_screen = std::make_shared<TouchScreen>("touch");
         touch_screen_factory = std::make_shared<InputFactory>(touch_screen);
-        Input::RegisterFactory<Input::InputDevice>(touch_screen->GetEngineName(),
-                                                   touch_screen_factory);
+        Common::Input::RegisterFactory<Common::Input::InputDevice>(touch_screen->GetEngineName(),
+                                                                   touch_screen_factory);
 
         gcadapter = std::make_shared<GCAdapter>("gcpad");
         gcadapter->SetMappingCallback(mapping_callback);
         gcadapter_input_factory = std::make_shared<InputFactory>(gcadapter);
         gcadapter_output_factory = std::make_shared<OutputFactory>(gcadapter);
-        Input::RegisterFactory<Input::InputDevice>(gcadapter->GetEngineName(),
-                                                   gcadapter_input_factory);
-        Input::RegisterFactory<Input::OutputDevice>(gcadapter->GetEngineName(),
-                                                    gcadapter_output_factory);
+        Common::Input::RegisterFactory<Common::Input::InputDevice>(gcadapter->GetEngineName(),
+                                                                   gcadapter_input_factory);
+        Common::Input::RegisterFactory<Common::Input::OutputDevice>(gcadapter->GetEngineName(),
+                                                                    gcadapter_output_factory);
 
         udp_client = std::make_shared<CemuhookUDP::UDPClient>("cemuhookudp");
         udp_client->SetMappingCallback(mapping_callback);
         udp_client_factory = std::make_shared<InputFactory>(udp_client);
-        Input::RegisterFactory<Input::InputDevice>(udp_client->GetEngineName(), udp_client_factory);
+        Common::Input::RegisterFactory<Common::Input::InputDevice>(udp_client->GetEngineName(),
+                                                                   udp_client_factory);
 
         tas_input = std::make_shared<TasInput::Tas>("tas");
         tas_input->SetMappingCallback(mapping_callback);
         tas_input_factory = std::make_shared<InputFactory>(tas_input);
         tas_output_factory = std::make_shared<OutputFactory>(tas_input);
-        Input::RegisterFactory<Input::InputDevice>(tas_input->GetEngineName(), tas_input_factory);
-        Input::RegisterFactory<Input::OutputDevice>(tas_input->GetEngineName(), tas_output_factory);
+        Common::Input::RegisterFactory<Common::Input::InputDevice>(tas_input->GetEngineName(),
+                                                                   tas_input_factory);
+        Common::Input::RegisterFactory<Common::Input::OutputDevice>(tas_input->GetEngineName(),
+                                                                    tas_output_factory);
 
 #ifdef HAVE_SDL2
         sdl = std::make_shared<SDLDriver>("sdl");
         sdl->SetMappingCallback(mapping_callback);
         sdl_input_factory = std::make_shared<InputFactory>(sdl);
         sdl_output_factory = std::make_shared<OutputFactory>(sdl);
-        Input::RegisterFactory<Input::InputDevice>(sdl->GetEngineName(), sdl_input_factory);
-        Input::RegisterFactory<Input::OutputDevice>(sdl->GetEngineName(), sdl_output_factory);
+        Common::Input::RegisterFactory<Common::Input::InputDevice>(sdl->GetEngineName(),
+                                                                   sdl_input_factory);
+        Common::Input::RegisterFactory<Common::Input::OutputDevice>(sdl->GetEngineName(),
+                                                                    sdl_output_factory);
 #endif
 
-        Input::RegisterFactory<Input::InputDevice>("touch_from_button",
-                                                   std::make_shared<TouchFromButton>());
-        Input::RegisterFactory<Input::InputDevice>("analog_from_button",
-                                                   std::make_shared<StickFromButton>());
+        Common::Input::RegisterFactory<Common::Input::InputDevice>(
+            "touch_from_button", std::make_shared<TouchFromButton>());
+        Common::Input::RegisterFactory<Common::Input::InputDevice>(
+            "analog_from_button", std::make_shared<StickFromButton>());
     }
 
     void Shutdown() {
-        Input::UnregisterFactory<Input::InputDevice>(keyboard->GetEngineName());
-        Input::UnregisterFactory<Input::OutputDevice>(keyboard->GetEngineName());
+        Common::Input::UnregisterFactory<Common::Input::InputDevice>(keyboard->GetEngineName());
+        Common::Input::UnregisterFactory<Common::Input::OutputDevice>(keyboard->GetEngineName());
         keyboard.reset();
 
-        Input::UnregisterFactory<Input::InputDevice>(mouse->GetEngineName());
-        Input::UnregisterFactory<Input::OutputDevice>(mouse->GetEngineName());
+        Common::Input::UnregisterFactory<Common::Input::InputDevice>(mouse->GetEngineName());
+        Common::Input::UnregisterFactory<Common::Input::OutputDevice>(mouse->GetEngineName());
         mouse.reset();
 
-        Input::UnregisterFactory<Input::InputDevice>(touch_screen->GetEngineName());
+        Common::Input::UnregisterFactory<Common::Input::InputDevice>(touch_screen->GetEngineName());
         touch_screen.reset();
 
-        Input::UnregisterFactory<Input::InputDevice>(gcadapter->GetEngineName());
-        Input::UnregisterFactory<Input::OutputDevice>(gcadapter->GetEngineName());
+        Common::Input::UnregisterFactory<Common::Input::InputDevice>(gcadapter->GetEngineName());
+        Common::Input::UnregisterFactory<Common::Input::OutputDevice>(gcadapter->GetEngineName());
         gcadapter.reset();
 
-        Input::UnregisterFactory<Input::InputDevice>(udp_client->GetEngineName());
+        Common::Input::UnregisterFactory<Common::Input::InputDevice>(udp_client->GetEngineName());
         udp_client.reset();
 
-        Input::UnregisterFactory<Input::InputDevice>(tas_input->GetEngineName());
-        Input::UnregisterFactory<Input::OutputDevice>(tas_input->GetEngineName());
+        Common::Input::UnregisterFactory<Common::Input::InputDevice>(tas_input->GetEngineName());
+        Common::Input::UnregisterFactory<Common::Input::OutputDevice>(tas_input->GetEngineName());
         tas_input.reset();
 
 #ifdef HAVE_SDL2
-        Input::UnregisterFactory<Input::InputDevice>(sdl->GetEngineName());
-        Input::UnregisterFactory<Input::OutputDevice>(sdl->GetEngineName());
+        Common::Input::UnregisterFactory<Common::Input::InputDevice>(sdl->GetEngineName());
+        Common::Input::UnregisterFactory<Common::Input::OutputDevice>(sdl->GetEngineName());
         sdl.reset();
 #endif
 
-        Input::UnregisterFactory<Input::InputDevice>("touch_from_button");
-        Input::UnregisterFactory<Input::InputDevice>("analog_from_button");
+        Common::Input::UnregisterFactory<Common::Input::InputDevice>("touch_from_button");
+        Common::Input::UnregisterFactory<Common::Input::InputDevice>("analog_from_button");
     }
 
     [[nodiscard]] std::vector<Common::ParamPackage> GetInputDevices() const {
diff --git a/src/yuzu/configuration/configure_input_player_widget.cpp b/src/yuzu/configuration/configure_input_player_widget.cpp
index 67e56ed3ab..bb20e9339b 100644
--- a/src/yuzu/configuration/configure_input_player_widget.cpp
+++ b/src/yuzu/configuration/configure_input_player_widget.cpp
@@ -1945,8 +1945,8 @@ void PlayerControlPreview::DrawRightBody(QPainter& p, const QPointF center) {
 }
 
 void PlayerControlPreview::DrawProTriggers(QPainter& p, const QPointF center,
-                                           const Input::ButtonStatus& left_pressed,
-                                           const Input::ButtonStatus& right_pressed) {
+                                           const Common::Input::ButtonStatus& left_pressed,
+                                           const Common::Input::ButtonStatus& right_pressed) {
     std::array<QPointF, pro_left_trigger.size() / 2> qleft_trigger;
     std::array<QPointF, pro_left_trigger.size() / 2> qright_trigger;
     std::array<QPointF, pro_body_top.size()> qbody_top;
@@ -1984,8 +1984,8 @@ void PlayerControlPreview::DrawProTriggers(QPainter& p, const QPointF center,
 }
 
 void PlayerControlPreview::DrawGCTriggers(QPainter& p, const QPointF center,
-                                          Input::TriggerStatus left_trigger,
-                                          Input::TriggerStatus right_trigger) {
+                                          Common::Input::TriggerStatus left_trigger,
+                                          Common::Input::TriggerStatus right_trigger) {
     std::array<QPointF, left_gc_trigger.size() / 2> qleft_trigger;
     std::array<QPointF, left_gc_trigger.size() / 2> qright_trigger;
 
@@ -2022,8 +2022,8 @@ void PlayerControlPreview::DrawGCTriggers(QPainter& p, const QPointF center,
 }
 
 void PlayerControlPreview::DrawHandheldTriggers(QPainter& p, const QPointF center,
-                                                const Input::ButtonStatus& left_pressed,
-                                                const Input::ButtonStatus& right_pressed) {
+                                                const Common::Input::ButtonStatus& left_pressed,
+                                                const Common::Input::ButtonStatus& right_pressed) {
     std::array<QPointF, left_joycon_trigger.size() / 2> qleft_trigger;
     std::array<QPointF, left_joycon_trigger.size() / 2> qright_trigger;
 
@@ -2048,8 +2048,8 @@ void PlayerControlPreview::DrawHandheldTriggers(QPainter& p, const QPointF cente
 }
 
 void PlayerControlPreview::DrawDualTriggers(QPainter& p, const QPointF center,
-                                            const Input::ButtonStatus& left_pressed,
-                                            const Input::ButtonStatus& right_pressed) {
+                                            const Common::Input::ButtonStatus& left_pressed,
+                                            const Common::Input::ButtonStatus& right_pressed) {
     std::array<QPointF, left_joycon_trigger.size() / 2> qleft_trigger;
     std::array<QPointF, left_joycon_trigger.size() / 2> qright_trigger;
     constexpr float size = 1.62f;
@@ -2076,9 +2076,9 @@ void PlayerControlPreview::DrawDualTriggers(QPainter& p, const QPointF center,
     DrawPolygon(p, qright_trigger);
 }
 
-void PlayerControlPreview::DrawDualTriggersTopView(QPainter& p, const QPointF center,
-                                                   const Input::ButtonStatus& left_pressed,
-                                                   const Input::ButtonStatus& right_pressed) {
+void PlayerControlPreview::DrawDualTriggersTopView(
+    QPainter& p, const QPointF center, const Common::Input::ButtonStatus& left_pressed,
+    const Common::Input::ButtonStatus& right_pressed) {
     std::array<QPointF, left_joystick_L_topview.size() / 2> qleft_trigger;
     std::array<QPointF, left_joystick_L_topview.size() / 2> qright_trigger;
     constexpr float size = 0.9f;
@@ -2113,9 +2113,9 @@ void PlayerControlPreview::DrawDualTriggersTopView(QPainter& p, const QPointF ce
     DrawSymbol(p, center + QPointF(177, -84), Symbol::R, 1.0f);
 }
 
-void PlayerControlPreview::DrawDualZTriggersTopView(QPainter& p, const QPointF center,
-                                                    const Input::ButtonStatus& left_pressed,
-                                                    const Input::ButtonStatus& right_pressed) {
+void PlayerControlPreview::DrawDualZTriggersTopView(
+    QPainter& p, const QPointF center, const Common::Input::ButtonStatus& left_pressed,
+    const Common::Input::ButtonStatus& right_pressed) {
     std::array<QPointF, left_joystick_ZL_topview.size() / 2> qleft_trigger;
     std::array<QPointF, left_joystick_ZL_topview.size() / 2> qright_trigger;
     constexpr float size = 0.9f;
@@ -2149,7 +2149,7 @@ void PlayerControlPreview::DrawDualZTriggersTopView(QPainter& p, const QPointF c
 }
 
 void PlayerControlPreview::DrawLeftTriggers(QPainter& p, const QPointF center,
-                                            const Input::ButtonStatus& left_pressed) {
+                                            const Common::Input::ButtonStatus& left_pressed) {
     std::array<QPointF, left_joycon_trigger.size() / 2> qleft_trigger;
     constexpr float size = 1.78f;
     constexpr float offset = 311.5f;
@@ -2166,7 +2166,7 @@ void PlayerControlPreview::DrawLeftTriggers(QPainter& p, const QPointF center,
 }
 
 void PlayerControlPreview::DrawLeftZTriggers(QPainter& p, const QPointF center,
-                                             const Input::ButtonStatus& left_pressed) {
+                                             const Common::Input::ButtonStatus& left_pressed) {
     std::array<QPointF, left_joycon_sideview_zl.size() / 2> qleft_trigger;
     constexpr float size = 1.1115f;
     constexpr float offset2 = 335;
@@ -2184,8 +2184,8 @@ void PlayerControlPreview::DrawLeftZTriggers(QPainter& p, const QPointF center,
               225 * 16, 44 * 16);
 }
 
-void PlayerControlPreview::DrawLeftTriggersTopView(QPainter& p, const QPointF center,
-                                                   const Input::ButtonStatus& left_pressed) {
+void PlayerControlPreview::DrawLeftTriggersTopView(
+    QPainter& p, const QPointF center, const Common::Input::ButtonStatus& left_pressed) {
     std::array<QPointF, left_joystick_L_topview.size() / 2> qleft_trigger;
 
     for (std::size_t point = 0; point < left_joystick_L_topview.size() / 2; ++point) {
@@ -2203,8 +2203,8 @@ void PlayerControlPreview::DrawLeftTriggersTopView(QPainter& p, const QPointF ce
     DrawSymbol(p, center + QPointF(-143, -36), Symbol::L, 1.0f);
 }
 
-void PlayerControlPreview::DrawLeftZTriggersTopView(QPainter& p, const QPointF center,
-                                                    const Input::ButtonStatus& left_pressed) {
+void PlayerControlPreview::DrawLeftZTriggersTopView(
+    QPainter& p, const QPointF center, const Common::Input::ButtonStatus& left_pressed) {
     std::array<QPointF, left_joystick_ZL_topview.size() / 2> qleft_trigger;
 
     for (std::size_t point = 0; point < left_joystick_ZL_topview.size() / 2; ++point) {
@@ -2223,7 +2223,7 @@ void PlayerControlPreview::DrawLeftZTriggersTopView(QPainter& p, const QPointF c
 }
 
 void PlayerControlPreview::DrawRightTriggers(QPainter& p, const QPointF center,
-                                             const Input::ButtonStatus& right_pressed) {
+                                             const Common::Input::ButtonStatus& right_pressed) {
     std::array<QPointF, left_joycon_trigger.size() / 2> qright_trigger;
     constexpr float size = 1.78f;
     constexpr float offset = 311.5f;
@@ -2240,7 +2240,7 @@ void PlayerControlPreview::DrawRightTriggers(QPainter& p, const QPointF center,
 }
 
 void PlayerControlPreview::DrawRightZTriggers(QPainter& p, const QPointF center,
-                                              const Input::ButtonStatus& right_pressed) {
+                                              const Common::Input::ButtonStatus& right_pressed) {
     std::array<QPointF, left_joycon_sideview_zl.size() / 2> qright_trigger;
     constexpr float size = 1.1115f;
     constexpr float offset2 = 335;
@@ -2259,8 +2259,8 @@ void PlayerControlPreview::DrawRightZTriggers(QPainter& p, const QPointF center,
               271 * 16, 44 * 16);
 }
 
-void PlayerControlPreview::DrawRightTriggersTopView(QPainter& p, const QPointF center,
-                                                    const Input::ButtonStatus& right_pressed) {
+void PlayerControlPreview::DrawRightTriggersTopView(
+    QPainter& p, const QPointF center, const Common::Input::ButtonStatus& right_pressed) {
     std::array<QPointF, left_joystick_L_topview.size() / 2> qright_trigger;
 
     for (std::size_t point = 0; point < left_joystick_L_topview.size() / 2; ++point) {
@@ -2278,8 +2278,8 @@ void PlayerControlPreview::DrawRightTriggersTopView(QPainter& p, const QPointF c
     DrawSymbol(p, center + QPointF(137, -36), Symbol::R, 1.0f);
 }
 
-void PlayerControlPreview::DrawRightZTriggersTopView(QPainter& p, const QPointF center,
-                                                     const Input::ButtonStatus& right_pressed) {
+void PlayerControlPreview::DrawRightZTriggersTopView(
+    QPainter& p, const QPointF center, const Common::Input::ButtonStatus& right_pressed) {
     std::array<QPointF, left_joystick_ZL_topview.size() / 2> qright_trigger;
 
     for (std::size_t point = 0; point < left_joystick_ZL_topview.size() / 2; ++point) {
@@ -2298,7 +2298,7 @@ void PlayerControlPreview::DrawRightZTriggersTopView(QPainter& p, const QPointF
 }
 
 void PlayerControlPreview::DrawJoystick(QPainter& p, const QPointF center, float size,
-                                        const Input::ButtonStatus& pressed) {
+                                        const Common::Input::ButtonStatus& pressed) {
     const float radius1 = 13.0f * size;
     const float radius2 = 9.0f * size;
 
@@ -2317,7 +2317,8 @@ void PlayerControlPreview::DrawJoystick(QPainter& p, const QPointF center, float
 }
 
 void PlayerControlPreview::DrawJoystickSideview(QPainter& p, const QPointF center, float angle,
-                                                float size, const Input::ButtonStatus& pressed) {
+                                                float size,
+                                                const Common::Input::ButtonStatus& pressed) {
     QVector<QPointF> joystick;
     joystick.reserve(static_cast<int>(left_joystick_sideview.size() / 2));
 
@@ -2342,7 +2343,7 @@ void PlayerControlPreview::DrawJoystickSideview(QPainter& p, const QPointF cente
 
 void PlayerControlPreview::DrawProJoystick(QPainter& p, const QPointF center, const QPointF offset,
                                            float offset_scalar,
-                                           const Input::ButtonStatus& pressed) {
+                                           const Common::Input::ButtonStatus& pressed) {
     const float radius1 = 24.0f;
     const float radius2 = 17.0f;
 
@@ -2377,7 +2378,7 @@ void PlayerControlPreview::DrawProJoystick(QPainter& p, const QPointF center, co
 }
 
 void PlayerControlPreview::DrawGCJoystick(QPainter& p, const QPointF center,
-                                          const Input::ButtonStatus& pressed) {
+                                          const Common::Input::ButtonStatus& pressed) {
     // Outer circle
     p.setPen(colors.outline);
     p.setBrush(pressed.value ? colors.highlight : colors.button);
@@ -2414,8 +2415,8 @@ void PlayerControlPreview::DrawRawJoystick(QPainter& p, QPointF center_left, QPo
     }
 }
 
-void PlayerControlPreview::DrawJoystickProperties(QPainter& p, const QPointF center,
-                                                  const Input::AnalogProperties& properties) {
+void PlayerControlPreview::DrawJoystickProperties(
+    QPainter& p, const QPointF center, const Common::Input::AnalogProperties& properties) {
     constexpr float size = 45.0f;
     const float range = size * properties.range;
     const float deadzone = size * properties.deadzone;
@@ -2435,7 +2436,7 @@ void PlayerControlPreview::DrawJoystickProperties(QPainter& p, const QPointF cen
 }
 
 void PlayerControlPreview::DrawJoystickDot(QPainter& p, const QPointF center,
-                                           const Input::StickStatus& stick, bool raw) {
+                                           const Common::Input::StickStatus& stick, bool raw) {
     constexpr float size = 45.0f;
     const float range = size * stick.x.properties.range;
 
@@ -2450,7 +2451,7 @@ void PlayerControlPreview::DrawJoystickDot(QPainter& p, const QPointF center,
 }
 
 void PlayerControlPreview::DrawRoundButton(QPainter& p, QPointF center,
-                                           const Input::ButtonStatus& pressed, float width,
+                                           const Common::Input::ButtonStatus& pressed, float width,
                                            float height, Direction direction, float radius) {
     p.setBrush(button_color);
     if (pressed.value) {
@@ -2476,13 +2477,15 @@ void PlayerControlPreview::DrawRoundButton(QPainter& p, QPointF center,
     p.drawRoundedRect(rect, radius, radius);
 }
 void PlayerControlPreview::DrawMinusButton(QPainter& p, const QPointF center,
-                                           const Input::ButtonStatus& pressed, int button_size) {
+                                           const Common::Input::ButtonStatus& pressed,
+                                           int button_size) {
     p.setPen(colors.outline);
     p.setBrush(pressed.value ? colors.highlight : colors.button);
     DrawRectangle(p, center, button_size, button_size / 3.0f);
 }
 void PlayerControlPreview::DrawPlusButton(QPainter& p, const QPointF center,
-                                          const Input::ButtonStatus& pressed, int button_size) {
+                                          const Common::Input::ButtonStatus& pressed,
+                                          int button_size) {
     // Draw outer line
     p.setPen(colors.outline);
     p.setBrush(pressed.value ? colors.highlight : colors.button);
@@ -2499,7 +2502,7 @@ void PlayerControlPreview::DrawPlusButton(QPainter& p, const QPointF center,
 }
 
 void PlayerControlPreview::DrawGCButtonX(QPainter& p, const QPointF center,
-                                         const Input::ButtonStatus& pressed) {
+                                         const Common::Input::ButtonStatus& pressed) {
     std::array<QPointF, gc_button_x.size() / 2> button_x;
 
     for (std::size_t point = 0; point < gc_button_x.size() / 2; ++point) {
@@ -2512,7 +2515,7 @@ void PlayerControlPreview::DrawGCButtonX(QPainter& p, const QPointF center,
 }
 
 void PlayerControlPreview::DrawGCButtonY(QPainter& p, const QPointF center,
-                                         const Input::ButtonStatus& pressed) {
+                                         const Common::Input::ButtonStatus& pressed) {
     std::array<QPointF, gc_button_y.size() / 2> button_x;
 
     for (std::size_t point = 0; point < gc_button_y.size() / 2; ++point) {
@@ -2525,7 +2528,7 @@ void PlayerControlPreview::DrawGCButtonY(QPainter& p, const QPointF center,
 }
 
 void PlayerControlPreview::DrawGCButtonZ(QPainter& p, const QPointF center,
-                                         const Input::ButtonStatus& pressed) {
+                                         const Common::Input::ButtonStatus& pressed) {
     std::array<QPointF, gc_button_z.size() / 2> button_x;
 
     for (std::size_t point = 0; point < gc_button_z.size() / 2; ++point) {
@@ -2539,7 +2542,8 @@ void PlayerControlPreview::DrawGCButtonZ(QPainter& p, const QPointF center,
 }
 
 void PlayerControlPreview::DrawCircleButton(QPainter& p, const QPointF center,
-                                            const Input::ButtonStatus& pressed, float button_size) {
+                                            const Common::Input::ButtonStatus& pressed,
+                                            float button_size) {
     p.setBrush(button_color);
     if (pressed.value) {
         p.setBrush(colors.highlight);
@@ -2571,7 +2575,7 @@ void PlayerControlPreview::DrawArrowButtonOutline(QPainter& p, const QPointF cen
 
 void PlayerControlPreview::DrawArrowButton(QPainter& p, const QPointF center,
                                            const Direction direction,
-                                           const Input::ButtonStatus& pressed, float size) {
+                                           const Common::Input::ButtonStatus& pressed, float size) {
     std::array<QPointF, up_arrow_button.size() / 2> arrow_button;
     QPoint offset;
 
@@ -2628,7 +2632,7 @@ void PlayerControlPreview::DrawArrowButton(QPainter& p, const QPointF center,
 
 void PlayerControlPreview::DrawTriggerButton(QPainter& p, const QPointF center,
                                              const Direction direction,
-                                             const Input::ButtonStatus& pressed) {
+                                             const Common::Input::ButtonStatus& pressed) {
     std::array<QPointF, trigger_button.size() / 2> qtrigger_button;
 
     for (std::size_t point = 0; point < trigger_button.size() / 2; ++point) {
@@ -2655,8 +2659,9 @@ void PlayerControlPreview::DrawTriggerButton(QPainter& p, const QPointF center,
     DrawPolygon(p, qtrigger_button);
 }
 
-void PlayerControlPreview::DrawBattery(QPainter& p, QPointF center, Input::BatteryLevel battery) {
-    if (battery == Input::BatteryLevel::None) {
+void PlayerControlPreview::DrawBattery(QPainter& p, QPointF center,
+                                       Common::Input::BatteryLevel battery) {
+    if (battery == Common::Input::BatteryLevel::None) {
         return;
     }
     p.setPen(colors.outline);
@@ -2665,29 +2670,29 @@ void PlayerControlPreview::DrawBattery(QPainter& p, QPointF center, Input::Batte
     p.drawRect(center.x() + 56, center.y() + 6, 3, 8);
     p.setBrush(colors.deadzone);
     switch (battery) {
-    case Input::BatteryLevel::Charging:
+    case Common::Input::BatteryLevel::Charging:
         p.setBrush(colors.indicator2);
         p.drawText(center + QPoint(2, 14), tr("Charging"));
         break;
-    case Input::BatteryLevel::Full:
+    case Common::Input::BatteryLevel::Full:
         p.drawRect(center.x() + 42, center.y(), 14, 20);
         p.drawRect(center.x() + 28, center.y(), 14, 20);
         p.drawRect(center.x() + 14, center.y(), 14, 20);
         p.drawRect(center.x(), center.y(), 14, 20);
         break;
-    case Input::BatteryLevel::Medium:
+    case Common::Input::BatteryLevel::Medium:
         p.drawRect(center.x() + 28, center.y(), 14, 20);
         p.drawRect(center.x() + 14, center.y(), 14, 20);
         p.drawRect(center.x(), center.y(), 14, 20);
         break;
-    case Input::BatteryLevel::Low:
+    case Common::Input::BatteryLevel::Low:
         p.drawRect(center.x() + 14, center.y(), 14, 20);
         p.drawRect(center.x(), center.y(), 14, 20);
         break;
-    case Input::BatteryLevel::Critical:
+    case Common::Input::BatteryLevel::Critical:
         p.drawRect(center.x(), center.y(), 14, 20);
         break;
-    case Input::BatteryLevel::Empty:
+    case Common::Input::BatteryLevel::Empty:
         p.drawRect(center.x(), center.y(), 5, 20);
         break;
     default:
diff --git a/src/yuzu/configuration/configure_input_player_widget.h b/src/yuzu/configuration/configure_input_player_widget.h
index 333c3fc56b..430e4f4f4c 100644
--- a/src/yuzu/configuration/configure_input_player_widget.h
+++ b/src/yuzu/configuration/configure_input_player_widget.h
@@ -115,66 +115,75 @@ private:
     void DrawGCBody(QPainter& p, QPointF center);
 
     // Draw triggers functions
-    void DrawProTriggers(QPainter& p, QPointF center, const Input::ButtonStatus& left_pressed,
-                         const Input::ButtonStatus& right_pressed);
-    void DrawGCTriggers(QPainter& p, QPointF center, Input::TriggerStatus left_trigger,
-                        Input::TriggerStatus right_trigger);
-    void DrawHandheldTriggers(QPainter& p, QPointF center, const Input::ButtonStatus& left_pressed,
-                              const Input::ButtonStatus& right_pressed);
-    void DrawDualTriggers(QPainter& p, QPointF center, const Input::ButtonStatus& left_pressed,
-                          const Input::ButtonStatus& right_pressed);
+    void DrawProTriggers(QPainter& p, QPointF center,
+                         const Common::Input::ButtonStatus& left_pressed,
+                         const Common::Input::ButtonStatus& right_pressed);
+    void DrawGCTriggers(QPainter& p, QPointF center, Common::Input::TriggerStatus left_trigger,
+                        Common::Input::TriggerStatus right_trigger);
+    void DrawHandheldTriggers(QPainter& p, QPointF center,
+                              const Common::Input::ButtonStatus& left_pressed,
+                              const Common::Input::ButtonStatus& right_pressed);
+    void DrawDualTriggers(QPainter& p, QPointF center,
+                          const Common::Input::ButtonStatus& left_pressed,
+                          const Common::Input::ButtonStatus& right_pressed);
     void DrawDualTriggersTopView(QPainter& p, QPointF center,
-                                 const Input::ButtonStatus& left_pressed,
-                                 const Input::ButtonStatus& right_pressed);
+                                 const Common::Input::ButtonStatus& left_pressed,
+                                 const Common::Input::ButtonStatus& right_pressed);
     void DrawDualZTriggersTopView(QPainter& p, QPointF center,
-                                  const Input::ButtonStatus& left_pressed,
-                                  const Input::ButtonStatus& right_pressed);
-    void DrawLeftTriggers(QPainter& p, QPointF center, const Input::ButtonStatus& left_pressed);
-    void DrawLeftZTriggers(QPainter& p, QPointF center, const Input::ButtonStatus& left_pressed);
+                                  const Common::Input::ButtonStatus& left_pressed,
+                                  const Common::Input::ButtonStatus& right_pressed);
+    void DrawLeftTriggers(QPainter& p, QPointF center,
+                          const Common::Input::ButtonStatus& left_pressed);
+    void DrawLeftZTriggers(QPainter& p, QPointF center,
+                           const Common::Input::ButtonStatus& left_pressed);
     void DrawLeftTriggersTopView(QPainter& p, QPointF center,
-                                 const Input::ButtonStatus& left_pressed);
+                                 const Common::Input::ButtonStatus& left_pressed);
     void DrawLeftZTriggersTopView(QPainter& p, QPointF center,
-                                  const Input::ButtonStatus& left_pressed);
-    void DrawRightTriggers(QPainter& p, QPointF center, const Input::ButtonStatus& right_pressed);
-    void DrawRightZTriggers(QPainter& p, QPointF center, const Input::ButtonStatus& right_pressed);
+                                  const Common::Input::ButtonStatus& left_pressed);
+    void DrawRightTriggers(QPainter& p, QPointF center,
+                           const Common::Input::ButtonStatus& right_pressed);
+    void DrawRightZTriggers(QPainter& p, QPointF center,
+                            const Common::Input::ButtonStatus& right_pressed);
     void DrawRightTriggersTopView(QPainter& p, QPointF center,
-                                  const Input::ButtonStatus& right_pressed);
+                                  const Common::Input::ButtonStatus& right_pressed);
     void DrawRightZTriggersTopView(QPainter& p, QPointF center,
-                                   const Input::ButtonStatus& right_pressed);
+                                   const Common::Input::ButtonStatus& right_pressed);
 
     // Draw joystick functions
-    void DrawJoystick(QPainter& p, QPointF center, float size, const Input::ButtonStatus& pressed);
+    void DrawJoystick(QPainter& p, QPointF center, float size,
+                      const Common::Input::ButtonStatus& pressed);
     void DrawJoystickSideview(QPainter& p, QPointF center, float angle, float size,
-                              const Input::ButtonStatus& pressed);
+                              const Common::Input::ButtonStatus& pressed);
     void DrawRawJoystick(QPainter& p, QPointF center_left, QPointF center_right);
     void DrawJoystickProperties(QPainter& p, QPointF center,
-                                const Input::AnalogProperties& properties);
-    void DrawJoystickDot(QPainter& p, QPointF center, const Input::StickStatus& stick, bool raw);
+                                const Common::Input::AnalogProperties& properties);
+    void DrawJoystickDot(QPainter& p, QPointF center, const Common::Input::StickStatus& stick,
+                         bool raw);
     void DrawProJoystick(QPainter& p, QPointF center, QPointF offset, float scalar,
-                         const Input::ButtonStatus& pressed);
-    void DrawGCJoystick(QPainter& p, QPointF center, const Input::ButtonStatus& pressed);
+                         const Common::Input::ButtonStatus& pressed);
+    void DrawGCJoystick(QPainter& p, QPointF center, const Common::Input::ButtonStatus& pressed);
 
     // Draw button functions
-    void DrawCircleButton(QPainter& p, QPointF center, const Input::ButtonStatus& pressed,
+    void DrawCircleButton(QPainter& p, QPointF center, const Common::Input::ButtonStatus& pressed,
                           float button_size);
-    void DrawRoundButton(QPainter& p, QPointF center, const Input::ButtonStatus& pressed,
+    void DrawRoundButton(QPainter& p, QPointF center, const Common::Input::ButtonStatus& pressed,
                          float width, float height, Direction direction = Direction::None,
                          float radius = 2);
-    void DrawMinusButton(QPainter& p, QPointF center, const Input::ButtonStatus& pressed,
+    void DrawMinusButton(QPainter& p, QPointF center, const Common::Input::ButtonStatus& pressed,
                          int button_size);
-    void DrawPlusButton(QPainter& p, QPointF center, const Input::ButtonStatus& pressed,
+    void DrawPlusButton(QPainter& p, QPointF center, const Common::Input::ButtonStatus& pressed,
                         int button_size);
-    void DrawGCButtonX(QPainter& p, QPointF center, const Input::ButtonStatus& pressed);
-    void DrawGCButtonY(QPainter& p, QPointF center, const Input::ButtonStatus& pressed);
-    void DrawGCButtonZ(QPainter& p, QPointF center, const Input::ButtonStatus& pressed);
+    void DrawGCButtonX(QPainter& p, QPointF center, const Common::Input::ButtonStatus& pressed);
+    void DrawGCButtonY(QPainter& p, QPointF center, const Common::Input::ButtonStatus& pressed);
+    void DrawGCButtonZ(QPainter& p, QPointF center, const Common::Input::ButtonStatus& pressed);
     void DrawArrowButtonOutline(QPainter& p, const QPointF center, float size = 1.0f);
     void DrawArrowButton(QPainter& p, QPointF center, Direction direction,
-                         const Input::ButtonStatus& pressed, float size = 1.0f);
+                         const Common::Input::ButtonStatus& pressed, float size = 1.0f);
     void DrawTriggerButton(QPainter& p, QPointF center, Direction direction,
-                           const Input::ButtonStatus& pressed);
+                           const Common::Input::ButtonStatus& pressed);
 
     // Draw battery functions
-    void DrawBattery(QPainter& p, QPointF center, Input::BatteryLevel battery);
+    void DrawBattery(QPainter& p, QPointF center, Common::Input::BatteryLevel battery);
 
     // Draw icon functions
     void DrawSymbol(QPainter& p, QPointF center, Symbol symbol, float icon_size);
-- 
cgit v1.2.3


From ebfe40dec88d6ab94295cf1fd8be87b6a3a2123c Mon Sep 17 00:00:00 2001
From: german77 <juangerman-13@hotmail.com>
Date: Sat, 13 Nov 2021 23:25:45 -0600
Subject: core/hid: Improve accuracy of the keyboard implementation

---
 src/common/settings_input.h                       |  35 +-
 src/core/hid/emulated_devices.cpp                 |   3 +-
 src/core/hid/hid_types.h                          | 398 +++++++++++++++-------
 src/core/hle/service/hid/controllers/keyboard.cpp |   1 +
 src/core/hle/service/hid/hid.cpp                  |  35 +-
 src/core/hle/service/hid/hid.h                    |   2 +
 src/input_common/drivers/keyboard.cpp             |  53 ++-
 src/input_common/drivers/keyboard.h               |   7 +
 src/input_common/main.cpp                         |   9 +
 src/input_common/main.h                           |   3 +
 src/yuzu/bootmanager.cpp                          | 276 ++++++++++++++-
 src/yuzu/bootmanager.h                            |   6 +
 src/yuzu/configuration/config.cpp                 | 167 +--------
 13 files changed, 682 insertions(+), 313 deletions(-)

(limited to 'src/input_common/main.cpp')

diff --git a/src/common/settings_input.h b/src/common/settings_input.h
index 2c0eb31d39..a2982fca46 100644
--- a/src/common/settings_input.h
+++ b/src/common/settings_input.h
@@ -129,7 +129,6 @@ extern const std::array<const char*, NumMouseButtons> mapping;
 namespace NativeKeyboard {
 enum Keys {
     None,
-    Error,
 
     A = 4,
     B,
@@ -167,22 +166,22 @@ enum Keys {
     N8,
     N9,
     N0,
-    Enter,
+    Return,
     Escape,
     Backspace,
     Tab,
     Space,
     Minus,
-    Equal,
-    LeftBrace,
-    RightBrace,
-    Backslash,
+    Plus,
+    OpenBracket,
+    CloseBracket,
+    Pipe,
     Tilde,
     Semicolon,
-    Apostrophe,
-    Grave,
+    Quote,
+    Backquote,
     Comma,
-    Dot,
+    Period,
     Slash,
     CapsLockKey,
 
@@ -199,7 +198,7 @@ enum Keys {
     F11,
     F12,
 
-    SystemRequest,
+    PrintScreen,
     ScrollLockKey,
     Pause,
     Insert,
@@ -268,8 +267,18 @@ enum Keys {
     ScrollLockActive,
     KPComma,
 
-    KPLeftParenthesis,
-    KPRightParenthesis,
+    Ro = 0x87,
+    KatakanaHiragana,
+    Yen,
+    Henkan,
+    Muhenkan,
+    NumPadCommaPc98,
+
+    HangulEnglish = 0x90,
+    Hanja,
+    KatakanaKey,
+    HiraganaKey,
+    ZenkakuHankaku,
 
     LeftControlKey = 0xE0,
     LeftShiftKey,
@@ -318,6 +327,8 @@ enum Modifiers {
     CapsLock,
     ScrollLock,
     NumLock,
+    Katakana,
+    Hiragana,
 
     NumKeyboardMods,
 };
diff --git a/src/core/hid/emulated_devices.cpp b/src/core/hid/emulated_devices.cpp
index e97470240e..0d840a0035 100644
--- a/src/core/hid/emulated_devices.cpp
+++ b/src/core/hid/emulated_devices.cpp
@@ -170,13 +170,14 @@ void EmulatedDevices::SetKeyboardButton(Common::Input::CallbackStatus callback,
         return;
     }
 
+    // Index should be converted from NativeKeyboard to KeyboardKeyIndex
     UpdateKey(index, current_status.value);
 
     TriggerOnChange(DeviceTriggerType::Keyboard);
 }
 
 void EmulatedDevices::UpdateKey(std::size_t key_index, bool status) {
-    constexpr u8 KEYS_PER_BYTE = 8;
+    constexpr std::size_t KEYS_PER_BYTE = 8;
     auto& entry = device_status.keyboard_state.key[key_index / KEYS_PER_BYTE];
     const u8 mask = static_cast<u8>(1 << (key_index % KEYS_PER_BYTE));
     if (status) {
diff --git a/src/core/hid/hid_types.h b/src/core/hid/hid_types.h
index 41bc65ce20..af95f3aff9 100644
--- a/src/core/hid/hid_types.h
+++ b/src/core/hid/hid_types.h
@@ -12,6 +12,195 @@
 
 namespace Core::HID {
 
+enum class DeviceIndex : u8 {
+    Left = 0,
+    Right = 1,
+    None = 2,
+    MaxDeviceIndex = 3,
+};
+
+// This is nn::hid::NpadButton
+enum class NpadButton : u64 {
+    None = 0,
+    A = 1U << 0,
+    B = 1U << 1,
+    X = 1U << 2,
+    Y = 1U << 3,
+    StickL = 1U << 4,
+    StickR = 1U << 5,
+    L = 1U << 6,
+    R = 1U << 7,
+    ZL = 1U << 8,
+    ZR = 1U << 9,
+    Plus = 1U << 10,
+    Minus = 1U << 11,
+
+    Left = 1U << 12,
+    Up = 1U << 13,
+    Right = 1U << 14,
+    Down = 1U << 15,
+
+    StickLLeft = 1U << 16,
+    StickLUp = 1U << 17,
+    StickLRight = 1U << 18,
+    StickLDown = 1U << 19,
+
+    StickRLeft = 1U << 20,
+    StickRUp = 1U << 21,
+    StickRRight = 1U << 22,
+    StickRDown = 1U << 23,
+
+    LeftSL = 1U << 24,
+    LeftSR = 1U << 25,
+
+    RightSL = 1U << 26,
+    RightSR = 1U << 27,
+
+    Palma = 1U << 28,
+    Verification = 1U << 29,
+    HandheldLeftB = 1U << 30,
+    LagonCLeft = 1U << 31,
+    LagonCUp = 1ULL << 32,
+    LagonCRight = 1ULL << 33,
+    LagonCDown = 1ULL << 34,
+};
+DECLARE_ENUM_FLAG_OPERATORS(NpadButton);
+
+enum class KeyboardKeyIndex : u32 {
+    A = 4,
+    B = 5,
+    C = 6,
+    D = 7,
+    E = 8,
+    F = 9,
+    G = 10,
+    H = 11,
+    I = 12,
+    J = 13,
+    K = 14,
+    L = 15,
+    M = 16,
+    N = 17,
+    O = 18,
+    P = 19,
+    Q = 20,
+    R = 21,
+    S = 22,
+    T = 23,
+    U = 24,
+    V = 25,
+    W = 26,
+    X = 27,
+    Y = 28,
+    Z = 29,
+    D1 = 30,
+    D2 = 31,
+    D3 = 32,
+    D4 = 33,
+    D5 = 34,
+    D6 = 35,
+    D7 = 36,
+    D8 = 37,
+    D9 = 38,
+    D0 = 39,
+    Return = 40,
+    Escape = 41,
+    Backspace = 42,
+    Tab = 43,
+    Space = 44,
+    Minus = 45,
+    Plus = 46,
+    OpenBracket = 47,
+    CloseBracket = 48,
+    Pipe = 49,
+    Tilde = 50,
+    Semicolon = 51,
+    Quote = 52,
+    Backquote = 53,
+    Comma = 54,
+    Period = 55,
+    Slash = 56,
+    CapsLock = 57,
+    F1 = 58,
+    F2 = 59,
+    F3 = 60,
+    F4 = 61,
+    F5 = 62,
+    F6 = 63,
+    F7 = 64,
+    F8 = 65,
+    F9 = 66,
+    F10 = 67,
+    F11 = 68,
+    F12 = 69,
+    PrintScreen = 70,
+    ScrollLock = 71,
+    Pause = 72,
+    Insert = 73,
+    Home = 74,
+    PageUp = 75,
+    Delete = 76,
+    End = 77,
+    PageDown = 78,
+    RightArrow = 79,
+    LeftArrow = 80,
+    DownArrow = 81,
+    UpArrow = 82,
+    NumLock = 83,
+    NumPadDivide = 84,
+    NumPadMultiply = 85,
+    NumPadSubtract = 86,
+    NumPadAdd = 87,
+    NumPadEnter = 88,
+    NumPad1 = 89,
+    NumPad2 = 90,
+    NumPad3 = 91,
+    NumPad4 = 92,
+    NumPad5 = 93,
+    NumPad6 = 94,
+    NumPad7 = 95,
+    NumPad8 = 96,
+    NumPad9 = 97,
+    NumPad0 = 98,
+    NumPadDot = 99,
+    Backslash = 100,
+    Application = 101,
+    Power = 102,
+    NumPadEquals = 103,
+    F13 = 104,
+    F14 = 105,
+    F15 = 106,
+    F16 = 107,
+    F17 = 108,
+    F18 = 109,
+    F19 = 110,
+    F20 = 111,
+    F21 = 112,
+    F22 = 113,
+    F23 = 114,
+    F24 = 115,
+    NumPadComma = 133,
+    Ro = 135,
+    KatakanaHiragana = 136,
+    Yen = 137,
+    Henkan = 138,
+    Muhenkan = 139,
+    NumPadCommaPc98 = 140,
+    HangulEnglish = 144,
+    Hanja = 145,
+    Katakana = 146,
+    Hiragana = 147,
+    ZenkakuHankaku = 148,
+    LeftControl = 224,
+    LeftShift = 225,
+    LeftAlt = 226,
+    LeftGui = 227,
+    RightControl = 228,
+    RightShift = 229,
+    RightAlt = 230,
+    RightGui = 231,
+};
+
 // This is nn::hid::NpadIdType
 enum class NpadIdType : u32 {
     Player1 = 0x0,
@@ -28,62 +217,6 @@ enum class NpadIdType : u32 {
     Invalid = 0xFFFFFFFF,
 };
 
-/// Converts a NpadIdType to an array index.
-constexpr size_t NpadIdTypeToIndex(NpadIdType npad_id_type) {
-    switch (npad_id_type) {
-    case NpadIdType::Player1:
-        return 0;
-    case NpadIdType::Player2:
-        return 1;
-    case NpadIdType::Player3:
-        return 2;
-    case NpadIdType::Player4:
-        return 3;
-    case NpadIdType::Player5:
-        return 4;
-    case NpadIdType::Player6:
-        return 5;
-    case NpadIdType::Player7:
-        return 6;
-    case NpadIdType::Player8:
-        return 7;
-    case NpadIdType::Handheld:
-        return 8;
-    case NpadIdType::Other:
-        return 9;
-    default:
-        return 0;
-    }
-}
-
-/// Converts an array index to a NpadIdType
-constexpr NpadIdType IndexToNpadIdType(size_t index) {
-    switch (index) {
-    case 0:
-        return NpadIdType::Player1;
-    case 1:
-        return NpadIdType::Player2;
-    case 2:
-        return NpadIdType::Player3;
-    case 3:
-        return NpadIdType::Player4;
-    case 4:
-        return NpadIdType::Player5;
-    case 5:
-        return NpadIdType::Player6;
-    case 6:
-        return NpadIdType::Player7;
-    case 7:
-        return NpadIdType::Player8;
-    case 8:
-        return NpadIdType::Handheld;
-    case 9:
-        return NpadIdType::Other;
-    default:
-        return NpadIdType::Invalid;
-    }
-}
-
 // This is nn::hid::NpadStyleIndex
 enum class NpadStyleIndex : u8 {
     None = 0,
@@ -124,6 +257,27 @@ enum class NpadStyleSet : u32 {
 };
 static_assert(sizeof(NpadStyleSet) == 4, "NpadStyleSet is an invalid size");
 
+// This is nn::hid::VibrationDevicePosition
+enum class VibrationDevicePosition : u32 {
+    None = 0,
+    Left = 1,
+    Right = 2,
+};
+
+// This is nn::hid::VibrationDeviceType
+enum class VibrationDeviceType : u32 {
+    Unknown = 0,
+    LinearResonantActuator = 1,
+    GcErm = 2,
+};
+
+// This is nn::hid::VibrationGcErmCommand
+enum class VibrationGcErmCommand : u64 {
+    Stop = 0,
+    Start = 1,
+    StopHard = 2,
+};
+
 // This is nn::hid::NpadStyleTag
 struct NpadStyleTag {
     union {
@@ -220,53 +374,6 @@ struct LedPattern {
     };
 };
 
-// This is nn::hid::NpadButton
-enum class NpadButton : u64 {
-    None = 0,
-    A = 1U << 0,
-    B = 1U << 1,
-    X = 1U << 2,
-    Y = 1U << 3,
-    StickL = 1U << 4,
-    StickR = 1U << 5,
-    L = 1U << 6,
-    R = 1U << 7,
-    ZL = 1U << 8,
-    ZR = 1U << 9,
-    Plus = 1U << 10,
-    Minus = 1U << 11,
-
-    Left = 1U << 12,
-    Up = 1U << 13,
-    Right = 1U << 14,
-    Down = 1U << 15,
-
-    StickLLeft = 1U << 16,
-    StickLUp = 1U << 17,
-    StickLRight = 1U << 18,
-    StickLDown = 1U << 19,
-
-    StickRLeft = 1U << 20,
-    StickRUp = 1U << 21,
-    StickRRight = 1U << 22,
-    StickRDown = 1U << 23,
-
-    LeftSL = 1U << 24,
-    LeftSR = 1U << 25,
-
-    RightSL = 1U << 26,
-    RightSR = 1U << 27,
-
-    Palma = 1U << 28,
-    Verification = 1U << 29,
-    HandheldLeftB = 1U << 30,
-    LagonCLeft = 1U << 31,
-    LagonCUp = 1ULL << 32,
-    LagonCRight = 1ULL << 33,
-    LagonCDown = 1ULL << 34,
-};
-DECLARE_ENUM_FLAG_OPERATORS(NpadButton);
-
 struct NpadButtonState {
     union {
         NpadButton raw{};
@@ -342,13 +449,6 @@ struct DebugPadButton {
 };
 static_assert(sizeof(DebugPadButton) == 0x4, "DebugPadButton is an invalid size");
 
-enum class DeviceIndex : u8 {
-    Left = 0,
-    Right = 1,
-    None = 2,
-    MaxDeviceIndex = 3,
-};
-
 // This is nn::hid::ConsoleSixAxisSensorHandle
 struct ConsoleSixAxisSensorHandle {
     u8 unknown_1;
@@ -383,20 +483,6 @@ struct VibrationDeviceHandle {
 };
 static_assert(sizeof(VibrationDeviceHandle) == 4, "SixAxisSensorHandle is an invalid size");
 
-// This is nn::hid::VibrationDeviceType
-enum class VibrationDeviceType : u32 {
-    Unknown = 0,
-    LinearResonantActuator = 1,
-    GcErm = 2,
-};
-
-// This is nn::hid::VibrationDevicePosition
-enum class VibrationDevicePosition : u32 {
-    None = 0,
-    Left = 1,
-    Right = 2,
-};
-
 // This is nn::hid::VibrationValue
 struct VibrationValue {
     f32 low_amplitude;
@@ -406,13 +492,6 @@ struct VibrationValue {
 };
 static_assert(sizeof(VibrationValue) == 0x10, "VibrationValue has incorrect size.");
 
-// This is nn::hid::VibrationGcErmCommand
-enum class VibrationGcErmCommand : u64 {
-    Stop = 0,
-    Start = 1,
-    StopHard = 2,
-};
-
 // This is nn::hid::VibrationDeviceInfo
 struct VibrationDeviceInfo {
     VibrationDeviceType type{};
@@ -482,4 +561,61 @@ struct MouseState {
     MouseAttribute attribute;
 };
 static_assert(sizeof(MouseState) == 0x28, "MouseState is an invalid size");
+
+/// Converts a NpadIdType to an array index.
+constexpr size_t NpadIdTypeToIndex(NpadIdType npad_id_type) {
+    switch (npad_id_type) {
+    case NpadIdType::Player1:
+        return 0;
+    case NpadIdType::Player2:
+        return 1;
+    case NpadIdType::Player3:
+        return 2;
+    case NpadIdType::Player4:
+        return 3;
+    case NpadIdType::Player5:
+        return 4;
+    case NpadIdType::Player6:
+        return 5;
+    case NpadIdType::Player7:
+        return 6;
+    case NpadIdType::Player8:
+        return 7;
+    case NpadIdType::Handheld:
+        return 8;
+    case NpadIdType::Other:
+        return 9;
+    default:
+        return 0;
+    }
+}
+
+/// Converts an array index to a NpadIdType
+constexpr NpadIdType IndexToNpadIdType(size_t index) {
+    switch (index) {
+    case 0:
+        return NpadIdType::Player1;
+    case 1:
+        return NpadIdType::Player2;
+    case 2:
+        return NpadIdType::Player3;
+    case 3:
+        return NpadIdType::Player4;
+    case 4:
+        return NpadIdType::Player5;
+    case 5:
+        return NpadIdType::Player6;
+    case 6:
+        return NpadIdType::Player7;
+    case 7:
+        return NpadIdType::Player8;
+    case 8:
+        return NpadIdType::Handheld;
+    case 9:
+        return NpadIdType::Other;
+    default:
+        return NpadIdType::Invalid;
+    }
+}
+
 } // namespace Core::HID
diff --git a/src/core/hle/service/hid/controllers/keyboard.cpp b/src/core/hle/service/hid/controllers/keyboard.cpp
index d6505dbc51..0ef8af0e69 100644
--- a/src/core/hle/service/hid/controllers/keyboard.cpp
+++ b/src/core/hle/service/hid/controllers/keyboard.cpp
@@ -42,6 +42,7 @@ void Controller_Keyboard::OnUpdate(const Core::Timing::CoreTiming& core_timing,
 
         next_state.key = keyboard_state;
         next_state.modifier = keyboard_modifier_state;
+        // This is always enabled on HW. Check what it actually does
         next_state.modifier.unknown.Assign(1);
     }
 
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 496b55d0ef..e740b43314 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -35,8 +35,9 @@ namespace Service::HID {
 
 // Updating period for each HID device.
 // Period time is obtained by measuring the number of samples in a second on HW using a homebrew
-constexpr auto pad_update_ns = std::chrono::nanoseconds{4 * 1000 * 1000};    // (4ms, 250Hz)
-constexpr auto motion_update_ns = std::chrono::nanoseconds{5 * 1000 * 1000}; // (5ms, 200Hz)
+constexpr auto pad_update_ns = std::chrono::nanoseconds{4 * 1000 * 1000};      // (4ms, 250Hz)
+constexpr auto keyboard_update_ns = std::chrono::nanoseconds{8 * 1000 * 1000}; // (8ms, 125Hz)
+constexpr auto motion_update_ns = std::chrono::nanoseconds{5 * 1000 * 1000};   // (5ms, 200Hz)
 constexpr std::size_t SHARED_MEMORY_SIZE = 0x40000;
 
 IAppletResource::IAppletResource(Core::System& system_,
@@ -78,14 +79,21 @@ IAppletResource::IAppletResource(Core::System& system_,
             const auto guard = LockService();
             UpdateControllers(user_data, ns_late);
         });
+    keyboard_update_event = Core::Timing::CreateEvent(
+        "HID::UpdatekeyboardCallback",
+        [this](std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
+            const auto guard = LockService();
+            UpdateKeyboard(user_data, ns_late);
+        });
     motion_update_event = Core::Timing::CreateEvent(
-        "HID::MotionPadCallback",
+        "HID::UpdateMotionCallback",
         [this](std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
             const auto guard = LockService();
             UpdateMotion(user_data, ns_late);
         });
 
     system.CoreTiming().ScheduleEvent(pad_update_ns, pad_update_event);
+    system.CoreTiming().ScheduleEvent(keyboard_update_ns, keyboard_update_event);
     system.CoreTiming().ScheduleEvent(motion_update_ns, motion_update_event);
 
     system.HIDCore().ReloadInputDevices();
@@ -101,6 +109,7 @@ void IAppletResource::DeactivateController(HidController controller) {
 
 IAppletResource::~IAppletResource() {
     system.CoreTiming().UnscheduleEvent(pad_update_event, 0);
+    system.CoreTiming().UnscheduleEvent(keyboard_update_event, 0);
     system.CoreTiming().UnscheduleEvent(motion_update_event, 0);
 }
 
@@ -117,18 +126,36 @@ void IAppletResource::UpdateControllers(std::uintptr_t user_data,
     auto& core_timing = system.CoreTiming();
 
     for (const auto& controller : controllers) {
+        // Keyboard has it's own update event
+        if (controller == controllers[static_cast<size_t>(HidController::Keyboard)]) {
+            continue;
+        }
         controller->OnUpdate(core_timing, system.Kernel().GetHidSharedMem().GetPointer(),
                              SHARED_MEMORY_SIZE);
     }
 
     // If ns_late is higher than the update rate ignore the delay
-    if (ns_late > motion_update_ns) {
+    if (ns_late > pad_update_ns) {
         ns_late = {};
     }
 
     core_timing.ScheduleEvent(pad_update_ns - ns_late, pad_update_event);
 }
 
+void IAppletResource::UpdateKeyboard(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
+    auto& core_timing = system.CoreTiming();
+
+    controllers[static_cast<size_t>(HidController::Keyboard)]->OnUpdate(
+        core_timing, system.Kernel().GetHidSharedMem().GetPointer(), SHARED_MEMORY_SIZE);
+
+    // If ns_late is higher than the update rate ignore the delay
+    if (ns_late > keyboard_update_ns) {
+        ns_late = {};
+    }
+
+    core_timing.ScheduleEvent(keyboard_update_ns - ns_late, keyboard_update_event);
+}
+
 void IAppletResource::UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
     auto& core_timing = system.CoreTiming();
 
diff --git a/src/core/hle/service/hid/hid.h b/src/core/hle/service/hid/hid.h
index 973e6a8acf..bbad165f89 100644
--- a/src/core/hle/service/hid/hid.h
+++ b/src/core/hle/service/hid/hid.h
@@ -70,11 +70,13 @@ private:
 
     void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx);
     void UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
+    void UpdateKeyboard(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
     void UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
 
     KernelHelpers::ServiceContext& service_context;
 
     std::shared_ptr<Core::Timing::EventType> pad_update_event;
+    std::shared_ptr<Core::Timing::EventType> keyboard_update_event;
     std::shared_ptr<Core::Timing::EventType> motion_update_event;
 
     std::array<std::unique_ptr<ControllerBase>, static_cast<size_t>(HidController::MaxControllers)>
diff --git a/src/input_common/drivers/keyboard.cpp b/src/input_common/drivers/keyboard.cpp
index 549704e89a..328fe1ac16 100644
--- a/src/input_common/drivers/keyboard.cpp
+++ b/src/input_common/drivers/keyboard.cpp
@@ -3,26 +3,71 @@
 // Refer to the license.txt file included
 
 #include "common/param_package.h"
+#include "common/settings_input.h"
 #include "input_common/drivers/keyboard.h"
 
 namespace InputCommon {
 
-constexpr PadIdentifier identifier = {
+constexpr PadIdentifier key_identifier = {
     .guid = Common::UUID{Common::INVALID_UUID},
     .port = 0,
     .pad = 0,
 };
+constexpr PadIdentifier modifier_identifier = {
+    .guid = Common::UUID{Common::INVALID_UUID},
+    .port = 0,
+    .pad = 1,
+};
 
 Keyboard::Keyboard(const std::string& input_engine_) : InputEngine(input_engine_) {
-    PreSetController(identifier);
+    PreSetController(key_identifier);
+    PreSetController(modifier_identifier);
 }
 
 void Keyboard::PressKey(int key_code) {
-    SetButton(identifier, key_code, true);
+    SetButton(key_identifier, key_code, true);
 }
 
 void Keyboard::ReleaseKey(int key_code) {
-    SetButton(identifier, key_code, false);
+    SetButton(key_identifier, key_code, false);
+}
+
+void Keyboard::SetModifiers(int key_modifiers) {
+    for (int i = 0; i < 32; ++i) {
+        bool key_value = ((key_modifiers >> i) & 0x1) != 0;
+        SetButton(modifier_identifier, i, key_value);
+        // Use the modifier to press the key button equivalent
+        switch (i) {
+        case Settings::NativeKeyboard::LeftControl:
+            SetButton(key_identifier, Settings::NativeKeyboard::LeftControlKey, key_value);
+            break;
+        case Settings::NativeKeyboard::LeftShift:
+            SetButton(key_identifier, Settings::NativeKeyboard::LeftShiftKey, key_value);
+            break;
+        case Settings::NativeKeyboard::LeftAlt:
+            SetButton(key_identifier, Settings::NativeKeyboard::LeftAltKey, key_value);
+            break;
+        case Settings::NativeKeyboard::LeftMeta:
+            SetButton(key_identifier, Settings::NativeKeyboard::LeftMetaKey, key_value);
+            break;
+        case Settings::NativeKeyboard::RightControl:
+            SetButton(key_identifier, Settings::NativeKeyboard::RightControlKey, key_value);
+            break;
+        case Settings::NativeKeyboard::RightShift:
+            SetButton(key_identifier, Settings::NativeKeyboard::RightShiftKey, key_value);
+            break;
+        case Settings::NativeKeyboard::RightAlt:
+            SetButton(key_identifier, Settings::NativeKeyboard::RightAltKey, key_value);
+            break;
+        case Settings::NativeKeyboard::RightMeta:
+            SetButton(key_identifier, Settings::NativeKeyboard::RightMetaKey, key_value);
+            break;
+        default:
+            // Other modifier keys should be pressed with PressKey since they stay enabled until
+            // next press
+            break;
+        }
+    }
 }
 
 void Keyboard::ReleaseAllKeys() {
diff --git a/src/input_common/drivers/keyboard.h b/src/input_common/drivers/keyboard.h
index 46fe785764..2ab92fd6c2 100644
--- a/src/input_common/drivers/keyboard.h
+++ b/src/input_common/drivers/keyboard.h
@@ -28,6 +28,13 @@ public:
      */
     void ReleaseKey(int key_code);
 
+    /**
+     * Sets the status of all keyboard modifier keys
+     * @param key_modifiers the code of the key to release
+     */
+    void SetModifiers(int key_modifiers);
+
+    /// Sets all keys to the non pressed state
     void ReleaseAllKeys();
 
     /// Used for automapping features
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index df36a337c7..ae2518f53c 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -402,6 +402,15 @@ std::string GenerateKeyboardParam(int key_code) {
     return param.Serialize();
 }
 
+std::string GenerateModdifierKeyboardParam(int key_code) {
+    Common::ParamPackage param;
+    param.Set("engine", "keyboard");
+    param.Set("code", key_code);
+    param.Set("toggle", false);
+    param.Set("pad", 1);
+    return param.Serialize();
+}
+
 std::string GenerateAnalogParamFromKeys(int key_up, int key_down, int key_left, int key_right,
                                         int key_modifier, float modifier_scale) {
     Common::ParamPackage circle_pad_param{
diff --git a/src/input_common/main.h b/src/input_common/main.h
index a4a24d076e..9ea3954658 100644
--- a/src/input_common/main.h
+++ b/src/input_common/main.h
@@ -134,6 +134,9 @@ private:
 /// Generates a serialized param package for creating a keyboard button device.
 std::string GenerateKeyboardParam(int key_code);
 
+/// Generates a serialized param package for creating a moddifier keyboard button device.
+std::string GenerateModdifierKeyboardParam(int key_code);
+
 /// Generates a serialized param package for creating an analog device taking input from keyboard.
 std::string GenerateAnalogParamFromKeys(int key_up, int key_down, int key_left, int key_right,
                                         int key_modifier, float modifier_scale);
diff --git a/src/yuzu/bootmanager.cpp b/src/yuzu/bootmanager.cpp
index 3c5590a017..61513a5b41 100644
--- a/src/yuzu/bootmanager.cpp
+++ b/src/yuzu/bootmanager.cpp
@@ -392,15 +392,287 @@ void GRenderWindow::closeEvent(QCloseEvent* event) {
     QWidget::closeEvent(event);
 }
 
+int GRenderWindow::QtKeyToSwitchKey(Qt::Key qt_key) {
+    switch (qt_key) {
+    case Qt::Key_A:
+        return Settings::NativeKeyboard::A;
+    case Qt::Key_B:
+        return Settings::NativeKeyboard::B;
+    case Qt::Key_C:
+        return Settings::NativeKeyboard::C;
+    case Qt::Key_D:
+        return Settings::NativeKeyboard::D;
+    case Qt::Key_E:
+        return Settings::NativeKeyboard::E;
+    case Qt::Key_F:
+        return Settings::NativeKeyboard::F;
+    case Qt::Key_G:
+        return Settings::NativeKeyboard::G;
+    case Qt::Key_H:
+        return Settings::NativeKeyboard::H;
+    case Qt::Key_I:
+        return Settings::NativeKeyboard::I;
+    case Qt::Key_J:
+        return Settings::NativeKeyboard::J;
+    case Qt::Key_K:
+        return Settings::NativeKeyboard::K;
+    case Qt::Key_L:
+        return Settings::NativeKeyboard::L;
+    case Qt::Key_M:
+        return Settings::NativeKeyboard::M;
+    case Qt::Key_N:
+        return Settings::NativeKeyboard::N;
+    case Qt::Key_O:
+        return Settings::NativeKeyboard::O;
+    case Qt::Key_P:
+        return Settings::NativeKeyboard::P;
+    case Qt::Key_Q:
+        return Settings::NativeKeyboard::Q;
+    case Qt::Key_R:
+        return Settings::NativeKeyboard::R;
+    case Qt::Key_S:
+        return Settings::NativeKeyboard::S;
+    case Qt::Key_T:
+        return Settings::NativeKeyboard::T;
+    case Qt::Key_U:
+        return Settings::NativeKeyboard::U;
+    case Qt::Key_V:
+        return Settings::NativeKeyboard::V;
+    case Qt::Key_W:
+        return Settings::NativeKeyboard::W;
+    case Qt::Key_X:
+        return Settings::NativeKeyboard::X;
+    case Qt::Key_Y:
+        return Settings::NativeKeyboard::Y;
+    case Qt::Key_Z:
+        return Settings::NativeKeyboard::Z;
+    case Qt::Key_1:
+        return Settings::NativeKeyboard::N1;
+    case Qt::Key_2:
+        return Settings::NativeKeyboard::N2;
+    case Qt::Key_3:
+        return Settings::NativeKeyboard::N3;
+    case Qt::Key_4:
+        return Settings::NativeKeyboard::N4;
+    case Qt::Key_5:
+        return Settings::NativeKeyboard::N5;
+    case Qt::Key_6:
+        return Settings::NativeKeyboard::N6;
+    case Qt::Key_7:
+        return Settings::NativeKeyboard::N7;
+    case Qt::Key_8:
+        return Settings::NativeKeyboard::N8;
+    case Qt::Key_9:
+        return Settings::NativeKeyboard::N9;
+    case Qt::Key_0:
+        return Settings::NativeKeyboard::N0;
+    case Qt::Key_Return:
+        return Settings::NativeKeyboard::Return;
+    case Qt::Key_Escape:
+        return Settings::NativeKeyboard::Escape;
+    case Qt::Key_Backspace:
+        return Settings::NativeKeyboard::Backspace;
+    case Qt::Key_Tab:
+        return Settings::NativeKeyboard::Tab;
+    case Qt::Key_Space:
+        return Settings::NativeKeyboard::Space;
+    case Qt::Key_Minus:
+        return Settings::NativeKeyboard::Minus;
+    case Qt::Key_Plus:
+    case Qt::Key_questiondown:
+        return Settings::NativeKeyboard::Plus;
+    case Qt::Key_BracketLeft:
+    case Qt::Key_BraceLeft:
+        return Settings::NativeKeyboard::OpenBracket;
+    case Qt::Key_BracketRight:
+    case Qt::Key_BraceRight:
+        return Settings::NativeKeyboard::CloseBracket;
+    case Qt::Key_Bar:
+        return Settings::NativeKeyboard::Pipe;
+    case Qt::Key_Dead_Tilde:
+        return Settings::NativeKeyboard::Tilde;
+    case Qt::Key_Ntilde:
+    case Qt::Key_Semicolon:
+        return Settings::NativeKeyboard::Semicolon;
+    case Qt::Key_Apostrophe:
+        return Settings::NativeKeyboard::Quote;
+    case Qt::Key_Dead_Grave:
+        return Settings::NativeKeyboard::Backquote;
+    case Qt::Key_Comma:
+        return Settings::NativeKeyboard::Comma;
+    case Qt::Key_Period:
+        return Settings::NativeKeyboard::Period;
+    case Qt::Key_Slash:
+        return Settings::NativeKeyboard::Slash;
+    case Qt::Key_CapsLock:
+        return Settings::NativeKeyboard::CapsLock;
+    case Qt::Key_F1:
+        return Settings::NativeKeyboard::F1;
+    case Qt::Key_F2:
+        return Settings::NativeKeyboard::F2;
+    case Qt::Key_F3:
+        return Settings::NativeKeyboard::F3;
+    case Qt::Key_F4:
+        return Settings::NativeKeyboard::F4;
+    case Qt::Key_F5:
+        return Settings::NativeKeyboard::F5;
+    case Qt::Key_F6:
+        return Settings::NativeKeyboard::F6;
+    case Qt::Key_F7:
+        return Settings::NativeKeyboard::F7;
+    case Qt::Key_F8:
+        return Settings::NativeKeyboard::F8;
+    case Qt::Key_F9:
+        return Settings::NativeKeyboard::F9;
+    case Qt::Key_F10:
+        return Settings::NativeKeyboard::F10;
+    case Qt::Key_F11:
+        return Settings::NativeKeyboard::F11;
+    case Qt::Key_F12:
+        return Settings::NativeKeyboard::F12;
+    case Qt::Key_Print:
+        return Settings::NativeKeyboard::PrintScreen;
+    case Qt::Key_ScrollLock:
+        return Settings::NativeKeyboard::ScrollLock;
+    case Qt::Key_Pause:
+        return Settings::NativeKeyboard::Pause;
+    case Qt::Key_Insert:
+        return Settings::NativeKeyboard::Insert;
+    case Qt::Key_Home:
+        return Settings::NativeKeyboard::Home;
+    case Qt::Key_PageUp:
+        return Settings::NativeKeyboard::PageUp;
+    case Qt::Key_Delete:
+        return Settings::NativeKeyboard::Delete;
+    case Qt::Key_End:
+        return Settings::NativeKeyboard::End;
+    case Qt::Key_PageDown:
+        return Settings::NativeKeyboard::PageDown;
+    case Qt::Key_Right:
+        return Settings::NativeKeyboard::Right;
+    case Qt::Key_Left:
+        return Settings::NativeKeyboard::Left;
+    case Qt::Key_Down:
+        return Settings::NativeKeyboard::Down;
+    case Qt::Key_Up:
+        return Settings::NativeKeyboard::Up;
+    case Qt::Key_NumLock:
+        return Settings::NativeKeyboard::NumLock;
+    // Numpad keys are missing here
+    case Qt::Key_F13:
+        return Settings::NativeKeyboard::F13;
+    case Qt::Key_F14:
+        return Settings::NativeKeyboard::F14;
+    case Qt::Key_F15:
+        return Settings::NativeKeyboard::F15;
+    case Qt::Key_F16:
+        return Settings::NativeKeyboard::F16;
+    case Qt::Key_F17:
+        return Settings::NativeKeyboard::F17;
+    case Qt::Key_F18:
+        return Settings::NativeKeyboard::F18;
+    case Qt::Key_F19:
+        return Settings::NativeKeyboard::F19;
+    case Qt::Key_F20:
+        return Settings::NativeKeyboard::F20;
+    case Qt::Key_F21:
+        return Settings::NativeKeyboard::F21;
+    case Qt::Key_F22:
+        return Settings::NativeKeyboard::F22;
+    case Qt::Key_F23:
+        return Settings::NativeKeyboard::F23;
+    case Qt::Key_F24:
+        return Settings::NativeKeyboard::F24;
+    // case Qt:::
+    //    return Settings::NativeKeyboard::KPComma;
+    // case Qt:::
+    //    return Settings::NativeKeyboard::Ro;
+    case Qt::Key_Hiragana_Katakana:
+        return Settings::NativeKeyboard::KatakanaHiragana;
+    case Qt::Key_yen:
+        return Settings::NativeKeyboard::Yen;
+    case Qt::Key_Henkan:
+        return Settings::NativeKeyboard::Henkan;
+    case Qt::Key_Muhenkan:
+        return Settings::NativeKeyboard::Muhenkan;
+    // case Qt:::
+    //    return Settings::NativeKeyboard::NumPadCommaPc98;
+    case Qt::Key_Hangul:
+        return Settings::NativeKeyboard::HangulEnglish;
+    case Qt::Key_Hangul_Hanja:
+        return Settings::NativeKeyboard::Hanja;
+    case Qt::Key_Katakana:
+        return Settings::NativeKeyboard::KatakanaKey;
+    case Qt::Key_Hiragana:
+        return Settings::NativeKeyboard::HiraganaKey;
+    case Qt::Key_Zenkaku_Hankaku:
+        return Settings::NativeKeyboard::ZenkakuHankaku;
+    // Modifier keys are handled by the modifier property
+    default:
+        return 0;
+    }
+}
+
+int GRenderWindow::QtModifierToSwitchModdifier(quint32 qt_moddifiers) {
+    int moddifier = 0;
+    // The values are obtained through testing, Qt doesn't seem to provide a proper enum
+    if ((qt_moddifiers & 0x1) != 0) {
+        moddifier |= 1 << Settings::NativeKeyboard::LeftShift;
+    }
+    if ((qt_moddifiers & 0x2) != 0) {
+        moddifier |= 1 << Settings::NativeKeyboard::LeftControl;
+    }
+    if ((qt_moddifiers & 0x4) != 0) {
+        moddifier |= 1 << Settings::NativeKeyboard::LeftAlt;
+    }
+    if ((qt_moddifiers & 0x08) != 0) {
+        moddifier |= 1 << Settings::NativeKeyboard::LeftMeta;
+    }
+    if ((qt_moddifiers & 0x10) != 0) {
+        moddifier |= 1 << Settings::NativeKeyboard::RightShift;
+    }
+    if ((qt_moddifiers & 0x20) != 0) {
+        moddifier |= 1 << Settings::NativeKeyboard::RightControl;
+    }
+    if ((qt_moddifiers & 0x40) != 0) {
+        moddifier |= 1 << Settings::NativeKeyboard::RightAlt;
+    }
+    if ((qt_moddifiers & 0x80) != 0) {
+        moddifier |= 1 << Settings::NativeKeyboard::RightMeta;
+    }
+    if ((qt_moddifiers & 0x100) != 0) {
+        moddifier |= 1 << Settings::NativeKeyboard::CapsLock;
+    }
+    if ((qt_moddifiers & 0x200) != 0) {
+        moddifier |= 1 << Settings::NativeKeyboard::NumLock;
+    }
+    // Verify the last two keys
+    if ((qt_moddifiers & 0x400) != 0) {
+        moddifier |= 1 << Settings::NativeKeyboard::Katakana;
+    }
+    if ((qt_moddifiers & 0x800) != 0) {
+        moddifier |= 1 << Settings::NativeKeyboard::Hiragana;
+    }
+    return moddifier;
+}
+
 void GRenderWindow::keyPressEvent(QKeyEvent* event) {
     if (!event->isAutoRepeat()) {
-        input_subsystem->GetKeyboard()->PressKey(event->key());
+        const auto moddifier = QtModifierToSwitchModdifier(event->nativeModifiers());
+        // Replace event->key() with event->nativeVirtualKey() since the second one provides raw key
+        // buttons
+        const auto key = QtKeyToSwitchKey(Qt::Key(event->key()));
+        input_subsystem->GetKeyboard()->SetModifiers(moddifier);
+        input_subsystem->GetKeyboard()->PressKey(key);
     }
 }
 
 void GRenderWindow::keyReleaseEvent(QKeyEvent* event) {
     if (!event->isAutoRepeat()) {
-        input_subsystem->GetKeyboard()->ReleaseKey(event->key());
+        const auto moddifier = QtModifierToSwitchModdifier(event->nativeModifiers());
+        const auto key = QtKeyToSwitchKey(Qt::Key(event->key()));
+        input_subsystem->GetKeyboard()->SetModifiers(moddifier);
+        input_subsystem->GetKeyboard()->ReleaseKey(key);
     }
 }
 
diff --git a/src/yuzu/bootmanager.h b/src/yuzu/bootmanager.h
index 95594f81ca..c42d139beb 100644
--- a/src/yuzu/bootmanager.h
+++ b/src/yuzu/bootmanager.h
@@ -158,6 +158,12 @@ public:
 
     void resizeEvent(QResizeEvent* event) override;
 
+    /// Converts a Qt keybard key into NativeKeyboard key
+    static int QtKeyToSwitchKey(Qt::Key qt_keys);
+
+    /// Converts a Qt modifier keys into NativeKeyboard modifier keys
+    static int QtModifierToSwitchModdifier(quint32 qt_moddifiers);
+
     void keyPressEvent(QKeyEvent* event) override;
     void keyReleaseEvent(QKeyEvent* event) override;
 
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index 7669fe4748..ccf274895f 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -65,157 +65,6 @@ const std::array<int, Settings::NativeMouseButton::NumMouseButtons> Config::defa
         Qt::Key_BracketLeft, Qt::Key_BracketRight, Qt::Key_Apostrophe, Qt::Key_Minus, Qt::Key_Equal,
 };
 
-const std::array<int, Settings::NativeKeyboard::NumKeyboardKeys> Config::default_keyboard_keys = {
-    0,
-    0,
-    0,
-    0,
-    Qt::Key_A,
-    Qt::Key_B,
-    Qt::Key_C,
-    Qt::Key_D,
-    Qt::Key_E,
-    Qt::Key_F,
-    Qt::Key_G,
-    Qt::Key_H,
-    Qt::Key_I,
-    Qt::Key_J,
-    Qt::Key_K,
-    Qt::Key_L,
-    Qt::Key_M,
-    Qt::Key_N,
-    Qt::Key_O,
-    Qt::Key_P,
-    Qt::Key_Q,
-    Qt::Key_R,
-    Qt::Key_S,
-    Qt::Key_T,
-    Qt::Key_U,
-    Qt::Key_V,
-    Qt::Key_W,
-    Qt::Key_X,
-    Qt::Key_Y,
-    Qt::Key_Z,
-    Qt::Key_1,
-    Qt::Key_2,
-    Qt::Key_3,
-    Qt::Key_4,
-    Qt::Key_5,
-    Qt::Key_6,
-    Qt::Key_7,
-    Qt::Key_8,
-    Qt::Key_9,
-    Qt::Key_0,
-    Qt::Key_Enter,
-    Qt::Key_Escape,
-    Qt::Key_Backspace,
-    Qt::Key_Tab,
-    Qt::Key_Space,
-    Qt::Key_Minus,
-    Qt::Key_Equal,
-    Qt::Key_BracketLeft,
-    Qt::Key_BracketRight,
-    Qt::Key_Backslash,
-    Qt::Key_Dead_Tilde,
-    Qt::Key_Semicolon,
-    Qt::Key_Apostrophe,
-    Qt::Key_Dead_Grave,
-    Qt::Key_Comma,
-    Qt::Key_Period,
-    Qt::Key_Slash,
-    Qt::Key_CapsLock,
-
-    Qt::Key_F1,
-    Qt::Key_F2,
-    Qt::Key_F3,
-    Qt::Key_F4,
-    Qt::Key_F5,
-    Qt::Key_F6,
-    Qt::Key_F7,
-    Qt::Key_F8,
-    Qt::Key_F9,
-    Qt::Key_F10,
-    Qt::Key_F11,
-    Qt::Key_F12,
-
-    Qt::Key_SysReq,
-    Qt::Key_ScrollLock,
-    Qt::Key_Pause,
-    Qt::Key_Insert,
-    Qt::Key_Home,
-    Qt::Key_PageUp,
-    Qt::Key_Delete,
-    Qt::Key_End,
-    Qt::Key_PageDown,
-    Qt::Key_Right,
-    Qt::Key_Left,
-    Qt::Key_Down,
-    Qt::Key_Up,
-
-    Qt::Key_NumLock,
-    Qt::Key_Slash,
-    Qt::Key_Asterisk,
-    Qt::Key_Minus,
-    Qt::Key_Plus,
-    Qt::Key_Enter,
-    Qt::Key_1,
-    Qt::Key_2,
-    Qt::Key_3,
-    Qt::Key_4,
-    Qt::Key_5,
-    Qt::Key_6,
-    Qt::Key_7,
-    Qt::Key_8,
-    Qt::Key_9,
-    Qt::Key_0,
-    Qt::Key_Period,
-
-    0,
-    0,
-    Qt::Key_PowerOff,
-    Qt::Key_Equal,
-
-    Qt::Key_F13,
-    Qt::Key_F14,
-    Qt::Key_F15,
-    Qt::Key_F16,
-    Qt::Key_F17,
-    Qt::Key_F18,
-    Qt::Key_F19,
-    Qt::Key_F20,
-    Qt::Key_F21,
-    Qt::Key_F22,
-    Qt::Key_F23,
-    Qt::Key_F24,
-
-    Qt::Key_Open,
-    Qt::Key_Help,
-    Qt::Key_Menu,
-    0,
-    Qt::Key_Stop,
-    Qt::Key_AudioRepeat,
-    Qt::Key_Undo,
-    Qt::Key_Cut,
-    Qt::Key_Copy,
-    Qt::Key_Paste,
-    Qt::Key_Find,
-    Qt::Key_VolumeMute,
-    Qt::Key_VolumeUp,
-    Qt::Key_VolumeDown,
-    Qt::Key_CapsLock,
-    Qt::Key_NumLock,
-    Qt::Key_ScrollLock,
-    Qt::Key_Comma,
-
-    Qt::Key_ParenLeft,
-    Qt::Key_ParenRight,
-};
-
-const std::array<int, Settings::NativeKeyboard::NumKeyboardMods> Config::default_keyboard_mods = {
-    Qt::Key_Control, Qt::Key_Shift, Qt::Key_Alt,   Qt::Key_ApplicationLeft,
-    Qt::Key_Control, Qt::Key_Shift, Qt::Key_AltGr, Qt::Key_ApplicationRight,
-};
-
 // This shouldn't have anything except static initializers (no functions). So
 // QKeySequence(...).toString() is NOT ALLOWED HERE.
 // This must be in alphabetical order according to action name as it must have the same order as
@@ -496,14 +345,14 @@ void Config::ReadDebugValues() {
 void Config::ReadKeyboardValues() {
     ReadBasicSetting(Settings::values.keyboard_enabled);
 
-    std::transform(default_keyboard_keys.begin(), default_keyboard_keys.end(),
-                   Settings::values.keyboard_keys.begin(), InputCommon::GenerateKeyboardParam);
-    std::transform(default_keyboard_mods.begin(), default_keyboard_mods.end(),
-                   Settings::values.keyboard_keys.begin() +
-                       Settings::NativeKeyboard::LeftControlKey,
-                   InputCommon::GenerateKeyboardParam);
-    std::transform(default_keyboard_mods.begin(), default_keyboard_mods.end(),
-                   Settings::values.keyboard_mods.begin(), InputCommon::GenerateKeyboardParam);
+    for (std::size_t i = 0; i < Settings::values.keyboard_keys.size(); ++i) {
+        Settings::values.keyboard_keys[i] = InputCommon::GenerateKeyboardParam(static_cast<int>(i));
+    }
+
+    for (std::size_t i = 0; i < Settings::values.keyboard_mods.size(); ++i) {
+        Settings::values.keyboard_mods[i] =
+            InputCommon::GenerateModdifierKeyboardParam(static_cast<int>(i));
+    }
 }
 
 void Config::ReadMouseValues() {
-- 
cgit v1.2.3


From 6032358402601281432d97a041fbbd5a7b197888 Mon Sep 17 00:00:00 2001
From: german77 <juangerman-13@hotmail.com>
Date: Sun, 14 Nov 2021 10:45:07 -0600
Subject: input_common: Allow keyboard to be backwards compatible

---
 src/common/settings.h                 |  2 --
 src/core/hid/emulated_devices.cpp     | 28 +++++++++++++++----
 src/input_common/drivers/keyboard.cpp | 52 ++++++++++++++++++++++++++---------
 src/input_common/drivers/keyboard.h   | 14 +++++++++-
 src/input_common/input_mapping.cpp    | 25 +++++++++++++++++
 src/input_common/input_mapping.h      |  7 +++++
 src/input_common/main.cpp             |  9 ------
 src/input_common/main.h               |  3 --
 src/yuzu/bootmanager.cpp              | 14 ++++++----
 src/yuzu/configuration/config.cpp     |  9 ------
 10 files changed, 115 insertions(+), 48 deletions(-)

(limited to 'src/input_common/main.cpp')

diff --git a/src/common/settings.h b/src/common/settings.h
index b52d0d1d0f..ee9e0b5a15 100644
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -572,8 +572,6 @@ struct Values {
 
     BasicSetting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
     BasicSetting<bool> keyboard_enabled{false, "keyboard_enabled"};
-    KeyboardKeysRaw keyboard_keys;
-    KeyboardModsRaw keyboard_mods;
 
     BasicSetting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
     ButtonsRaw debug_pad_buttons;
diff --git a/src/core/hid/emulated_devices.cpp b/src/core/hid/emulated_devices.cpp
index 0d840a0035..45e0bd80db 100644
--- a/src/core/hid/emulated_devices.cpp
+++ b/src/core/hid/emulated_devices.cpp
@@ -29,13 +29,29 @@ void EmulatedDevices::ReloadInput() {
                    mouse_button_devices.begin(),
                    Common::Input::CreateDevice<Common::Input::InputDevice>);
 
-    std::transform(Settings::values.keyboard_keys.begin(), Settings::values.keyboard_keys.end(),
-                   keyboard_devices.begin(),
-                   Common::Input::CreateDeviceFromString<Common::Input::InputDevice>);
+    std::size_t key_index = 0;
+    for (auto& keyboard_device : keyboard_devices) {
+        // Keyboard keys are only mapped on port 1, pad 0
+        Common::ParamPackage keyboard_params;
+        keyboard_params.Set("engine", "keyboard");
+        keyboard_params.Set("button", static_cast<int>(key_index));
+        keyboard_params.Set("port", 1);
+        keyboard_params.Set("pad", 0);
+        keyboard_device = Common::Input::CreateDevice<Common::Input::InputDevice>(keyboard_params);
+        key_index++;
+    }
 
-    std::transform(Settings::values.keyboard_mods.begin(), Settings::values.keyboard_mods.end(),
-                   keyboard_modifier_devices.begin(),
-                   Common::Input::CreateDeviceFromString<Common::Input::InputDevice>);
+    key_index = 0;
+    for (auto& keyboard_device : keyboard_modifier_devices) {
+        // Keyboard moddifiers are only mapped on port 1, pad 1
+        Common::ParamPackage keyboard_params;
+        keyboard_params.Set("engine", "keyboard");
+        keyboard_params.Set("button", static_cast<int>(key_index));
+        keyboard_params.Set("port", 1);
+        keyboard_params.Set("pad", 1);
+        keyboard_device = Common::Input::CreateDevice<Common::Input::InputDevice>(keyboard_params);
+        key_index++;
+    }
 
     for (std::size_t index = 0; index < mouse_button_devices.size(); ++index) {
         if (!mouse_button_devices[index]) {
diff --git a/src/input_common/drivers/keyboard.cpp b/src/input_common/drivers/keyboard.cpp
index 328fe1ac16..23b0c0ccf3 100644
--- a/src/input_common/drivers/keyboard.cpp
+++ b/src/input_common/drivers/keyboard.cpp
@@ -13,15 +13,26 @@ constexpr PadIdentifier key_identifier = {
     .port = 0,
     .pad = 0,
 };
-constexpr PadIdentifier modifier_identifier = {
+constexpr PadIdentifier keyboard_key_identifier = {
     .guid = Common::UUID{Common::INVALID_UUID},
-    .port = 0,
+    .port = 1,
+    .pad = 0,
+};
+constexpr PadIdentifier keyboard_modifier_identifier = {
+    .guid = Common::UUID{Common::INVALID_UUID},
+    .port = 1,
     .pad = 1,
 };
 
 Keyboard::Keyboard(const std::string& input_engine_) : InputEngine(input_engine_) {
+    // Keyboard is broken into 3 diferent sets:
+    // key: Unfiltered intended for controllers.
+    // keyboard_key: Allows only Settings::NativeKeyboard::Keys intended for keyboard emulation.
+    // keyboard_modifier: Allows only Settings::NativeKeyboard::Modifiers intended for keyboard
+    // emulation.
     PreSetController(key_identifier);
-    PreSetController(modifier_identifier);
+    PreSetController(keyboard_key_identifier);
+    PreSetController(keyboard_modifier_identifier);
 }
 
 void Keyboard::PressKey(int key_code) {
@@ -32,35 +43,50 @@ void Keyboard::ReleaseKey(int key_code) {
     SetButton(key_identifier, key_code, false);
 }
 
-void Keyboard::SetModifiers(int key_modifiers) {
+void Keyboard::PressKeyboardKey(int key_index) {
+    if (key_index == Settings::NativeKeyboard::None) {
+        return;
+    }
+    SetButton(keyboard_key_identifier, key_index, true);
+}
+
+void Keyboard::ReleaseKeyboardKey(int key_index) {
+    if (key_index == Settings::NativeKeyboard::None) {
+        return;
+    }
+    SetButton(keyboard_key_identifier, key_index, false);
+}
+
+void Keyboard::SetKeyboardModifiers(int key_modifiers) {
     for (int i = 0; i < 32; ++i) {
         bool key_value = ((key_modifiers >> i) & 0x1) != 0;
-        SetButton(modifier_identifier, i, key_value);
+        SetButton(keyboard_modifier_identifier, i, key_value);
         // Use the modifier to press the key button equivalent
         switch (i) {
         case Settings::NativeKeyboard::LeftControl:
-            SetButton(key_identifier, Settings::NativeKeyboard::LeftControlKey, key_value);
+            SetButton(keyboard_key_identifier, Settings::NativeKeyboard::LeftControlKey, key_value);
             break;
         case Settings::NativeKeyboard::LeftShift:
-            SetButton(key_identifier, Settings::NativeKeyboard::LeftShiftKey, key_value);
+            SetButton(keyboard_key_identifier, Settings::NativeKeyboard::LeftShiftKey, key_value);
             break;
         case Settings::NativeKeyboard::LeftAlt:
-            SetButton(key_identifier, Settings::NativeKeyboard::LeftAltKey, key_value);
+            SetButton(keyboard_key_identifier, Settings::NativeKeyboard::LeftAltKey, key_value);
             break;
         case Settings::NativeKeyboard::LeftMeta:
-            SetButton(key_identifier, Settings::NativeKeyboard::LeftMetaKey, key_value);
+            SetButton(keyboard_key_identifier, Settings::NativeKeyboard::LeftMetaKey, key_value);
             break;
         case Settings::NativeKeyboard::RightControl:
-            SetButton(key_identifier, Settings::NativeKeyboard::RightControlKey, key_value);
+            SetButton(keyboard_key_identifier, Settings::NativeKeyboard::RightControlKey,
+                      key_value);
             break;
         case Settings::NativeKeyboard::RightShift:
-            SetButton(key_identifier, Settings::NativeKeyboard::RightShiftKey, key_value);
+            SetButton(keyboard_key_identifier, Settings::NativeKeyboard::RightShiftKey, key_value);
             break;
         case Settings::NativeKeyboard::RightAlt:
-            SetButton(key_identifier, Settings::NativeKeyboard::RightAltKey, key_value);
+            SetButton(keyboard_key_identifier, Settings::NativeKeyboard::RightAltKey, key_value);
             break;
         case Settings::NativeKeyboard::RightMeta:
-            SetButton(key_identifier, Settings::NativeKeyboard::RightMetaKey, key_value);
+            SetButton(keyboard_key_identifier, Settings::NativeKeyboard::RightMetaKey, key_value);
             break;
         default:
             // Other modifier keys should be pressed with PressKey since they stay enabled until
diff --git a/src/input_common/drivers/keyboard.h b/src/input_common/drivers/keyboard.h
index 2ab92fd6c2..ad123b1368 100644
--- a/src/input_common/drivers/keyboard.h
+++ b/src/input_common/drivers/keyboard.h
@@ -28,11 +28,23 @@ public:
      */
     void ReleaseKey(int key_code);
 
+    /**
+     * Sets the status of the keyboard key to pressed
+     * @param key_index index of the key to press
+     */
+    void PressKeyboardKey(int key_index);
+
+    /**
+     * Sets the status of the keyboard key to released
+     * @param key_index index of the key to release
+     */
+    void ReleaseKeyboardKey(int key_index);
+
     /**
      * Sets the status of all keyboard modifier keys
      * @param key_modifiers the code of the key to release
      */
-    void SetModifiers(int key_modifiers);
+    void SetKeyboardModifiers(int key_modifiers);
 
     /// Sets all keys to the non pressed state
     void ReleaseAllKeys();
diff --git a/src/input_common/input_mapping.cpp b/src/input_common/input_mapping.cpp
index 0ffc710281..0eeeff3725 100644
--- a/src/input_common/input_mapping.cpp
+++ b/src/input_common/input_mapping.cpp
@@ -28,6 +28,10 @@ void MappingFactory::RegisterInput(const MappingData& data) {
     if (!is_enabled) {
         return;
     }
+    if (!IsDriverValid(data)) {
+        return;
+    }
+
     switch (input_type) {
     case Polling::InputType::Button:
         RegisterButton(data);
@@ -168,4 +172,25 @@ void MappingFactory::RegisterMotion(const MappingData& data) {
     input_queue.Push(new_input);
 }
 
+bool MappingFactory::IsDriverValid(const MappingData& data) const {
+    // Only port 0 can be mapped on the keyboard
+    if (data.engine == "keyboard" && data.pad.port != 0) {
+        return false;
+    }
+    // The following drivers don't need to be mapped
+    if (data.engine == "tas") {
+        return false;
+    }
+    if (data.engine == "touch") {
+        return false;
+    }
+    if (data.engine == "touch_from_button") {
+        return false;
+    }
+    if (data.engine == "analog_from_button") {
+        return false;
+    }
+    return true;
+}
+
 } // namespace InputCommon
diff --git a/src/input_common/input_mapping.h b/src/input_common/input_mapping.h
index 2622dba70c..44eb8ad9a3 100644
--- a/src/input_common/input_mapping.h
+++ b/src/input_common/input_mapping.h
@@ -66,6 +66,13 @@ private:
      */
     void RegisterMotion(const MappingData& data);
 
+    /**
+     * Returns true if driver can be mapped
+     * @param "data": An struct containing all the information needed to create a proper
+     * ParamPackage
+     */
+    bool IsDriverValid(const MappingData& data) const;
+
     Common::SPSCQueue<Common::ParamPackage> input_queue;
     Polling::InputType input_type{Polling::InputType::None};
     bool is_enabled{};
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index ae2518f53c..df36a337c7 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -402,15 +402,6 @@ std::string GenerateKeyboardParam(int key_code) {
     return param.Serialize();
 }
 
-std::string GenerateModdifierKeyboardParam(int key_code) {
-    Common::ParamPackage param;
-    param.Set("engine", "keyboard");
-    param.Set("code", key_code);
-    param.Set("toggle", false);
-    param.Set("pad", 1);
-    return param.Serialize();
-}
-
 std::string GenerateAnalogParamFromKeys(int key_up, int key_down, int key_left, int key_right,
                                         int key_modifier, float modifier_scale) {
     Common::ParamPackage circle_pad_param{
diff --git a/src/input_common/main.h b/src/input_common/main.h
index 9ea3954658..a4a24d076e 100644
--- a/src/input_common/main.h
+++ b/src/input_common/main.h
@@ -134,9 +134,6 @@ private:
 /// Generates a serialized param package for creating a keyboard button device.
 std::string GenerateKeyboardParam(int key_code);
 
-/// Generates a serialized param package for creating a moddifier keyboard button device.
-std::string GenerateModdifierKeyboardParam(int key_code);
-
 /// Generates a serialized param package for creating an analog device taking input from keyboard.
 std::string GenerateAnalogParamFromKeys(int key_up, int key_down, int key_left, int key_right,
                                         int key_modifier, float modifier_scale);
diff --git a/src/yuzu/bootmanager.cpp b/src/yuzu/bootmanager.cpp
index 61513a5b41..9f4d1aac37 100644
--- a/src/yuzu/bootmanager.cpp
+++ b/src/yuzu/bootmanager.cpp
@@ -609,7 +609,7 @@ int GRenderWindow::QtKeyToSwitchKey(Qt::Key qt_key) {
         return Settings::NativeKeyboard::ZenkakuHankaku;
     // Modifier keys are handled by the modifier property
     default:
-        return 0;
+        return Settings::NativeKeyboard::None;
     }
 }
 
@@ -662,8 +662,10 @@ void GRenderWindow::keyPressEvent(QKeyEvent* event) {
         // Replace event->key() with event->nativeVirtualKey() since the second one provides raw key
         // buttons
         const auto key = QtKeyToSwitchKey(Qt::Key(event->key()));
-        input_subsystem->GetKeyboard()->SetModifiers(moddifier);
-        input_subsystem->GetKeyboard()->PressKey(key);
+        input_subsystem->GetKeyboard()->SetKeyboardModifiers(moddifier);
+        input_subsystem->GetKeyboard()->PressKeyboardKey(key);
+        // This is used for gamepads
+        input_subsystem->GetKeyboard()->PressKey(event->key());
     }
 }
 
@@ -671,8 +673,10 @@ void GRenderWindow::keyReleaseEvent(QKeyEvent* event) {
     if (!event->isAutoRepeat()) {
         const auto moddifier = QtModifierToSwitchModdifier(event->nativeModifiers());
         const auto key = QtKeyToSwitchKey(Qt::Key(event->key()));
-        input_subsystem->GetKeyboard()->SetModifiers(moddifier);
-        input_subsystem->GetKeyboard()->ReleaseKey(key);
+        input_subsystem->GetKeyboard()->SetKeyboardModifiers(moddifier);
+        input_subsystem->GetKeyboard()->ReleaseKeyboardKey(key);
+        // This is used for gamepads
+        input_subsystem->GetKeyboard()->ReleaseKey(event->key());
     }
 }
 
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index ccf274895f..5865359fe0 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -344,15 +344,6 @@ void Config::ReadDebugValues() {
 
 void Config::ReadKeyboardValues() {
     ReadBasicSetting(Settings::values.keyboard_enabled);
-
-    for (std::size_t i = 0; i < Settings::values.keyboard_keys.size(); ++i) {
-        Settings::values.keyboard_keys[i] = InputCommon::GenerateKeyboardParam(static_cast<int>(i));
-    }
-
-    for (std::size_t i = 0; i < Settings::values.keyboard_mods.size(); ++i) {
-        Settings::values.keyboard_mods[i] =
-            InputCommon::GenerateModdifierKeyboardParam(static_cast<int>(i));
-    }
 }
 
 void Config::ReadMouseValues() {
-- 
cgit v1.2.3


From b8b849dc2e80c683eae73d616e40420d4238e64d Mon Sep 17 00:00:00 2001
From: german77 <juangerman-13@hotmail.com>
Date: Sun, 21 Nov 2021 14:12:01 -0600
Subject: input_common: Move button names to the frontend

---
 src/common/input.h                                | 22 ++++++
 src/input_common/drivers/gc_adapter.cpp           | 36 +++++-----
 src/input_common/drivers/gc_adapter.h             |  4 +-
 src/input_common/drivers/mouse.cpp                |  9 ++-
 src/input_common/drivers/mouse.h                  |  2 +-
 src/input_common/drivers/sdl_driver.cpp           | 15 ++--
 src/input_common/drivers/sdl_driver.h             |  2 +-
 src/input_common/input_engine.h                   |  5 +-
 src/input_common/input_mapping.cpp                |  5 ++
 src/input_common/main.cpp                         | 17 ++---
 src/input_common/main.h                           |  9 ++-
 src/yuzu/configuration/configure_input_player.cpp | 86 ++++++++++++++++++++++-
 12 files changed, 160 insertions(+), 52 deletions(-)

(limited to 'src/input_common/main.cpp')

diff --git a/src/common/input.h b/src/common/input.h
index d997853c61..cc0cbd9b8a 100644
--- a/src/common/input.h
+++ b/src/common/input.h
@@ -175,6 +175,28 @@ struct LedStatus {
     bool led_4{};
 };
 
+// List of buttons to be passed to Qt that can be translated
+enum class ButtonNames {
+    Undefined,
+    Invalid,
+    // This will display the engine name instead of the button name
+    Engine,
+    // This will display the button by value instead of the button name
+    Value,
+    ButtonLeft,
+    ButtonRight,
+    ButtonDown,
+    ButtonUp,
+    TriggerZ,
+    TriggerR,
+    TriggerL,
+    ButtonA,
+    ButtonB,
+    ButtonX,
+    ButtonY,
+    ButtonStart,
+};
+
 // Callback data consisting of an input type and the equivalent data status
 struct CallbackStatus {
     InputType type{InputType::None};
diff --git a/src/input_common/drivers/gc_adapter.cpp b/src/input_common/drivers/gc_adapter.cpp
index a1b9b6d988..8b65742236 100644
--- a/src/input_common/drivers/gc_adapter.cpp
+++ b/src/input_common/drivers/gc_adapter.cpp
@@ -481,47 +481,47 @@ AnalogMapping GCAdapter::GetAnalogMappingForDevice(const Common::ParamPackage& p
     return mapping;
 }
 
-std::string GCAdapter::GetUIButtonName(const Common::ParamPackage& params) const {
+Common::Input::ButtonNames GCAdapter::GetUIButtonName(const Common::ParamPackage& params) const {
     PadButton button = static_cast<PadButton>(params.Get("button", 0));
     switch (button) {
     case PadButton::ButtonLeft:
-        return "left";
+        return Common::Input::ButtonNames::ButtonLeft;
     case PadButton::ButtonRight:
-        return "right";
+        return Common::Input::ButtonNames::ButtonRight;
     case PadButton::ButtonDown:
-        return "down";
+        return Common::Input::ButtonNames::ButtonDown;
     case PadButton::ButtonUp:
-        return "up";
+        return Common::Input::ButtonNames::ButtonUp;
     case PadButton::TriggerZ:
-        return "Z";
+        return Common::Input::ButtonNames::TriggerZ;
     case PadButton::TriggerR:
-        return "R";
+        return Common::Input::ButtonNames::TriggerR;
     case PadButton::TriggerL:
-        return "L";
+        return Common::Input::ButtonNames::TriggerL;
     case PadButton::ButtonA:
-        return "A";
+        return Common::Input::ButtonNames::ButtonA;
     case PadButton::ButtonB:
-        return "B";
+        return Common::Input::ButtonNames::ButtonB;
     case PadButton::ButtonX:
-        return "X";
+        return Common::Input::ButtonNames::ButtonX;
     case PadButton::ButtonY:
-        return "Y";
+        return Common::Input::ButtonNames::ButtonY;
     case PadButton::ButtonStart:
-        return "start";
+        return Common::Input::ButtonNames::ButtonStart;
     default:
-        return "Unknown GC";
+        return Common::Input::ButtonNames::Undefined;
     }
 }
 
-std::string GCAdapter::GetUIName(const Common::ParamPackage& params) const {
+Common::Input::ButtonNames GCAdapter::GetUIName(const Common::ParamPackage& params) const {
     if (params.Has("button")) {
-        return fmt::format("Button {}", GetUIButtonName(params));
+        return GetUIButtonName(params);
     }
     if (params.Has("axis")) {
-        return fmt::format("Axis {}", params.Get("axis", 0));
+        return Common::Input::ButtonNames::Value;
     }
 
-    return "Bad GC Adapter";
+    return Common::Input::ButtonNames::Invalid;
 }
 
 } // namespace InputCommon
diff --git a/src/input_common/drivers/gc_adapter.h b/src/input_common/drivers/gc_adapter.h
index 3e4747040f..8dc51d2e58 100644
--- a/src/input_common/drivers/gc_adapter.h
+++ b/src/input_common/drivers/gc_adapter.h
@@ -34,7 +34,7 @@ public:
     std::vector<Common::ParamPackage> GetInputDevices() const override;
     ButtonMapping GetButtonMappingForDevice(const Common::ParamPackage& params) override;
     AnalogMapping GetAnalogMappingForDevice(const Common::ParamPackage& params) override;
-    std::string GetUIName(const Common::ParamPackage& params) const override;
+    Common::Input::ButtonNames GetUIName(const Common::ParamPackage& params) const override;
 
 private:
     enum class PadButton {
@@ -112,7 +112,7 @@ private:
     /// Updates vibration state of all controllers
     void SendVibrations();
 
-    std::string GetUIButtonName(const Common::ParamPackage& params) const;
+    Common::Input::ButtonNames GetUIButtonName(const Common::ParamPackage& params) const;
 
     std::unique_ptr<LibUSBDeviceHandle> usb_adapter_handle;
     std::array<GCController, 4> pads;
diff --git a/src/input_common/drivers/mouse.cpp b/src/input_common/drivers/mouse.cpp
index 9a9a1987d5..752118e97e 100644
--- a/src/input_common/drivers/mouse.cpp
+++ b/src/input_common/drivers/mouse.cpp
@@ -171,12 +171,15 @@ AnalogMapping Mouse::GetAnalogMappingForDevice(
     return mapping;
 }
 
-std::string Mouse::GetUIName(const Common::ParamPackage& params) const {
+Common::Input::ButtonNames Mouse::GetUIName(const Common::ParamPackage& params) const {
     if (params.Has("button")) {
-        return fmt::format("Mouse {}", params.Get("button", 0));
+        return Common::Input::ButtonNames::Value;
+    }
+    if (params.Has("axis")) {
+        return Common::Input::ButtonNames::Value;
     }
 
-    return "Bad Mouse";
+    return Common::Input::ButtonNames::Invalid;
 }
 
 } // namespace InputCommon
diff --git a/src/input_common/drivers/mouse.h b/src/input_common/drivers/mouse.h
index 11dd76e140..4a1fd2fd96 100644
--- a/src/input_common/drivers/mouse.h
+++ b/src/input_common/drivers/mouse.h
@@ -63,7 +63,7 @@ public:
 
     std::vector<Common::ParamPackage> GetInputDevices() const override;
     AnalogMapping GetAnalogMappingForDevice(const Common::ParamPackage& params) override;
-    std::string GetUIName(const Common::ParamPackage& params) const override;
+    Common::Input::ButtonNames GetUIName(const Common::ParamPackage& params) const override;
 
 private:
     void UpdateThread(std::stop_token stop_token);
diff --git a/src/input_common/drivers/sdl_driver.cpp b/src/input_common/drivers/sdl_driver.cpp
index d5af6c09b4..90128b6cf6 100644
--- a/src/input_common/drivers/sdl_driver.cpp
+++ b/src/input_common/drivers/sdl_driver.cpp
@@ -869,26 +869,25 @@ MotionMapping SDLDriver::GetMotionMappingForDevice(const Common::ParamPackage& p
     return mapping;
 }
 
-std::string SDLDriver::GetUIName(const Common::ParamPackage& params) const {
+Common::Input::ButtonNames 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));
+        return Common::Input::ButtonNames::Value;
     }
     if (params.Has("hat")) {
-        return fmt::format("Hat {}", params.Get("direction", ""));
+        return Common::Input::ButtonNames::Value;
     }
     if (params.Has("axis")) {
-        return fmt::format("Axis {}", params.Get("axis", ""));
+        return Common::Input::ButtonNames::Value;
     }
     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", ""));
+        return Common::Input::ButtonNames::Value;
     }
     if (params.Has("motion")) {
-        return "SDL motion";
+        return Common::Input::ButtonNames::Engine;
     }
 
-    return "Bad SDL";
+    return Common::Input::ButtonNames::Invalid;
 }
 
 std::string SDLDriver::GetHatButtonName(u8 direction_value) const {
diff --git a/src/input_common/drivers/sdl_driver.h b/src/input_common/drivers/sdl_driver.h
index 3faaca9842..d03ff4b84f 100644
--- a/src/input_common/drivers/sdl_driver.h
+++ b/src/input_common/drivers/sdl_driver.h
@@ -53,7 +53,7 @@ public:
     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;
+    Common::Input::ButtonNames GetUIName(const Common::ParamPackage& params) const override;
 
     std::string GetHatButtonName(u8 direction_value) const override;
     u8 GetHatButtonId(const std::string& direction_name) const override;
diff --git a/src/input_common/input_engine.h b/src/input_common/input_engine.h
index c621686e54..02272b3f87 100644
--- a/src/input_common/input_engine.h
+++ b/src/input_common/input_engine.h
@@ -161,8 +161,9 @@ public:
     };
 
     /// Retrieves the name of the given input.
-    virtual std::string GetUIName([[maybe_unused]] const Common::ParamPackage& params) const {
-        return GetEngineName();
+    virtual Common::Input::ButtonNames GetUIName(
+        [[maybe_unused]] const Common::ParamPackage& params) const {
+        return Common::Input::ButtonNames::Engine;
     };
 
     /// Retrieves the index number of the given hat button direction
diff --git a/src/input_common/input_mapping.cpp b/src/input_common/input_mapping.cpp
index 0eeeff3725..c5218f2cb7 100644
--- a/src/input_common/input_mapping.cpp
+++ b/src/input_common/input_mapping.cpp
@@ -61,6 +61,7 @@ void MappingFactory::RegisterButton(const MappingData& data) {
     }
     new_input.Set("port", static_cast<int>(data.pad.port));
     new_input.Set("pad", static_cast<int>(data.pad.pad));
+
     switch (data.type) {
     case EngineInputType::Button:
         // Workaround for old compatibility
@@ -75,6 +76,10 @@ void MappingFactory::RegisterButton(const MappingData& data) {
         new_input.Set("direction", data.hat_name);
         break;
     case EngineInputType::Analog:
+        // Ignore mouse axis when mapping buttons
+        if (data.engine == "mouse") {
+            return;
+        }
         new_input.Set("axis", data.index);
         new_input.Set("threshold", 0.5f);
         break;
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index df36a337c7..39e4935dc1 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -205,9 +205,9 @@ struct InputSubsystem::Impl {
         return {};
     }
 
-    std::string GetButtonName(const Common::ParamPackage& params) const {
+    Common::Input::ButtonNames GetButtonName(const Common::ParamPackage& params) const {
         if (!params.Has("engine") || params.Get("engine", "") == "any") {
-            return "Unknown";
+            return Common::Input::ButtonNames::Undefined;
         }
         const std::string engine = params.Get("engine", "");
         if (engine == mouse->GetEngineName()) {
@@ -227,7 +227,7 @@ struct InputSubsystem::Impl {
             return sdl->GetUIName(params);
         }
 #endif
-        return "Bad engine";
+        return Common::Input::ButtonNames::Invalid;
     }
 
     bool IsController(const Common::ParamPackage& params) {
@@ -361,15 +361,8 @@ MotionMapping InputSubsystem::GetMotionMappingForDevice(const Common::ParamPacka
     return impl->GetMotionMappingForDevice(device);
 }
 
-std::string InputSubsystem::GetButtonName(const Common::ParamPackage& params) const {
-    const std::string toggle = params.Get("toggle", false) ? "~" : "";
-    const std::string inverted = params.Get("inverted", false) ? "!" : "";
-    const std::string button_name = impl->GetButtonName(params);
-    std::string axis_direction = "";
-    if (params.Has("axis")) {
-        axis_direction = params.Get("invert", "+");
-    }
-    return fmt::format("{}{}{}{}", toggle, inverted, button_name, axis_direction);
+Common::Input::ButtonNames InputSubsystem::GetButtonName(const Common::ParamPackage& params) const {
+    return impl->GetButtonName(params);
 }
 
 bool InputSubsystem::IsController(const Common::ParamPackage& params) const {
diff --git a/src/input_common/main.h b/src/input_common/main.h
index a4a24d076e..c6f97f6918 100644
--- a/src/input_common/main.h
+++ b/src/input_common/main.h
@@ -13,6 +13,10 @@ namespace Common {
 class ParamPackage;
 }
 
+namespace Common::Input {
+enum class ButtonNames;
+}
+
 namespace Settings::NativeAnalog {
 enum Values : int;
 }
@@ -108,8 +112,9 @@ public:
     /// Retrieves the motion mappings for the given device.
     [[nodiscard]] MotionMapping GetMotionMappingForDevice(const Common::ParamPackage& device) const;
 
-    /// Returns a string contaning the name of the button from the input engine.
-    [[nodiscard]] std::string GetButtonName(const Common::ParamPackage& params) const;
+    /// Returns an enum contaning the name to be displayed from the input engine.
+    [[nodiscard]] Common::Input::ButtonNames GetButtonName(
+        const Common::ParamPackage& params) const;
 
     /// Returns true if device is a controller.
     [[nodiscard]] bool IsController(const Common::ParamPackage& params) const;
diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp
index 0254ea6fe1..6219a09a84 100644
--- a/src/yuzu/configuration/configure_input_player.cpp
+++ b/src/yuzu/configuration/configure_input_player.cpp
@@ -52,6 +52,37 @@ QString GetKeyName(int key_code) {
     }
 }
 
+QString GetButtonName(Common::Input::ButtonNames button_name) {
+    switch (button_name) {
+    case Common::Input::ButtonNames::ButtonLeft:
+        return QObject::tr("Left");
+    case Common::Input::ButtonNames::ButtonRight:
+        return QObject::tr("Right");
+    case Common::Input::ButtonNames::ButtonDown:
+        return QObject::tr("Down");
+    case Common::Input::ButtonNames::ButtonUp:
+        return QObject::tr("Up");
+    case Common::Input::ButtonNames::TriggerZ:
+        return QObject::tr("Z");
+    case Common::Input::ButtonNames::TriggerR:
+        return QObject::tr("R");
+    case Common::Input::ButtonNames::TriggerL:
+        return QObject::tr("L");
+    case Common::Input::ButtonNames::ButtonA:
+        return QObject::tr("A");
+    case Common::Input::ButtonNames::ButtonB:
+        return QObject::tr("B");
+    case Common::Input::ButtonNames::ButtonX:
+        return QObject::tr("X");
+    case Common::Input::ButtonNames::ButtonY:
+        return QObject::tr("Y");
+    case Common::Input::ButtonNames::ButtonStart:
+        return QObject::tr("Start");
+    default:
+        return QObject::tr("[undefined]");
+    }
+}
+
 void SetAnalogParam(const Common::ParamPackage& input_param, Common::ParamPackage& analog_param,
                     const std::string& button_name) {
     // The poller returned a complete axis, so set all the buttons
@@ -75,15 +106,64 @@ QString ConfigureInputPlayer::ButtonToText(const Common::ParamPackage& param) {
         return QObject::tr("[not set]");
     }
 
+    const QString toggle = QString::fromStdString(param.Get("toggle", false) ? "~" : "");
+    const QString inverted = QString::fromStdString(param.Get("inverted", false) ? "!" : "");
+    const auto common_button_name = input_subsystem->GetButtonName(param);
+
     // Retrieve the names from Qt
     if (param.Get("engine", "") == "keyboard") {
         const QString button_str = GetKeyName(param.Get("code", 0));
-        const QString toggle = QString::fromStdString(param.Get("toggle", false) ? "~" : "");
         return QObject::tr("%1%2").arg(toggle, button_str);
     }
 
-    std::string button_name = input_subsystem->GetButtonName(param);
-    return QString::fromStdString(button_name);
+    if (common_button_name == Common::Input::ButtonNames::Invalid) {
+        return QObject::tr("[invalid]");
+    }
+
+    if (common_button_name == Common::Input::ButtonNames::Engine) {
+        return QString::fromStdString(param.Get("engine", ""));
+    }
+
+    if (common_button_name == Common::Input::ButtonNames::Value) {
+        if (param.Has("hat")) {
+            const QString hat = QString::fromStdString(param.Get("direction", ""));
+            return QObject::tr("%1%2Hat %3").arg(toggle, inverted, hat);
+        }
+        if (param.Has("axis")) {
+            const QString axis = QString::fromStdString(param.Get("axis", ""));
+            return QObject::tr("%1%2Axis %3").arg(toggle, inverted, axis);
+        }
+        if (param.Has("axis_x") && param.Has("axis_y") && param.Has("axis_z")) {
+            const QString axis_x = QString::fromStdString(param.Get("axis_x", ""));
+            const QString axis_y = QString::fromStdString(param.Get("axis_y", ""));
+            const QString axis_z = QString::fromStdString(param.Get("axis_z", ""));
+            return QObject::tr("%1%2Axis %3,%4,%5").arg(toggle, inverted, axis_x, axis_y, axis_z);
+        }
+        if (param.Has("motion")) {
+            const QString motion = QString::fromStdString(param.Get("motion", ""));
+            return QObject::tr("%1%2Motion %3").arg(toggle, inverted, motion);
+        }
+        if (param.Has("button")) {
+            const QString button = QString::fromStdString(param.Get("button", ""));
+            return QObject::tr("%1%2Button %3").arg(toggle, inverted, button);
+        }
+    }
+
+    QString button_name = GetButtonName(common_button_name);
+    if (param.Has("hat")) {
+        return QObject::tr("%1%2Hat %3").arg(toggle, inverted, button_name);
+    }
+    if (param.Has("axis")) {
+        return QObject::tr("%1%2Axis %3").arg(toggle, inverted, button_name);
+    }
+    if (param.Has("motion")) {
+        return QObject::tr("%1%2Axis %3").arg(toggle, inverted, button_name);
+    }
+    if (param.Has("button")) {
+        return QObject::tr("%1%2Button %3").arg(toggle, inverted, button_name);
+    }
+
+    return QObject::tr("[unknown]");
 }
 
 QString ConfigureInputPlayer::AnalogToText(const Common::ParamPackage& param,
-- 
cgit v1.2.3


From 7b56b2cab69aff46013a921c041de1ace999507d Mon Sep 17 00:00:00 2001
From: Narr the Reg <juangerman-13@hotmail.com>
Date: Fri, 26 Nov 2021 15:45:37 -0600
Subject: input_common: Fully implement UDP controllers

---
 src/common/input.h                                 |  14 ++
 src/common/settings.h                              |   1 +
 src/core/hid/emulated_console.cpp                  |   6 +-
 src/input_common/drivers/udp_client.cpp            | 206 ++++++++++++++++++++-
 src/input_common/drivers/udp_client.h              |  56 ++++++
 src/input_common/helpers/udp_protocol.h            |  75 +++++---
 src/input_common/input_mapping.cpp                 |   6 +
 src/input_common/main.cpp                          |  26 ++-
 src/yuzu/configuration/config.cpp                  |   2 +
 .../configuration/configure_input_advanced.cpp     |   2 +
 src/yuzu/configuration/configure_input_advanced.ui |  19 +-
 src/yuzu/configuration/configure_input_player.cpp  |  24 +++
 12 files changed, 397 insertions(+), 40 deletions(-)

(limited to 'src/input_common/main.cpp')

diff --git a/src/common/input.h b/src/common/input.h
index cc0cbd9b8a..eaee0bdeaf 100644
--- a/src/common/input.h
+++ b/src/common/input.h
@@ -195,6 +195,20 @@ enum class ButtonNames {
     ButtonX,
     ButtonY,
     ButtonStart,
+
+    // DS4 button names
+    L1,
+    L2,
+    L3,
+    R1,
+    R2,
+    R3,
+    Circle,
+    Cross,
+    Square,
+    Triangle,
+    Share,
+    Options,
 };
 
 // Callback data consisting of an input type and the equivalent data status
diff --git a/src/common/settings.h b/src/common/settings.h
index d7410fa9b2..e4e049f670 100644
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -560,6 +560,7 @@ struct Values {
 
     Setting<bool> motion_enabled{true, "motion_enabled"};
     BasicSetting<std::string> udp_input_servers{"127.0.0.1:26760", "udp_input_servers"};
+    BasicSetting<bool> enable_udp_controller{false, "enable_udp_controller"};
 
     BasicSetting<bool> pause_tas_on_load{true, "pause_tas_on_load"};
     BasicSetting<bool> tas_enable{false, "tas_enable"};
diff --git a/src/core/hid/emulated_console.cpp b/src/core/hid/emulated_console.cpp
index b224932dc5..80db8e9c6d 100644
--- a/src/core/hid/emulated_console.cpp
+++ b/src/core/hid/emulated_console.cpp
@@ -30,8 +30,10 @@ void EmulatedConsole::SetTouchParams() {
     }
     touch_params[index++] = Common::ParamPackage{"engine:touch,axis_x:0,axis_y:1,button:0"};
     touch_params[index++] = Common::ParamPackage{"engine:touch,axis_x:2,axis_y:3,button:1"};
-    touch_params[index++] = Common::ParamPackage{"engine:cemuhookudp,axis_x:0,axis_y:1,button:0"};
-    touch_params[index++] = Common::ParamPackage{"engine:cemuhookudp,axis_x:2,axis_y:3,button:1"};
+    touch_params[index++] =
+        Common::ParamPackage{"engine:cemuhookudp,axis_x:17,axis_y:18,button:65536"};
+    touch_params[index++] =
+        Common::ParamPackage{"engine:cemuhookudp,axis_x:19,axis_y:20,button:131072"};
 
     const auto button_index =
         static_cast<u64>(Settings::values.touch_from_button_map_index.GetValue());
diff --git a/src/input_common/drivers/udp_client.cpp b/src/input_common/drivers/udp_client.cpp
index 7cab707da5..fdee0f2d53 100644
--- a/src/input_common/drivers/udp_client.cpp
+++ b/src/input_common/drivers/udp_client.cpp
@@ -103,7 +103,7 @@ private:
 
         // Send a request for getting pad data for the pad
         const Request::PadData pad_data{
-            Request::PadData::Flags::AllPorts,
+            Request::RegisterFlags::AllPads,
             0,
             EMPTY_MAC_ADDRESS,
         };
@@ -247,7 +247,12 @@ void UDPClient::OnPadData(Response::PadData data, std::size_t client) {
 
     for (std::size_t id = 0; id < data.touch.size(); ++id) {
         const auto touch_pad = data.touch[id];
-        const int touch_id = static_cast<int>(client * 2 + id);
+        const auto touch_axis_x_id =
+            static_cast<int>(id == 0 ? PadAxes::Touch1X : PadAxes::Touch2X);
+        const auto touch_axis_y_id =
+            static_cast<int>(id == 0 ? PadAxes::Touch1Y : PadAxes::Touch2Y);
+        const auto touch_button_id =
+            static_cast<int>(id == 0 ? PadButton::Touch1 : PadButton::touch2);
 
         // TODO: Use custom calibration per device
         const Common::ParamPackage touch_param(Settings::values.touch_device.GetValue());
@@ -264,14 +269,35 @@ void UDPClient::OnPadData(Response::PadData data, std::size_t client) {
             static_cast<f32>(max_y - min_y);
 
         if (touch_pad.is_active) {
-            SetAxis(identifier, touch_id * 2, x);
-            SetAxis(identifier, touch_id * 2 + 1, y);
-            SetButton(identifier, touch_id, true);
+            SetAxis(identifier, touch_axis_x_id, x);
+            SetAxis(identifier, touch_axis_y_id, y);
+            SetButton(identifier, touch_button_id, true);
             continue;
         }
-        SetAxis(identifier, touch_id * 2, 0);
-        SetAxis(identifier, touch_id * 2 + 1, 0);
-        SetButton(identifier, touch_id, false);
+        SetAxis(identifier, touch_axis_x_id, 0);
+        SetAxis(identifier, touch_axis_y_id, 0);
+        SetButton(identifier, touch_button_id, false);
+    }
+
+    SetAxis(identifier, static_cast<int>(PadAxes::LeftStickX),
+            (data.left_stick_x - 127.0f) / 127.0f);
+    SetAxis(identifier, static_cast<int>(PadAxes::LeftStickY),
+            (data.left_stick_y - 127.0f) / 127.0f);
+    SetAxis(identifier, static_cast<int>(PadAxes::RightStickX),
+            (data.right_stick_x - 127.0f) / 127.0f);
+    SetAxis(identifier, static_cast<int>(PadAxes::RightStickY),
+            (data.right_stick_y - 127.0f) / 127.0f);
+
+    static constexpr std::array<PadButton, 16> buttons{
+        PadButton::Share,    PadButton::L3,     PadButton::R3,    PadButton::Options,
+        PadButton::Up,       PadButton::Right,  PadButton::Down,  PadButton::Left,
+        PadButton::L2,       PadButton::R2,     PadButton::L1,    PadButton::R1,
+        PadButton::Triangle, PadButton::Circle, PadButton::Cross, PadButton::Square};
+
+    for (std::size_t i = 0; i < buttons.size(); ++i) {
+        const bool button_status = (data.digital_button & (1U << i)) != 0;
+        const int button = static_cast<int>(buttons[i]);
+        SetButton(identifier, button, button_status);
     }
 }
 
@@ -317,6 +343,170 @@ void UDPClient::Reset() {
     }
 }
 
+std::vector<Common::ParamPackage> UDPClient::GetInputDevices() const {
+    std::vector<Common::ParamPackage> devices;
+    if (!Settings::values.enable_udp_controller) {
+        return devices;
+    }
+    for (std::size_t client = 0; client < clients.size(); client++) {
+        if (clients[client].active != 1) {
+            continue;
+        }
+        for (std::size_t index = 0; index < PADS_PER_CLIENT; ++index) {
+            const std::size_t pad_index = client * PADS_PER_CLIENT + index;
+            if (!pads[pad_index].connected) {
+                continue;
+            }
+            const auto pad_identifier = GetPadIdentifier(pad_index);
+            Common::ParamPackage identifier{};
+            identifier.Set("engine", GetEngineName());
+            identifier.Set("display", fmt::format("UDP Controller {}", pad_identifier.pad));
+            identifier.Set("guid", pad_identifier.guid.Format());
+            identifier.Set("port", static_cast<int>(pad_identifier.port));
+            identifier.Set("pad", static_cast<int>(pad_identifier.pad));
+            devices.emplace_back(identifier);
+        }
+    }
+    return devices;
+}
+
+ButtonMapping UDPClient::GetButtonMappingForDevice(const Common::ParamPackage& params) {
+    // This list excludes any button that can't be really mapped
+    static constexpr std::array<std::pair<Settings::NativeButton::Values, PadButton>, 18>
+        switch_to_dsu_button = {
+            std::pair{Settings::NativeButton::A, PadButton::Circle},
+            {Settings::NativeButton::B, PadButton::Cross},
+            {Settings::NativeButton::X, PadButton::Triangle},
+            {Settings::NativeButton::Y, PadButton::Square},
+            {Settings::NativeButton::Plus, PadButton::Options},
+            {Settings::NativeButton::Minus, PadButton::Share},
+            {Settings::NativeButton::DLeft, PadButton::Left},
+            {Settings::NativeButton::DUp, PadButton::Up},
+            {Settings::NativeButton::DRight, PadButton::Right},
+            {Settings::NativeButton::DDown, PadButton::Down},
+            {Settings::NativeButton::L, PadButton::L1},
+            {Settings::NativeButton::R, PadButton::R1},
+            {Settings::NativeButton::ZL, PadButton::L2},
+            {Settings::NativeButton::ZR, PadButton::R2},
+            {Settings::NativeButton::SL, PadButton::L2},
+            {Settings::NativeButton::SR, PadButton::R2},
+            {Settings::NativeButton::LStick, PadButton::L3},
+            {Settings::NativeButton::RStick, PadButton::R3},
+        };
+    if (!params.Has("guid") || !params.Has("port") || !params.Has("pad")) {
+        return {};
+    }
+
+    ButtonMapping mapping{};
+    for (const auto& [switch_button, dsu_button] : switch_to_dsu_button) {
+        Common::ParamPackage button_params{};
+        button_params.Set("engine", GetEngineName());
+        button_params.Set("guid", params.Get("guid", ""));
+        button_params.Set("port", params.Get("port", 0));
+        button_params.Set("pad", params.Get("pad", 0));
+        button_params.Set("button", static_cast<int>(dsu_button));
+        mapping.insert_or_assign(switch_button, std::move(button_params));
+    }
+
+    return mapping;
+}
+
+AnalogMapping UDPClient::GetAnalogMappingForDevice(const Common::ParamPackage& params) {
+    if (!params.Has("guid") || !params.Has("port") || !params.Has("pad")) {
+        return {};
+    }
+
+    AnalogMapping mapping = {};
+    Common::ParamPackage left_analog_params;
+    left_analog_params.Set("engine", GetEngineName());
+    left_analog_params.Set("guid", params.Get("guid", ""));
+    left_analog_params.Set("port", params.Get("port", 0));
+    left_analog_params.Set("pad", params.Get("pad", 0));
+    left_analog_params.Set("axis_x", static_cast<int>(PadAxes::LeftStickX));
+    left_analog_params.Set("axis_y", static_cast<int>(PadAxes::LeftStickY));
+    mapping.insert_or_assign(Settings::NativeAnalog::LStick, std::move(left_analog_params));
+    Common::ParamPackage right_analog_params;
+    right_analog_params.Set("engine", GetEngineName());
+    right_analog_params.Set("guid", params.Get("guid", ""));
+    right_analog_params.Set("port", params.Get("port", 0));
+    right_analog_params.Set("pad", params.Get("pad", 0));
+    right_analog_params.Set("axis_x", static_cast<int>(PadAxes::RightStickX));
+    right_analog_params.Set("axis_y", static_cast<int>(PadAxes::RightStickY));
+    mapping.insert_or_assign(Settings::NativeAnalog::RStick, std::move(right_analog_params));
+    return mapping;
+}
+
+MotionMapping UDPClient::GetMotionMappingForDevice(const Common::ParamPackage& params) {
+    if (!params.Has("guid") || !params.Has("port") || !params.Has("pad")) {
+        return {};
+    }
+
+    MotionMapping mapping = {};
+    Common::ParamPackage motion_params;
+    motion_params.Set("engine", GetEngineName());
+    motion_params.Set("guid", params.Get("guid", ""));
+    motion_params.Set("port", params.Get("port", 0));
+    motion_params.Set("pad", params.Get("pad", 0));
+    motion_params.Set("motion", 0);
+    mapping.insert_or_assign(Settings::NativeMotion::MotionLeft, std::move(motion_params));
+    mapping.insert_or_assign(Settings::NativeMotion::MotionRight, std::move(motion_params));
+    return mapping;
+}
+
+Common::Input::ButtonNames UDPClient::GetUIButtonName(const Common::ParamPackage& params) const {
+    PadButton button = static_cast<PadButton>(params.Get("button", 0));
+    switch (button) {
+    case PadButton::Left:
+        return Common::Input::ButtonNames::ButtonLeft;
+    case PadButton::Right:
+        return Common::Input::ButtonNames::ButtonRight;
+    case PadButton::Down:
+        return Common::Input::ButtonNames::ButtonDown;
+    case PadButton::Up:
+        return Common::Input::ButtonNames::ButtonUp;
+    case PadButton::L1:
+        return Common::Input::ButtonNames::L1;
+    case PadButton::L2:
+        return Common::Input::ButtonNames::L2;
+    case PadButton::L3:
+        return Common::Input::ButtonNames::L3;
+    case PadButton::R1:
+        return Common::Input::ButtonNames::R1;
+    case PadButton::R2:
+        return Common::Input::ButtonNames::R2;
+    case PadButton::R3:
+        return Common::Input::ButtonNames::R3;
+    case PadButton::Circle:
+        return Common::Input::ButtonNames::Circle;
+    case PadButton::Cross:
+        return Common::Input::ButtonNames::Cross;
+    case PadButton::Square:
+        return Common::Input::ButtonNames::Square;
+    case PadButton::Triangle:
+        return Common::Input::ButtonNames::Triangle;
+    case PadButton::Share:
+        return Common::Input::ButtonNames::Share;
+    case PadButton::Options:
+        return Common::Input::ButtonNames::Options;
+    default:
+        return Common::Input::ButtonNames::Undefined;
+    }
+}
+
+Common::Input::ButtonNames UDPClient::GetUIName(const Common::ParamPackage& params) const {
+    if (params.Has("button")) {
+        return GetUIButtonName(params);
+    }
+    if (params.Has("axis")) {
+        return Common::Input::ButtonNames::Value;
+    }
+    if (params.Has("motion")) {
+        return Common::Input::ButtonNames::Engine;
+    }
+
+    return Common::Input::ButtonNames::Invalid;
+}
+
 void TestCommunication(const std::string& host, u16 port,
                        const std::function<void()>& success_callback,
                        const std::function<void()>& failure_callback) {
diff --git a/src/input_common/drivers/udp_client.h b/src/input_common/drivers/udp_client.h
index 1f02adba58..5d483f26b3 100644
--- a/src/input_common/drivers/udp_client.h
+++ b/src/input_common/drivers/udp_client.h
@@ -56,7 +56,61 @@ public:
 
     void ReloadSockets();
 
+    /// Used for automapping features
+    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;
+    Common::Input::ButtonNames GetUIName(const Common::ParamPackage& params) const override;
+
 private:
+    enum class PadButton {
+        Undefined = 0x0000,
+        Share = 0x0001,
+        L3 = 0x0002,
+        R3 = 0x0004,
+        Options = 0x0008,
+        Up = 0x0010,
+        Right = 0x0020,
+        Down = 0x0040,
+        Left = 0x0080,
+        L2 = 0x0100,
+        R2 = 0x0200,
+        L1 = 0x0400,
+        R1 = 0x0800,
+        Triangle = 0x1000,
+        Circle = 0x2000,
+        Cross = 0x4000,
+        Square = 0x8000,
+        Touch1 = 0x10000,
+        touch2 = 0x20000,
+    };
+
+    enum class PadAxes : u8 {
+        LeftStickX,
+        LeftStickY,
+        RightStickX,
+        RightStickY,
+        AnalogLeft,
+        AnalogDown,
+        AnalogRight,
+        AnalogUp,
+        AnalogSquare,
+        AnalogCross,
+        AnalogCircle,
+        AnalogTriangle,
+        AnalogR1,
+        AnalogL1,
+        AnalogR2,
+        AnalogL3,
+        AnalogR3,
+        Touch1X,
+        Touch1Y,
+        Touch2X,
+        Touch2Y,
+        Undefined,
+    };
+
     struct PadData {
         std::size_t pad_index{};
         bool connected{};
@@ -90,6 +144,8 @@ private:
     const PadIdentifier GetPadIdentifier(std::size_t pad_index) const;
     const Common::UUID GetHostUUID(const std::string host) const;
 
+    Common::Input::ButtonNames GetUIButtonName(const Common::ParamPackage& params) const;
+
     // Allocate clients for 8 udp servers
     static constexpr std::size_t MAX_UDP_CLIENTS = 8;
     static constexpr std::size_t PADS_PER_CLIENT = 4;
diff --git a/src/input_common/helpers/udp_protocol.h b/src/input_common/helpers/udp_protocol.h
index 1bdc9209e7..bcba12c58e 100644
--- a/src/input_common/helpers/udp_protocol.h
+++ b/src/input_common/helpers/udp_protocol.h
@@ -56,6 +56,12 @@ constexpr Type GetMessageType();
 
 namespace Request {
 
+enum RegisterFlags : u8 {
+    AllPads,
+    PadID,
+    PadMACAdddress,
+};
+
 struct Version {};
 /**
  * Requests the server to send information about what controllers are plugged into the ports
@@ -77,13 +83,8 @@ static_assert(std::is_trivially_copyable_v<PortInfo>,
  * timeout seems to be 5 seconds.
  */
 struct PadData {
-    enum class Flags : u8 {
-        AllPorts,
-        Id,
-        Mac,
-    };
     /// Determines which method will be used as a look up for the controller
-    Flags flags{};
+    RegisterFlags flags{};
     /// Index of the port of the controller to retrieve data about
     u8 port_id{};
     /// Mac address of the controller to retrieve data about
@@ -113,6 +114,36 @@ Message<T> Create(const T data, const u32 client_id = 0) {
 
 namespace Response {
 
+enum class ConnectionType : u8 {
+    None,
+    Usb,
+    Bluetooth,
+};
+
+enum class State : u8 {
+    Disconnected,
+    Reserved,
+    Connected,
+};
+
+enum class Model : u8 {
+    None,
+    PartialGyro,
+    FullGyro,
+    Generic,
+};
+
+enum class Battery : u8 {
+    None = 0x00,
+    Dying = 0x01,
+    Low = 0x02,
+    Medium = 0x03,
+    High = 0x04,
+    Full = 0x05,
+    Charging = 0xEE,
+    Charged = 0xEF,
+};
+
 struct Version {
     u16_le version{};
 };
@@ -122,11 +153,11 @@ static_assert(std::is_trivially_copyable_v<Version>,
 
 struct PortInfo {
     u8 id{};
-    u8 state{};
-    u8 model{};
-    u8 connection_type{};
+    State state{};
+    Model model{};
+    ConnectionType connection_type{};
     MacAddress mac;
-    u8 battery{};
+    Battery battery{};
     u8 is_pad_active{};
 };
 static_assert(sizeof(PortInfo) == 12, "UDP Response PortInfo struct has wrong size");
@@ -177,18 +208,18 @@ struct PadData {
     u8 right_stick_y{};
 
     struct AnalogButton {
-        u8 button_8{};
-        u8 button_7{};
-        u8 button_6{};
-        u8 button_5{};
-        u8 button_12{};
-        u8 button_11{};
-        u8 button_10{};
-        u8 button_9{};
-        u8 button_16{};
-        u8 button_15{};
-        u8 button_14{};
-        u8 button_13{};
+        u8 button_dpad_left_analog{};
+        u8 button_dpad_down_analog{};
+        u8 button_dpad_right_analog{};
+        u8 button_dpad_up_analog{};
+        u8 button_square_analog{};
+        u8 button_cross_analog{};
+        u8 button_circle_analog{};
+        u8 button_triangle_analog{};
+        u8 button_r1_analog{};
+        u8 button_l1_analog{};
+        u8 trigger_r2{};
+        u8 trigger_l2{};
     } analog_button;
 
     std::array<TouchPad, 2> touch;
diff --git a/src/input_common/input_mapping.cpp b/src/input_common/input_mapping.cpp
index c5218f2cb7..6e0024b2da 100644
--- a/src/input_common/input_mapping.cpp
+++ b/src/input_common/input_mapping.cpp
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included
 
 #include "common/common_types.h"
+#include "common/settings.h"
 #include "input_common/input_engine.h"
 #include "input_common/input_mapping.h"
 
@@ -182,6 +183,11 @@ bool MappingFactory::IsDriverValid(const MappingData& data) const {
     if (data.engine == "keyboard" && data.pad.port != 0) {
         return false;
     }
+    // To prevent mapping with two devices we disable any UDP except motion
+    if (!Settings::values.enable_udp_controller && data.engine == "cemuhookudp" &&
+        data.type != EngineInputType::Motion) {
+        return false;
+    }
     // The following drivers don't need to be mapped
     if (data.engine == "tas") {
         return false;
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index 39e4935dc1..940744c5f0 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -63,9 +63,12 @@ struct InputSubsystem::Impl {
 
         udp_client = std::make_shared<CemuhookUDP::UDPClient>("cemuhookudp");
         udp_client->SetMappingCallback(mapping_callback);
-        udp_client_factory = std::make_shared<InputFactory>(udp_client);
+        udp_client_input_factory = std::make_shared<InputFactory>(udp_client);
+        udp_client_output_factory = std::make_shared<OutputFactory>(udp_client);
         Common::Input::RegisterFactory<Common::Input::InputDevice>(udp_client->GetEngineName(),
-                                                                   udp_client_factory);
+                                                                   udp_client_input_factory);
+        Common::Input::RegisterFactory<Common::Input::OutputDevice>(udp_client->GetEngineName(),
+                                                                    udp_client_output_factory);
 
         tas_input = std::make_shared<TasInput::Tas>("tas");
         tas_input->SetMappingCallback(mapping_callback);
@@ -110,6 +113,7 @@ struct InputSubsystem::Impl {
         gcadapter.reset();
 
         Common::Input::UnregisterFactory<Common::Input::InputDevice>(udp_client->GetEngineName());
+        Common::Input::UnregisterFactory<Common::Input::OutputDevice>(udp_client->GetEngineName());
         udp_client.reset();
 
         Common::Input::UnregisterFactory<Common::Input::InputDevice>(tas_input->GetEngineName());
@@ -137,6 +141,8 @@ struct InputSubsystem::Impl {
         devices.insert(devices.end(), mouse_devices.begin(), mouse_devices.end());
         auto gcadapter_devices = gcadapter->GetInputDevices();
         devices.insert(devices.end(), gcadapter_devices.begin(), gcadapter_devices.end());
+        auto udp_devices = udp_client->GetInputDevices();
+        devices.insert(devices.end(), udp_devices.begin(), udp_devices.end());
 #ifdef HAVE_SDL2
         auto sdl_devices = sdl->GetInputDevices();
         devices.insert(devices.end(), sdl_devices.begin(), sdl_devices.end());
@@ -157,6 +163,9 @@ struct InputSubsystem::Impl {
         if (engine == gcadapter->GetEngineName()) {
             return gcadapter->GetAnalogMappingForDevice(params);
         }
+        if (engine == udp_client->GetEngineName()) {
+            return udp_client->GetAnalogMappingForDevice(params);
+        }
         if (engine == tas_input->GetEngineName()) {
             return tas_input->GetAnalogMappingForDevice(params);
         }
@@ -177,6 +186,9 @@ struct InputSubsystem::Impl {
         if (engine == gcadapter->GetEngineName()) {
             return gcadapter->GetButtonMappingForDevice(params);
         }
+        if (engine == udp_client->GetEngineName()) {
+            return udp_client->GetButtonMappingForDevice(params);
+        }
         if (engine == tas_input->GetEngineName()) {
             return tas_input->GetButtonMappingForDevice(params);
         }
@@ -194,8 +206,8 @@ struct InputSubsystem::Impl {
             return {};
         }
         const std::string engine = params.Get("engine", "");
-        if (engine == gcadapter->GetEngineName()) {
-            return gcadapter->GetMotionMappingForDevice(params);
+        if (engine == udp_client->GetEngineName()) {
+            return udp_client->GetMotionMappingForDevice(params);
         }
 #ifdef HAVE_SDL2
         if (engine == sdl->GetEngineName()) {
@@ -238,6 +250,9 @@ struct InputSubsystem::Impl {
         if (engine == gcadapter->GetEngineName()) {
             return true;
         }
+        if (engine == udp_client->GetEngineName()) {
+            return true;
+        }
         if (engine == tas_input->GetEngineName()) {
             return true;
         }
@@ -286,12 +301,13 @@ struct InputSubsystem::Impl {
     std::shared_ptr<InputFactory> mouse_factory;
     std::shared_ptr<InputFactory> gcadapter_input_factory;
     std::shared_ptr<InputFactory> touch_screen_factory;
-    std::shared_ptr<InputFactory> udp_client_factory;
+    std::shared_ptr<InputFactory> udp_client_input_factory;
     std::shared_ptr<InputFactory> tas_input_factory;
 
     std::shared_ptr<OutputFactory> keyboard_output_factory;
     std::shared_ptr<OutputFactory> mouse_output_factory;
     std::shared_ptr<OutputFactory> gcadapter_output_factory;
+    std::shared_ptr<OutputFactory> udp_client_output_factory;
     std::shared_ptr<OutputFactory> tas_output_factory;
 
 #ifdef HAVE_SDL2
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index ae1684dd4c..38fd6e93b3 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -447,6 +447,7 @@ void Config::ReadMotionTouchValues() {
     Settings::values.touch_from_button_map_index = std::clamp(
         Settings::values.touch_from_button_map_index.GetValue(), 0, num_touch_from_button_maps - 1);
     ReadBasicSetting(Settings::values.udp_input_servers);
+    ReadBasicSetting(Settings::values.enable_udp_controller);
 }
 
 void Config::ReadCoreValues() {
@@ -942,6 +943,7 @@ void Config::SaveMotionTouchValues() {
     WriteBasicSetting(Settings::values.touch_device);
     WriteBasicSetting(Settings::values.touch_from_button_map_index);
     WriteBasicSetting(Settings::values.udp_input_servers);
+    WriteBasicSetting(Settings::values.enable_udp_controller);
 
     qt_config->beginWriteArray(QStringLiteral("touch_from_button_maps"));
     for (std::size_t p = 0; p < Settings::values.touch_from_button_maps.size(); ++p) {
diff --git a/src/yuzu/configuration/configure_input_advanced.cpp b/src/yuzu/configuration/configure_input_advanced.cpp
index e6127f9e67..65c8e59ac4 100644
--- a/src/yuzu/configuration/configure_input_advanced.cpp
+++ b/src/yuzu/configuration/configure_input_advanced.cpp
@@ -130,6 +130,7 @@ void ConfigureInputAdvanced::ApplyConfiguration() {
         static_cast<float>(ui->mouse_panning_sensitivity->value());
     Settings::values.touchscreen.enabled = ui->touchscreen_enabled->isChecked();
     Settings::values.enable_raw_input = ui->enable_raw_input->isChecked();
+    Settings::values.enable_udp_controller = ui->enable_udp_controller->isChecked();
 }
 
 void ConfigureInputAdvanced::LoadConfiguration() {
@@ -160,6 +161,7 @@ void ConfigureInputAdvanced::LoadConfiguration() {
     ui->mouse_panning_sensitivity->setValue(Settings::values.mouse_panning_sensitivity.GetValue());
     ui->touchscreen_enabled->setChecked(Settings::values.touchscreen.enabled);
     ui->enable_raw_input->setChecked(Settings::values.enable_raw_input.GetValue());
+    ui->enable_udp_controller->setChecked(Settings::values.enable_udp_controller.GetValue());
 
     UpdateUIEnabled();
 }
diff --git a/src/yuzu/configuration/configure_input_advanced.ui b/src/yuzu/configuration/configure_input_advanced.ui
index 75487a5d0a..df0e4d6024 100644
--- a/src/yuzu/configuration/configure_input_advanced.ui
+++ b/src/yuzu/configuration/configure_input_advanced.ui
@@ -2642,6 +2642,19 @@
                      </widget>
                    </item>
                    <item row="3" column="0">
+                     <widget class="QCheckBox" name="enable_udp_controller">
+                       <property name="minimumSize">
+                         <size>
+                           <width>0</width>
+                           <height>23</height>
+                         </size>
+                       </property>
+                       <property name="text">
+                         <string>Enable UDP controllers (not needed for motion)</string>
+                       </property>
+                     </widget>
+                   </item>
+                   <item row="4" column="0">
                      <widget class="QCheckBox" name="mouse_panning">
                        <property name="minimumSize">
                          <size>
@@ -2654,7 +2667,7 @@
                        </property>
                      </widget>
                    </item>
-                   <item row="3" column="2">
+                   <item row="4" column="2">
                      <widget class="QSpinBox" name="mouse_panning_sensitivity">
                        <property name="toolTip">
                          <string>Mouse sensitivity</string>
@@ -2676,14 +2689,14 @@
                        </property>
                      </widget>
                    </item>
-                   <item row="4" column="0">
+                   <item row="5" column="0">
                      <widget class="QLabel" name="motion_touch">
                        <property name="text">
                          <string>Motion / Touch</string>
                        </property>
                      </widget>
                    </item>
-                   <item row="4" column="2">
+                   <item row="5" column="2">
                      <widget class="QPushButton" name="buttonMotionTouch">
                        <property name="text">
                          <string>Configure</string>
diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp
index 6219a09a84..ec071d6ec4 100644
--- a/src/yuzu/configuration/configure_input_player.cpp
+++ b/src/yuzu/configuration/configure_input_player.cpp
@@ -78,6 +78,30 @@ QString GetButtonName(Common::Input::ButtonNames button_name) {
         return QObject::tr("Y");
     case Common::Input::ButtonNames::ButtonStart:
         return QObject::tr("Start");
+    case Common::Input::ButtonNames::L1:
+        return QObject::tr("L1");
+    case Common::Input::ButtonNames::L2:
+        return QObject::tr("L2");
+    case Common::Input::ButtonNames::L3:
+        return QObject::tr("L3");
+    case Common::Input::ButtonNames::R1:
+        return QObject::tr("R1");
+    case Common::Input::ButtonNames::R2:
+        return QObject::tr("R2");
+    case Common::Input::ButtonNames::R3:
+        return QObject::tr("R3");
+    case Common::Input::ButtonNames::Circle:
+        return QObject::tr("Circle");
+    case Common::Input::ButtonNames::Cross:
+        return QObject::tr("Cross");
+    case Common::Input::ButtonNames::Square:
+        return QObject::tr("Square");
+    case Common::Input::ButtonNames::Triangle:
+        return QObject::tr("Triangle");
+    case Common::Input::ButtonNames::Share:
+        return QObject::tr("Share");
+    case Common::Input::ButtonNames::Options:
+        return QObject::tr("Options");
     default:
         return QObject::tr("[undefined]");
     }
-- 
cgit v1.2.3