15 files changed, 254 insertions, 223 deletions

diff --git a/src/input_common/drivers/gc_adapter.cpp b/src/input_common/drivers/gc_adapter.cpp
index 62dc28711..2550f8cba 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 b82e4803d..fba90352e 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 a3e0d8a61..58df15050 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 d3178b1a9..cf0918409 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 53e282ef3..1e3741e0f 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 1ff85f48d..b879df8ab 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 5fbb2f47f..d297d253c 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 806a0e8bb..1d5948f79 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 82dff5ca8..437ace4f7 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 bb2bad5b1..fee41cae3 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 21b353728..628f18215 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 31ce900d7..ed79d3d93 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 6edb8d900..2b3b77938 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 1357e104b..573f09fde 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 07d514ad7..df36a337c 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 {