early-access version 3244

2022-12-24 04:43:08 +01:00
parent 79ff2722d6
commit 984203b4d4
47 changed files with 4798 additions and 128 deletions
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -88,6 +88,7 @@ void EmulatedController::ReloadFromSettings() {
        motion_params[index] = Common::ParamPackage(player.motions[index]);
    }

+    controller.color_values = {};
    controller.colors_state.fullkey = {
        .body = GetNpadColor(player.body_color_left),
        .button = GetNpadColor(player.button_color_left),
@@ -101,6 +102,8 @@ void EmulatedController::ReloadFromSettings() {
        .button = GetNpadColor(player.button_color_right),
    };

+    ring_params[0] = Common::ParamPackage(Settings::values.ringcon_analogs);
+
    // Other or debug controller should always be a pro controller
    if (npad_id_type != NpadIdType::Other) {
        SetNpadStyleIndex(MapSettingsTypeToNPad(player.controller_type));
@@ -127,18 +130,26 @@ void EmulatedController::LoadDevices() {
    trigger_params[LeftIndex] = button_params[Settings::NativeButton::ZL];
    trigger_params[RightIndex] = button_params[Settings::NativeButton::ZR];

+    color_params[LeftIndex] = left_joycon;
+    color_params[RightIndex] = right_joycon;
+    color_params[LeftIndex].Set("color", true);
+    color_params[RightIndex].Set("color", true);
+
    battery_params[LeftIndex] = left_joycon;
    battery_params[RightIndex] = right_joycon;
    battery_params[LeftIndex].Set("battery", true);
    battery_params[RightIndex].Set("battery", true);

    camera_params = Common::ParamPackage{"engine:camera,camera:1"};
-    nfc_params = Common::ParamPackage{"engine:virtual_amiibo,nfc:1"};
+    ring_params[1] = Common::ParamPackage{"engine:joycon,axis_x:100,axis_y:101"};
+    nfc_params[0] = Common::ParamPackage{"engine:virtual_amiibo,nfc:1"};
+    nfc_params[1] = right_joycon;
+    nfc_params[1].Set("nfc", true);

    output_params[LeftIndex] = left_joycon;
    output_params[RightIndex] = right_joycon;
    output_params[2] = camera_params;
-    output_params[3] = nfc_params;
+    output_params[3] = nfc_params[0];
    output_params[LeftIndex].Set("output", true);
    output_params[RightIndex].Set("output", true);
    output_params[2].Set("output", true);
@@ -154,8 +165,11 @@ void EmulatedController::LoadDevices() {
                           Common::Input::CreateInputDevice);
    std::ranges::transform(battery_params, battery_devices.begin(),
                           Common::Input::CreateInputDevice);
+    std::ranges::transform(color_params, color_devices.begin(), Common::Input::CreateInputDevice);
    camera_devices = Common::Input::CreateInputDevice(camera_params);
-    nfc_devices = Common::Input::CreateInputDevice(nfc_params);
+    std::ranges::transform(ring_params, ring_analog_devices.begin(),
+                           Common::Input::CreateInputDevice);
+    std::ranges::transform(nfc_params, nfc_devices.begin(), Common::Input::CreateInputDevice);
    std::ranges::transform(output_params, output_devices.begin(),
                           Common::Input::CreateOutputDevice);

@@ -310,6 +324,19 @@ void EmulatedController::ReloadInput() {
        battery_devices[index]->ForceUpdate();
    }

+    for (std::size_t index = 0; index < color_devices.size(); ++index) {
+        if (!color_devices[index]) {
+            continue;
+        }
+        color_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetColors(callback, index);
+                },
+        });
+        color_devices[index]->ForceUpdate();
+    }
+
    for (std::size_t index = 0; index < motion_devices.size(); ++index) {
        if (!motion_devices[index]) {
            continue;
@@ -331,14 +358,26 @@ void EmulatedController::ReloadInput() {
        camera_devices->ForceUpdate();
    }

-    if (nfc_devices) {
-        if (npad_id_type == NpadIdType::Handheld || npad_id_type == NpadIdType::Player1) {
-            nfc_devices->SetCallback({
-                .on_change =
-                    [this](const Common::Input::CallbackStatus& callback) { SetNfc(callback); },
-            });
-            nfc_devices->ForceUpdate();
+    for (std::size_t index = 0; index < ring_analog_devices.size(); ++index) {
+        if (!ring_analog_devices[index]) {
+            continue;
        }
+        ring_analog_devices[index]->SetCallback({
+            .on_change =
+                [this](const Common::Input::CallbackStatus& callback) { SetRingAnalog(callback); },
+        });
+        ring_analog_devices[index]->ForceUpdate();
+    }
+
+    for (std::size_t index = 0; index < nfc_devices.size(); ++index) {
+        if (!nfc_devices[index]) {
+            continue;
+        }
+        nfc_devices[index]->SetCallback({
+            .on_change =
+                [this](const Common::Input::CallbackStatus& callback) { SetNfc(callback); },
+        });
+        nfc_devices[index]->ForceUpdate();
    }

    // Use a common UUID for TAS
@@ -416,6 +455,9 @@ void EmulatedController::UnloadInput() {
    for (auto& battery : battery_devices) {
        battery.reset();
    }
+    for (auto& color : color_devices) {
+        color.reset();
+    }
    for (auto& output : output_devices) {
        output.reset();
    }
@@ -432,7 +474,12 @@ void EmulatedController::UnloadInput() {
        stick.reset();
    }
    camera_devices.reset();
-    nfc_devices.reset();
+    for (auto& ring : ring_analog_devices) {
+        ring.reset();
+    }
+    for (auto& nfc : nfc_devices) {
+        nfc.reset();
+    }
 }

 void EmulatedController::EnableConfiguration() {
@@ -444,6 +491,11 @@ void EmulatedController::EnableConfiguration() {
 void EmulatedController::DisableConfiguration() {
    is_configuring = false;

+    // Get Joycon colors before turning on the controller
+    for (const auto& color_device : color_devices) {
+        color_device->ForceUpdate();
+    }
+
    // Apply temporary npad type to the real controller
    if (tmp_npad_type != npad_type) {
        if (is_connected) {
@@ -497,6 +549,9 @@ void EmulatedController::SaveCurrentConfig() {
    for (std::size_t index = 0; index < player.motions.size(); ++index) {
        player.motions[index] = motion_params[index].Serialize();
    }
+    if (npad_id_type == NpadIdType::Player1) {
+        Settings::values.ringcon_analogs = ring_params[0].Serialize();
+    }
 }

 void EmulatedController::RestoreConfig() {
@@ -906,6 +961,58 @@ void EmulatedController::SetMotion(const Common::Input::CallbackStatus& callback
    TriggerOnChange(ControllerTriggerType::Motion, true);
 }

+void EmulatedController::SetColors(const Common::Input::CallbackStatus& callback,
+                                   std::size_t index) {
+    if (index >= controller.color_values.size()) {
+        return;
+    }
+    std::unique_lock lock{mutex};
+    controller.color_values[index] = TransformToColor(callback);
+
+    if (is_configuring) {
+        lock.unlock();
+        TriggerOnChange(ControllerTriggerType::Color, false);
+        return;
+    }
+
+    if (controller.color_values[index].body == 0) {
+        return;
+    }
+
+    controller.colors_state.fullkey = {
+        .body = GetNpadColor(controller.color_values[index].body),
+        .button = GetNpadColor(controller.color_values[index].buttons),
+    };
+    if (npad_type == NpadStyleIndex::ProController) {
+        controller.colors_state.left = {
+            .body = GetNpadColor(controller.color_values[index].left_grip),
+            .button = GetNpadColor(controller.color_values[index].buttons),
+        };
+        controller.colors_state.right = {
+            .body = GetNpadColor(controller.color_values[index].right_grip),
+            .button = GetNpadColor(controller.color_values[index].buttons),
+        };
+    } else {
+        switch (index) {
+        case LeftIndex:
+            controller.colors_state.left = {
+                .body = GetNpadColor(controller.color_values[index].body),
+                .button = GetNpadColor(controller.color_values[index].buttons),
+            };
+            break;
+        case RightIndex:
+            controller.colors_state.right = {
+                .body = GetNpadColor(controller.color_values[index].body),
+                .button = GetNpadColor(controller.color_values[index].buttons),
+            };
+            break;
+        }
+    }
+
+    lock.unlock();
+    TriggerOnChange(ControllerTriggerType::Color, true);
+}
+
 void EmulatedController::SetBattery(const Common::Input::CallbackStatus& callback,
                                    std::size_t index) {
    if (index >= controller.battery_values.size()) {
@@ -996,6 +1103,24 @@ void EmulatedController::SetCamera(const Common::Input::CallbackStatus& callback
    TriggerOnChange(ControllerTriggerType::IrSensor, true);
 }

+void EmulatedController::SetRingAnalog(const Common::Input::CallbackStatus& callback) {
+    std::unique_lock lock{mutex};
+    const auto force_value = TransformToStick(callback);
+
+    controller.ring_analog_value = force_value.x;
+
+    if (is_configuring) {
+        lock.unlock();
+        TriggerOnChange(ControllerTriggerType::RingController, false);
+        return;
+    }
+
+    controller.ring_analog_state.force = force_value.x.value;
+
+    lock.unlock();
+    TriggerOnChange(ControllerTriggerType::RingController, true);
+}
+
 void EmulatedController::SetNfc(const Common::Input::CallbackStatus& callback) {
    std::unique_lock lock{mutex};
    controller.nfc_values = TransformToNfc(callback);
@@ -1095,6 +1220,15 @@ bool EmulatedController::SetCameraFormat(
               camera_format)) == Common::Input::CameraError::None;
 }

+Common::ParamPackage EmulatedController::GetRingParam() const {
+    return ring_params[0];
+}
+
+void EmulatedController::SetRingParam(Common::ParamPackage param) {
+    ring_params[0] = std::move(param);
+    ReloadInput();
+}
+
 bool EmulatedController::HasNfc() const {
    const auto& nfc_output_device = output_devices[3];

@@ -1386,6 +1520,10 @@ CameraValues EmulatedController::GetCameraValues() const {
    return controller.camera_values;
 }

+RingAnalogValue EmulatedController::GetRingSensorValues() const {
+    return controller.ring_analog_value;
+}
+
 HomeButtonState EmulatedController::GetHomeButtons() const {
    std::scoped_lock lock{mutex};
    if (is_configuring) {
@@ -1479,6 +1617,10 @@ const CameraState& EmulatedController::GetCamera() const {
    return controller.camera_state;
 }

+RingSensorForce EmulatedController::GetRingSensorForce() const {
+    return controller.ring_analog_state;
+}
+
 const NfcState& EmulatedController::GetNfc() const {
    std::scoped_lock lock{mutex};
    return controller.nfc_state;
--- a/src/core/hid/emulated_controller.h
+++ b/src/core/hid/emulated_controller.h
@@ -35,19 +35,26 @@ using ControllerMotionDevices =
    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeMotion::NumMotions>;
 using TriggerDevices =
    std::array<std::unique_ptr<Common::Input::InputDevice>, Settings::NativeTrigger::NumTriggers>;
+using ColorDevices =
+    std::array<std::unique_ptr<Common::Input::InputDevice>, max_emulated_controllers>;
 using BatteryDevices =
    std::array<std::unique_ptr<Common::Input::InputDevice>, max_emulated_controllers>;
 using CameraDevices = std::unique_ptr<Common::Input::InputDevice>;
-using NfcDevices = std::unique_ptr<Common::Input::InputDevice>;
+using RingAnalogDevices =
+    std::array<std::unique_ptr<Common::Input::InputDevice>, max_emulated_controllers>;
+using NfcDevices =
+    std::array<std::unique_ptr<Common::Input::InputDevice>, max_emulated_controllers>;
 using OutputDevices = std::array<std::unique_ptr<Common::Input::OutputDevice>, output_devices_size>;

 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 ColorParams = std::array<Common::ParamPackage, max_emulated_controllers>;
 using BatteryParams = std::array<Common::ParamPackage, max_emulated_controllers>;
 using CameraParams = Common::ParamPackage;
-using NfcParams = Common::ParamPackage;
+using RingAnalogParams = std::array<Common::ParamPackage, max_emulated_controllers>;
+using NfcParams = std::array<Common::ParamPackage, max_emulated_controllers>;
 using OutputParams = std::array<Common::ParamPackage, output_devices_size>;

 using ButtonValues = std::array<Common::Input::ButtonStatus, Settings::NativeButton::NumButtons>;
@@ -58,6 +65,7 @@ using ControllerMotionValues = std::array<ControllerMotionInfo, Settings::Native
 using ColorValues = std::array<Common::Input::BodyColorStatus, max_emulated_controllers>;
 using BatteryValues = std::array<Common::Input::BatteryStatus, max_emulated_controllers>;
 using CameraValues = Common::Input::CameraStatus;
+using RingAnalogValue = Common::Input::AnalogStatus;
 using NfcValues = Common::Input::NfcStatus;
 using VibrationValues = std::array<Common::Input::VibrationStatus, max_emulated_controllers>;

@@ -84,6 +92,10 @@ struct CameraState {
    std::size_t sample{};
 };

+struct RingSensorForce {
+    f32 force;
+};
+
 struct NfcState {
    Common::Input::NfcState state{};
    std::vector<u8> data{};
@@ -116,6 +128,7 @@ struct ControllerStatus {
    BatteryValues battery_values{};
    VibrationValues vibration_values{};
    CameraValues camera_values{};
+    RingAnalogValue ring_analog_value{};
    NfcValues nfc_values{};

    // Data for HID serices
@@ -129,6 +142,7 @@ struct ControllerStatus {
    ControllerColors colors_state{};
    BatteryLevelState battery_state{};
    CameraState camera_state{};
+    RingSensorForce ring_analog_state{};
    NfcState nfc_state{};
 };

@@ -141,6 +155,7 @@ enum class ControllerTriggerType {
    Battery,
    Vibration,
    IrSensor,
+    RingController,
    Nfc,
    Connected,
    Disconnected,
@@ -294,6 +309,9 @@ public:
    /// Returns the latest camera status from the controller with parameters
    CameraValues GetCameraValues() const;

+    /// Returns the latest status of analog input from the ring sensor with parameters
+    RingAnalogValue GetRingSensorValues() const;
+
    /// Returns the latest status of button input for the hid::HomeButton service
    HomeButtonState GetHomeButtons() const;

@@ -324,6 +342,9 @@ public:
    /// Returns the latest camera status from the controller
    const CameraState& GetCamera() const;

+    /// Returns the latest ringcon force sensor value
+    RingSensorForce GetRingSensorForce() const;
+
    /// Returns the latest ntag status from the controller
    const NfcState& GetNfc() const;

@@ -353,6 +374,15 @@ public:
     */
    bool SetCameraFormat(Core::IrSensor::ImageTransferProcessorFormat camera_format);

+    // Returns the current mapped ring device
+    Common::ParamPackage GetRingParam() const;
+
+    /**
+     * Updates the current mapped ring device
+     * @param param ParamPackage with ring sensor data to be mapped
+     */
+    void SetRingParam(Common::ParamPackage param);
+
    /// Returns true if the device has nfc support
    bool HasNfc() const;

@@ -432,10 +462,17 @@ private:
     */
    void SetMotion(const Common::Input::CallbackStatus& callback, std::size_t index);

+    /**
+     * Updates the color status of the controller
+     * @param callback A CallbackStatus containing the color status
+     * @param index color ID of the to be updated
+     */
+    void SetColors(const 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
+     * @param index battery ID of the to be updated
     */
    void SetBattery(const Common::Input::CallbackStatus& callback, std::size_t index);

@@ -445,6 +482,12 @@ private:
     */
    void SetCamera(const Common::Input::CallbackStatus& callback);

+    /**
+     * Updates the ring analog sensor status of the ring controller
+     * @param callback A CallbackStatus containing the force status
+     */
+    void SetRingAnalog(const Common::Input::CallbackStatus& callback);
+
    /**
     * Updates the nfc status of the controller
     * @param callback A CallbackStatus containing the nfc status
@@ -484,7 +527,9 @@ private:
    ControllerMotionParams motion_params;
    TriggerParams trigger_params;
    BatteryParams battery_params;
+    ColorParams color_params;
    CameraParams camera_params;
+    RingAnalogParams ring_params;
    NfcParams nfc_params;
    OutputParams output_params;

@@ -493,7 +538,9 @@ private:
    ControllerMotionDevices motion_devices;
    TriggerDevices trigger_devices;
    BatteryDevices battery_devices;
+    ColorDevices color_devices;
    CameraDevices camera_devices;
+    RingAnalogDevices ring_analog_devices;
    NfcDevices nfc_devices;
    OutputDevices output_devices;

--- a/src/core/hid/emulated_devices.cpp
+++ b/src/core/hid/emulated_devices.cpp
@@ -14,7 +14,6 @@ EmulatedDevices::EmulatedDevices() = default;
 EmulatedDevices::~EmulatedDevices() = default;

 void EmulatedDevices::ReloadFromSettings() {
-    ring_params = Common::ParamPackage(Settings::values.ringcon_analogs);
    ReloadInput();
 }

@@ -66,8 +65,6 @@ void EmulatedDevices::ReloadInput() {
        key_index++;
    }

-    ring_analog_device = Common::Input::CreateInputDevice(ring_params);
-
    for (std::size_t index = 0; index < mouse_button_devices.size(); ++index) {
        if (!mouse_button_devices[index]) {
            continue;
@@ -122,13 +119,6 @@ void EmulatedDevices::ReloadInput() {
                },
        });
    }
-
-    if (ring_analog_device) {
-        ring_analog_device->SetCallback({
-            .on_change =
-                [this](const Common::Input::CallbackStatus& callback) { SetRingAnalog(callback); },
-        });
-    }
 }

 void EmulatedDevices::UnloadInput() {
@@ -145,7 +135,6 @@ void EmulatedDevices::UnloadInput() {
    for (auto& button : keyboard_modifier_devices) {
        button.reset();
    }
-    ring_analog_device.reset();
 }

 void EmulatedDevices::EnableConfiguration() {
@@ -165,7 +154,6 @@ void EmulatedDevices::SaveCurrentConfig() {
    if (!is_configuring) {
        return;
    }
-    Settings::values.ringcon_analogs = ring_params.Serialize();
 }

 void EmulatedDevices::RestoreConfig() {
@@ -175,15 +163,6 @@ void EmulatedDevices::RestoreConfig() {
    ReloadFromSettings();
 }

-Common::ParamPackage EmulatedDevices::GetRingParam() const {
-    return ring_params;
-}
-
-void EmulatedDevices::SetRingParam(Common::ParamPackage param) {
-    ring_params = std::move(param);
-    ReloadInput();
-}
-
 void EmulatedDevices::SetKeyboardButton(const Common::Input::CallbackStatus& callback,
                                        std::size_t index) {
    if (index >= device_status.keyboard_values.size()) {
@@ -430,23 +409,6 @@ void EmulatedDevices::SetMouseStick(const Common::Input::CallbackStatus& callbac
    TriggerOnChange(DeviceTriggerType::Mouse);
 }

-void EmulatedDevices::SetRingAnalog(const Common::Input::CallbackStatus& callback) {
-    std::lock_guard lock{mutex};
-    const auto force_value = TransformToStick(callback);
-
-    device_status.ring_analog_value = force_value.x;
-
-    if (is_configuring) {
-        device_status.ring_analog_value = {};
-        TriggerOnChange(DeviceTriggerType::RingController);
-        return;
-    }
-
-    device_status.ring_analog_state.force = force_value.x.value;
-
-    TriggerOnChange(DeviceTriggerType::RingController);
-}
-
 KeyboardValues EmulatedDevices::GetKeyboardValues() const {
    std::scoped_lock lock{mutex};
    return device_status.keyboard_values;
@@ -462,10 +424,6 @@ MouseButtonValues EmulatedDevices::GetMouseButtonsValues() const {
    return device_status.mouse_button_values;
 }

-RingAnalogValue EmulatedDevices::GetRingSensorValues() const {
-    return device_status.ring_analog_value;
-}
-
 KeyboardKey EmulatedDevices::GetKeyboard() const {
    std::scoped_lock lock{mutex};
    return device_status.keyboard_state;
@@ -491,10 +449,6 @@ AnalogStickState EmulatedDevices::GetMouseWheel() const {
    return device_status.mouse_wheel_state;
 }

-RingSensorForce EmulatedDevices::GetRingSensorForce() const {
-    return device_status.ring_analog_state;
-}
-
 void EmulatedDevices::TriggerOnChange(DeviceTriggerType type) {
    std::scoped_lock lock{callback_mutex};
    for (const auto& poller_pair : callback_list) {
--- a/src/core/hid/emulated_devices.h
+++ b/src/core/hid/emulated_devices.h
@@ -26,11 +26,9 @@ using MouseButtonDevices = std::array<std::unique_ptr<Common::Input::InputDevice
 using MouseAnalogDevices = std::array<std::unique_ptr<Common::Input::InputDevice>,
                                      Settings::NativeMouseWheel::NumMouseWheels>;
 using MouseStickDevice = std::unique_ptr<Common::Input::InputDevice>;
-using RingAnalogDevice = std::unique_ptr<Common::Input::InputDevice>;

 using MouseButtonParams =
    std::array<Common::ParamPackage, Settings::NativeMouseButton::NumMouseButtons>;
-using RingAnalogParams = Common::ParamPackage;

 using KeyboardValues =
    std::array<Common::Input::ButtonStatus, Settings::NativeKeyboard::NumKeyboardKeys>;
@@ -41,17 +39,12 @@ using MouseButtonValues =
 using MouseAnalogValues =
    std::array<Common::Input::AnalogStatus, Settings::NativeMouseWheel::NumMouseWheels>;
 using MouseStickValue = Common::Input::TouchStatus;
-using RingAnalogValue = Common::Input::AnalogStatus;

 struct MousePosition {
    f32 x;
    f32 y;
 };

-struct RingSensorForce {
-    f32 force;
-};
-
 struct DeviceStatus {
    // Data from input_common
    KeyboardValues keyboard_values{};
@@ -59,7 +52,6 @@ struct DeviceStatus {
    MouseButtonValues mouse_button_values{};
    MouseAnalogValues mouse_analog_values{};
    MouseStickValue mouse_stick_value{};
-    RingAnalogValue ring_analog_value{};

    // Data for HID serices
    KeyboardKey keyboard_state{};
@@ -67,7 +59,6 @@ struct DeviceStatus {
    MouseButton mouse_button_state{};
    MousePosition mouse_position_state{};
    AnalogStickState mouse_wheel_state{};
-    RingSensorForce ring_analog_state{};
 };

 enum class DeviceTriggerType {
@@ -138,9 +129,6 @@ public:
    /// Returns the latest status of button input from the mouse with parameters
    MouseButtonValues GetMouseButtonsValues() const;

-    /// Returns the latest status of analog input from the ring sensor with parameters
-    RingAnalogValue GetRingSensorValues() const;
-
    /// Returns the latest status of button input from the keyboard
    KeyboardKey GetKeyboard() const;

@@ -156,9 +144,6 @@ public:
    /// Returns the latest mouse wheel change
    AnalogStickState GetMouseWheel() const;

-    /// Returns the latest ringcon force sensor value
-    RingSensorForce GetRingSensorForce() const;
-
    /**
     * Adds a callback to the list of events
     * @param update_callback InterfaceUpdateCallback that will be triggered
@@ -224,14 +209,11 @@ private:

    bool is_configuring{false};

-    RingAnalogParams ring_params;
-
    KeyboardDevices keyboard_devices;
    KeyboardModifierDevices keyboard_modifier_devices;
    MouseButtonDevices mouse_button_devices;
    MouseAnalogDevices mouse_analog_devices;
    MouseStickDevice mouse_stick_device;
-    RingAnalogDevice ring_analog_device;

    mutable std::mutex mutex;
    mutable std::mutex callback_mutex;
--- a/src/core/hid/input_converter.cpp
+++ b/src/core/hid/input_converter.cpp
@@ -304,6 +304,18 @@ Common::Input::NfcStatus TransformToNfc(const Common::Input::CallbackStatus& cal
    return nfc;
 }

+Common::Input::BodyColorStatus TransformToColor(const Common::Input::CallbackStatus& callback) {
+    switch (callback.type) {
+    case Common::Input::InputType::Color:
+        return callback.color_status;
+        break;
+    default:
+        LOG_ERROR(Input, "Conversion from type {} to color not implemented", callback.type);
+        return {};
+        break;
+    }
+}
+
 void SanitizeAnalog(Common::Input::AnalogStatus& analog, bool clamp_value) {
    const auto& properties = analog.properties;
    float& raw_value = analog.raw_value;
--- a/src/core/hid/input_converter.h
+++ b/src/core/hid/input_converter.h
@@ -88,10 +88,18 @@ Common::Input::CameraStatus TransformToCamera(const Common::Input::CallbackStatu
 * Converts raw input data into a valid nfc status.
 *
 * @param callback Supported callbacks: Nfc.
- * @return A valid CameraObject object.
+ * @return A valid data tag vector.
 */
 Common::Input::NfcStatus TransformToNfc(const Common::Input::CallbackStatus& callback);

+/**
+ * Converts raw input data into a valid color status.
+ *
+ * @param callback Supported callbacks: Color.
+ * @return A valid Color object.
+ */
+Common::Input::BodyColorStatus TransformToColor(const Common::Input::CallbackStatus& callback);
+
 /**
 * Converts raw analog data into a valid analog value
 * @param analog An analog object containing raw data and properties
--- a/src/core/hle/service/hid/controllers/npad.cpp
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@@ -272,6 +272,8 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
        }
        break;
    case Core::HID::NpadStyleIndex::JoyconLeft:
+        shared_memory->fullkey_color.attribute = ColorAttribute::Ok;
+        shared_memory->fullkey_color.fullkey = body_colors.left;
        shared_memory->joycon_color.attribute = ColorAttribute::Ok;
        shared_memory->joycon_color.left = body_colors.left;
        shared_memory->battery_level_dual = battery_level.left.battery_level;
@@ -285,6 +287,8 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
        shared_memory->sixaxis_left_properties.is_newly_assigned.Assign(1);
        break;
    case Core::HID::NpadStyleIndex::JoyconRight:
+        shared_memory->fullkey_color.attribute = ColorAttribute::Ok;
+        shared_memory->fullkey_color.fullkey = body_colors.right;
        shared_memory->joycon_color.attribute = ColorAttribute::Ok;
        shared_memory->joycon_color.right = body_colors.right;
        shared_memory->battery_level_right = battery_level.right.battery_level;
@@ -332,6 +336,8 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {

    controller.is_connected = true;
    controller.device->Connect();
+    controller.device->SetLedPattern();
+    controller.device->SetPollingMode(Common::Input::PollingMode::Active);
    SignalStyleSetChangedEvent(npad_id);
    WriteEmptyEntry(controller.shared_memory);
 }
--- a/src/core/hle/service/hid/hidbus.cpp
+++ b/src/core/hle/service/hid/hidbus.cpp
@@ -297,13 +297,13 @@ void HidBus::EnableExternalDevice(Kernel::HLERequestContext& ctx) {

    const auto parameters{rp.PopRaw<Parameters>()};

-    LOG_INFO(Service_HID,
-             "called, enable={}, abstracted_pad_id={}, bus_type={}, internal_index={}, "
-             "player_number={}, is_valid={}, inval={}, applet_resource_user_id{}",
-             parameters.enable, parameters.bus_handle.abstracted_pad_id,
-             parameters.bus_handle.bus_type, parameters.bus_handle.internal_index,
-             parameters.bus_handle.player_number, parameters.bus_handle.is_valid, parameters.inval,
-             parameters.applet_resource_user_id);
+    LOG_DEBUG(Service_HID,
+              "called, enable={}, abstracted_pad_id={}, bus_type={}, internal_index={}, "
+              "player_number={}, is_valid={}, inval={}, applet_resource_user_id{}",
+              parameters.enable, parameters.bus_handle.abstracted_pad_id,
+              parameters.bus_handle.bus_type, parameters.bus_handle.internal_index,
+              parameters.bus_handle.player_number, parameters.bus_handle.is_valid, parameters.inval,
+              parameters.applet_resource_user_id);

    const auto device_index = GetDeviceIndexFromHandle(parameters.bus_handle);

@@ -326,11 +326,11 @@ void HidBus::GetExternalDeviceId(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto bus_handle_{rp.PopRaw<BusHandle>()};

-    LOG_INFO(Service_HID,
-             "called, abstracted_pad_id={}, bus_type={}, internal_index={}, player_number={}, "
-             "is_valid={}",
-             bus_handle_.abstracted_pad_id, bus_handle_.bus_type, bus_handle_.internal_index,
-             bus_handle_.player_number, bus_handle_.is_valid);
+    LOG_DEBUG(Service_HID,
+              "called, abstracted_pad_id={}, bus_type={}, internal_index={}, player_number={}, "
+              "is_valid={}",
+              bus_handle_.abstracted_pad_id, bus_handle_.bus_type, bus_handle_.internal_index,
+              bus_handle_.player_number, bus_handle_.is_valid);

    const auto device_index = GetDeviceIndexFromHandle(bus_handle_);

--- a/src/core/hle/service/hid/hidbus/ringcon.cpp
+++ b/src/core/hle/service/hid/hidbus/ringcon.cpp
@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

-#include "core/hid/emulated_devices.h"
+#include "core/hid/emulated_controller.h"
 #include "core/hid/hid_core.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/kernel/k_readable_event.h"
@@ -12,16 +12,18 @@ namespace Service::HID {
 RingController::RingController(Core::HID::HIDCore& hid_core_,
                               KernelHelpers::ServiceContext& service_context_)
    : HidbusBase(service_context_) {
-    input = hid_core_.GetEmulatedDevices();
+    input = hid_core_.GetEmulatedController(Core::HID::NpadIdType::Player1);
 }

 RingController::~RingController() = default;

 void RingController::OnInit() {
+    input->SetPollingMode(Common::Input::PollingMode::Ring);
    return;
 }

 void RingController::OnRelease() {
+    input->SetPollingMode(Common::Input::PollingMode::Active);
    return;
 };

--- a/src/core/hle/service/hid/hidbus/ringcon.h
+++ b/src/core/hle/service/hid/hidbus/ringcon.h
@@ -9,7 +9,7 @@
 #include "core/hle/service/hid/hidbus/hidbus_base.h"

 namespace Core::HID {
-class EmulatedDevices;
+class EmulatedController;
 } // namespace Core::HID

 namespace Service::HID {
@@ -248,6 +248,6 @@ private:
        .zero = {.value = idle_value, .crc = 225},
    };

-    Core::HID::EmulatedDevices* input;
+    Core::HID::EmulatedController* input;
 };
 } // namespace Service::HID