core/hid: Rework battery mappings

src/core/hid/emulated_controller.cpp

@@ -87,11 +87,23 @@ void EmulatedController::ReloadFromSettings() {
 
     ReloadInput();
 }
+void EmulatedController::LoadDevices() {
+    const auto left_joycon = button_params[Settings::NativeButton::ZL];
+    const auto right_joycon = button_params[Settings::NativeButton::ZR];
 
-void EmulatedController::ReloadInput() {
-    // If you load any device here add the equivalent to the UnloadInput() function
-    const auto left_side = button_params[Settings::NativeButton::ZL];
-    const auto right_side = button_params[Settings::NativeButton::ZR];
+    // Triggers for GC controllers
+    trigger_params[LeftIndex] = button_params[Settings::NativeButton::ZL];
+    trigger_params[RightIndex] = button_params[Settings::NativeButton::ZR];
+
+    battery_params[LeftIndex] = left_joycon;
+    battery_params[RightIndex] = right_joycon;
+    battery_params[LeftIndex].Set("battery", true);
+    battery_params[RightIndex].Set("battery", true);
+
+    output_params[LeftIndex] = left_joycon;
+    output_params[RightIndex] = right_joycon;
+    output_params[LeftIndex].Set("output", true);
+    output_params[RightIndex].Set("output", true);
 
     std::transform(button_params.begin() + Settings::NativeButton::BUTTON_HID_BEGIN,
                    button_params.begin() + Settings::NativeButton::BUTTON_NS_END,
@@ -102,19 +114,17 @@ void EmulatedController::ReloadInput() {
     std::transform(motion_params.begin() + Settings::NativeMotion::MOTION_HID_BEGIN,
                    motion_params.begin() + Settings::NativeMotion::MOTION_HID_END,
                    motion_devices.begin(), Input::CreateDevice<Input::InputDevice>);
+    std::transform(trigger_params.begin(), trigger_params.end(), trigger_devices.begin(),
+                   Input::CreateDevice<Input::InputDevice>);
+    std::transform(battery_params.begin(), battery_params.begin(), battery_devices.end(),
+                   Input::CreateDevice<Input::InputDevice>);
+    std::transform(output_params.begin(), output_params.end(), output_devices.begin(),
+                   Input::CreateDevice<Input::OutputDevice>);
+}
 
-    trigger_devices[0] =
-        Input::CreateDevice<Input::InputDevice>(button_params[Settings::NativeButton::ZL]);
-    trigger_devices[1] =
-        Input::CreateDevice<Input::InputDevice>(button_params[Settings::NativeButton::ZR]);
-
-    battery_devices[0] = Input::CreateDevice<Input::InputDevice>(left_side);
-    battery_devices[1] = Input::CreateDevice<Input::InputDevice>(right_side);
-
-    button_params[Settings::NativeButton::ZL].Set("output", true);
-    output_devices[0] =
-        Input::CreateDevice<Input::OutputDevice>(button_params[Settings::NativeButton::ZL]);
-
+void EmulatedController::ReloadInput() {
+    // If you load any device here add the equivalent to the UnloadInput() function
+    LoadDevices();
     for (std::size_t index = 0; index < button_devices.size(); ++index) {
         if (!button_devices[index]) {
             continue;
@@ -241,7 +251,7 @@ void EmulatedController::RestoreConfig() {
     ReloadFromSettings();
 }
 
-std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices() const {
+std::vector<Common::ParamPackage> EmulatedController::GetMappedDevices(DeviceIndex device_index) const {
     std::vector<Common::ParamPackage> devices;
     for (const auto& param : button_params) {
         if (!param.Has("engine")) {
@@ -612,21 +622,21 @@ void EmulatedController::SetBattery(Input::CallbackStatus callback, std::size_t
     }
 
     switch (index) {
-    case 0:
+    case LeftIndex:
         controller.battery_state.left = {
             .is_powered = is_powered,
             .is_charging = is_charging,
             .battery_level = battery_level,
         };
         break;
-    case 1:
+    case RightIndex:
         controller.battery_state.right = {
             .is_powered = is_powered,
             .is_charging = is_charging,
             .battery_level = battery_level,
         };
         break;
-    case 2:
+    case DualIndex:
         controller.battery_state.dual = {
             .is_powered = is_powered,
             .is_charging = is_charging,

src/core/hid/emulated_controller.h

@@ -18,7 +18,7 @@
 #include "core/hid/motion_input.h"
 
 namespace Core::HID {
-
+const std::size_t max_emulated_controllers = 2;
 struct ControllerMotionInfo {
     Input::MotionStatus raw_status{};
     MotionInput emulated{};
@@ -32,23 +32,23 @@ using ControllerMotionDevices =
     std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeMotion::NumMotions>;
 using TriggerDevices =
     std::array<std::unique_ptr<Input::InputDevice>, Settings::NativeTrigger::NumTriggers>;
-using BatteryDevices = std::array<std::unique_ptr<Input::InputDevice>, 2>;
-using OutputDevices = std::array<std::unique_ptr<Input::OutputDevice>, 2>;
+using BatteryDevices = std::array<std::unique_ptr<Input::InputDevice>, max_emulated_controllers>;
+using OutputDevices = std::array<std::unique_ptr<Input::OutputDevice>, max_emulated_controllers>;
 
 using ButtonParams = std::array<Common::ParamPackage, Settings::NativeButton::NumButtons>;
 using StickParams = std::array<Common::ParamPackage, Settings::NativeAnalog::NumAnalogs>;
 using ControllerMotionParams = std::array<Common::ParamPackage, Settings::NativeMotion::NumMotions>;
 using TriggerParams = std::array<Common::ParamPackage, Settings::NativeTrigger::NumTriggers>;
-using BatteryParams = std::array<Common::ParamPackage, 2>;
-using OutputParams = std::array<Common::ParamPackage, 2>;
+using BatteryParams = std::array<Common::ParamPackage, max_emulated_controllers>;
+using OutputParams = std::array<Common::ParamPackage, max_emulated_controllers>;
 
 using ButtonValues = std::array<Input::ButtonStatus, Settings::NativeButton::NumButtons>;
 using SticksValues = std::array<Input::StickStatus, Settings::NativeAnalog::NumAnalogs>;
 using TriggerValues = std::array<Input::TriggerStatus, Settings::NativeTrigger::NumTriggers>;
 using ControllerMotionValues = std::array<ControllerMotionInfo, Settings::NativeMotion::NumMotions>;
-using ColorValues = std::array<Input::BodyColorStatus, 3>;
-using BatteryValues = std::array<Input::BatteryStatus, 3>;
-using VibrationValues = std::array<Input::VibrationStatus, 2>;
+using ColorValues = std::array<Input::BodyColorStatus, max_emulated_controllers>;
+using BatteryValues = std::array<Input::BatteryStatus, max_emulated_controllers>;
+using VibrationValues = std::array<Input::VibrationStatus, max_emulated_controllers>;
 
 struct AnalogSticks {
     AnalogStickState left{};
@@ -75,6 +75,13 @@ struct ControllerMotion {
     bool is_at_rest{};
 };
 
+enum DeviceIndex : u8 {
+    LeftIndex,
+    RightIndex,
+    DualIndex,
+    AllDevices,
+};
+
 using MotionState = std::array<ControllerMotion, 2>;
 
 struct ControllerStatus {
@@ -189,7 +196,7 @@ public:
     void RestoreConfig();
 
     /// Returns a vector of mapped devices from the mapped button and stick parameters
-    std::vector<Common::ParamPackage> GetMappedDevices() const;
+    std::vector<Common::ParamPackage> GetMappedDevices(DeviceIndex device_index) const;
 
     // Returns the current mapped button device
     Common::ParamPackage GetButtonParam(std::size_t index) const;
@@ -289,6 +296,9 @@ public:
     void DeleteCallback(int key);
 
 private:
+    /// creates input devices from params
+    void LoadDevices();
+
     /**
      * Updates the button status of the controller
      * @param callback: A CallbackStatus containing the button status

src/core/hid/emulated_devices.cpp

@@ -174,7 +174,7 @@ void EmulatedDevices::UpdateKey(std::size_t key_index, bool status) {
     if (status) {
         entry = entry | mask;
     } else {
-        entry = entry & ~mask;
+        entry = static_cast<u8>(entry & ~mask);
     }
 }
 

src/core/hid/input_converter.cpp

@@ -33,6 +33,10 @@ Input::BatteryStatus TransformToBattery(const Input::CallbackStatus& callback) {
         }
         break;
     }
+    case Input::InputType::Button:
+        battery = callback.button_status.value ? Input::BatteryLevel::Charging
+                                               : Input::BatteryLevel::Critical;
+        break;
     case Input::InputType::Battery:
         battery = callback.battery_status;
         break;

src/core/hle/service/hid/controllers/npad.cpp

@@ -101,8 +101,9 @@ Controller_NPad::Controller_NPad(Core::System& system_,
     for (std::size_t i = 0; i < controller_data.size(); ++i) {
         auto& controller = controller_data[i];
         controller.device = system.HIDCore().GetEmulatedControllerByIndex(i);
-        controller.vibration[0].latest_vibration_value = DEFAULT_VIBRATION_VALUE;
-        controller.vibration[1].latest_vibration_value = DEFAULT_VIBRATION_VALUE;
+        controller.vibration[Core::HID::DeviceIndex::LeftIndex].latest_vibration_value = DEFAULT_VIBRATION_VALUE;
+        controller.vibration[Core::HID::DeviceIndex::RightIndex].latest_vibration_value =
+            DEFAULT_VIBRATION_VALUE;
         Core::HID::ControllerUpdateCallback engine_callback{
             .on_change = [this,
                           i](Core::HID::ControllerTriggerType type) { ControllerUpdate(type, i); },
@@ -285,9 +286,12 @@ void Controller_NPad::OnInit() {
         auto& npad = controller.shared_memory_entry;
         npad.fullkey_color = {
             .attribute = ColorAttribute::NoController,
+            .fullkey = {},
         };
         npad.joycon_color = {
             .attribute = ColorAttribute::NoController,
+            .left = {},
+            .right = {},
         };
         // HW seems to initialize the first 19 entries
         for (std::size_t i = 0; i < 19; ++i) {
@@ -907,9 +911,12 @@ void Controller_NPad::DisconnectNpadAtIndex(std::size_t npad_index) {
     shared_memory_entry.battery_level_right = 0;
     shared_memory_entry.fullkey_color = {
         .attribute = ColorAttribute::NoController,
+        .fullkey = {},
     };
     shared_memory_entry.joycon_color = {
         .attribute = ColorAttribute::NoController,
+        .left = {},
+        .right = {},
     };
     shared_memory_entry.assignment_mode = NpadJoyAssignmentMode::Dual;
     shared_memory_entry.footer_type = AppletFooterUiType::None;

src/input_common/helpers/stick_from_buttons.cpp

@@ -200,7 +200,7 @@ public:
         TriggerOnChange(status);
     }
 
-    void ForceUpdate() override{
+    void ForceUpdate() override {
         up->ForceUpdate();
         down->ForceUpdate();
         left->ForceUpdate();

src/input_common/input_poller.cpp

@@ -183,6 +183,17 @@ public:
         return status;
     }
 
+    void ForceUpdate() {
+        const Input::CallbackStatus status{
+            .type = Input::InputType::Stick,
+            .stick_status = GetStatus(),
+        };
+
+        last_axis_x_value = status.stick_status.x.raw_value;
+        last_axis_y_value = status.stick_status.y.raw_value;
+        TriggerOnChange(status);
+    }
+
     void OnChange() {
         const Input::CallbackStatus status{
             .type = Input::InputType::Stick,
@@ -448,6 +459,16 @@ public:
         return static_cast<Input::BatteryLevel>(input_engine->GetBattery(identifier));
     }
 
+    void ForceUpdate() {
+        const Input::CallbackStatus status{
+            .type = Input::InputType::Battery,
+            .battery_status = GetStatus(),
+        };
+
+        last_battery_value = status.battery_status;
+        TriggerOnChange(status);
+    }
+
     void OnChange() {
         const Input::CallbackStatus status{
             .type = Input::InputType::Battery,
@@ -579,6 +600,18 @@ public:
         return status;
     }
 
+    void ForceUpdate() {
+        const Input::CallbackStatus status{
+            .type = Input::InputType::Motion,
+            .motion_status = GetStatus(),
+        };
+
+        last_axis_x_value = status.motion_status.gyro.x.raw_value;
+        last_axis_y_value = status.motion_status.gyro.y.raw_value;
+        last_axis_z_value = status.motion_status.gyro.z.raw_value;
+        TriggerOnChange(status);
+    }
+
     void OnChange() {
         const Input::CallbackStatus status{
             .type = Input::InputType::Motion,
@@ -868,6 +901,9 @@ 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) {
+    if (params.Has("battery")) {
+        return CreateBatteryDevice(params);
+    }
     if (params.Has("button") && params.Has("axis")) {
         return CreateTriggerDevice(params);
     }
@@ -892,9 +928,6 @@ std::unique_ptr<Input::InputDevice> InputFactory::Create(const Common::ParamPack
     if (params.Has("axis")) {
         return CreateAnalogDevice(params);
     }
-    if (params.Has("battery")) {
-        return CreateBatteryDevice(params);
-    }
     LOG_ERROR(Input, "Invalid parameters given");
     return std::make_unique<DummyInput>();
 }

src/yuzu/configuration/configure_input_player.cpp

@@ -630,7 +630,7 @@ void ConfigureInputPlayer::UpdateInputDeviceCombobox() {
         return;
     }
 
-    const auto devices = emulated_controller->GetMappedDevices();
+    const auto devices = emulated_controller->GetMappedDevices(Core::HID::DeviceIndex::AllDevices);
     UpdateInputDevices();
 
     if (devices.empty()) {

src/yuzu/configuration/configure_input_player_widget.cpp

@@ -356,7 +356,7 @@ void PlayerControlPreview::DrawLeftController(QPainter& p, const QPointF center)
     DrawCircle(p, center + QPoint(26, 71), 5);
 
     // Draw battery
-    DrawBattery(p, center + QPoint(-170, -140), battery_values[0]);
+    DrawBattery(p, center + QPoint(-170, -140), battery_values[Core::HID::DeviceIndex::LeftIndex]);
 }
 
 void PlayerControlPreview::DrawRightController(QPainter& p, const QPointF center) {
@@ -482,7 +482,7 @@ void PlayerControlPreview::DrawRightController(QPainter& p, const QPointF center
     DrawSymbol(p, center + QPoint(-26, 66), Symbol::House, 5);
 
     // Draw battery
-    DrawBattery(p, center + QPoint(110, -140), battery_values[1]);
+    DrawBattery(p, center + QPoint(110, -140), battery_values[Core::HID::DeviceIndex::RightIndex]);
 }
 
 void PlayerControlPreview::DrawDualController(QPainter& p, const QPointF center) {
@@ -618,8 +618,8 @@ void PlayerControlPreview::DrawDualController(QPainter& p, const QPointF center)
     DrawSymbol(p, center + QPoint(50, 60), Symbol::House, 4.2f);
 
     // Draw battery
-    DrawBattery(p, center + QPoint(-100, -160), battery_values[0]);
-    DrawBattery(p, center + QPoint(40, -160), battery_values[1]);
+    DrawBattery(p, center + QPoint(-100, -160), battery_values[Core::HID::DeviceIndex::LeftIndex]);
+    DrawBattery(p, center + QPoint(40, -160), battery_values[Core::HID::DeviceIndex::RightIndex]);
 }
 
 void PlayerControlPreview::DrawHandheldController(QPainter& p, const QPointF center) {
@@ -720,9 +720,8 @@ void PlayerControlPreview::DrawHandheldController(QPainter& p, const QPointF cen
     DrawSymbol(p, center + QPoint(161, 37), Symbol::House, 2.75f);
 
     // Draw battery
-    DrawBattery(p, center + QPoint(-200, 110), battery_values[0]);
-    DrawBattery(p, center + QPoint(-30, 110), battery_values[1]);
-    DrawBattery(p, center + QPoint(130, 110), battery_values[2]);
+    DrawBattery(p, center + QPoint(-200, 110), battery_values[Core::HID::DeviceIndex::LeftIndex]);
+    DrawBattery(p, center + QPoint(130, 110), battery_values[Core::HID::DeviceIndex::RightIndex]);
 }
 
 void PlayerControlPreview::DrawProController(QPainter& p, const QPointF center) {
@@ -812,7 +811,7 @@ void PlayerControlPreview::DrawProController(QPainter& p, const QPointF center)
     DrawSymbol(p, center + QPoint(29, -56), Symbol::House, 3.9f);
 
     // Draw battery
-    DrawBattery(p, center + QPoint(-30, -160), battery_values[0]);
+    DrawBattery(p, center + QPoint(-30, -160), battery_values[Core::HID::DeviceIndex::LeftIndex]);
 }
 
 void PlayerControlPreview::DrawGCController(QPainter& p, const QPointF center) {
@@ -868,7 +867,7 @@ void PlayerControlPreview::DrawGCController(QPainter& p, const QPointF center) {
     DrawCircleButton(p, center + QPoint(0, -44), button_values[Plus], 8);
 
     // Draw battery
-    DrawBattery(p, center + QPoint(-30, -165), battery_values[0]);
+    DrawBattery(p, center + QPoint(-30, -165), battery_values[Core::HID::DeviceIndex::LeftIndex]);
 }
 
 constexpr std::array<float, 13 * 2> symbol_a = {