VERY experimental Nintendo Switch 2 emulator
C++
service: hid: Fully implement abstract vibration
Narr the Rege2313faec9c3
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cppindex 4ce0a9834e..0c0b3cd47d 100644--- a/src/core/hle/service/hid/hid.cpp+++ b/src/core/hle/service/hid/hid.cpp@@ -26,6 +26,7 @@ void LoopProcess(Core::System& system) {resource_manager->Initialize();resource_manager->RegisterAppletResourceUserId(system.ApplicationProcess()->GetProcessId(),true);+ resource_manager->SetAruidValidForVibration(system.ApplicationProcess()->GetProcessId(), true);server_manager->RegisterNamedService("hid", std::make_shared<IHidServer>(system, resource_manager, firmware_settings));diff --git a/src/core/hle/service/hid/hid_server.cpp b/src/core/hle/service/hid/hid_server.cppindex 1951da33ba..30afed8122 100644--- a/src/core/hle/service/hid/hid_server.cpp+++ b/src/core/hle/service/hid/hid_server.cpp@@ -22,12 +22,16 @@#include "hid_core/resources/mouse/mouse.h"#include "hid_core/resources/npad/npad.h"#include "hid_core/resources/npad/npad_types.h"+#include "hid_core/resources/npad/npad_vibration.h"#include "hid_core/resources/palma/palma.h"#include "hid_core/resources/six_axis/console_six_axis.h"#include "hid_core/resources/six_axis/seven_six_axis.h"#include "hid_core/resources/six_axis/six_axis.h"#include "hid_core/resources/touch_screen/gesture.h"#include "hid_core/resources/touch_screen/touch_screen.h"+#include "hid_core/resources/vibration/gc_vibration_device.h"+#include "hid_core/resources/vibration/n64_vibration_device.h"+#include "hid_core/resources/vibration/vibration_device.h"namespace Service::HID {@@ -38,7 +42,7 @@ public:: ServiceFramework{system_, "IActiveVibrationDeviceList"}, resource_manager(resource) {// clang-format offstatic const FunctionInfo functions[] = {- {0, &IActiveVibrationDeviceList::InitializeVibrationDevice, "InitializeVibrationDevice"},+ {0, &IActiveVibrationDeviceList::ActivateVibrationDevice, "ActivateVibrationDevice"},};// clang-format on@@ -46,22 +50,49 @@ public:}private:- void InitializeVibrationDevice(HLERequestContext& ctx) {+ void ActivateVibrationDevice(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto vibration_device_handle{rp.PopRaw<Core::HID::VibrationDeviceHandle>()};- if (resource_manager != nullptr && resource_manager->GetNpad()) {- resource_manager->GetNpad()->InitializeVibrationDevice(vibration_device_handle);- }-LOG_DEBUG(Service_HID, "called, npad_type={}, npad_id={}, device_index={}",vibration_device_handle.npad_type, vibration_device_handle.npad_id,vibration_device_handle.device_index);+ const auto result = ActivateVibrationDeviceImpl(vibration_device_handle);+IPC::ResponseBuilder rb{ctx, 2};- rb.Push(ResultSuccess);+ rb.Push(result);}+ Result ActivateVibrationDeviceImpl(const Core::HID::VibrationDeviceHandle& handle) {+ std::scoped_lock lock{mutex};++ const Result is_valid = IsVibrationHandleValid(handle);+ if (is_valid.IsError()) {+ return is_valid;+ }++ for (std::size_t i = 0; i < list_size; i++) {+ if (handle.device_index == vibration_device_list[i].device_index &&+ handle.npad_id == vibration_device_list[i].npad_id &&+ handle.npad_type == vibration_device_list[i].npad_type) {+ return ResultSuccess;+ }+ }+ if (list_size == vibration_device_list.size()) {+ return ResultVibrationDeviceIndexOutOfRange;+ }+ const Result result = resource_manager->GetVibrationDevice(handle)->Activate();+ if (result.IsError()) {+ return result;+ }+ vibration_device_list[list_size++] = handle;+ return ResultSuccess;+ }++ mutable std::mutex mutex;+ std::size_t list_size{};+ std::array<Core::HID::VibrationDeviceHandle, 0x100> vibration_device_list{};std::shared_ptr<ResourceManager> resource_manager;};@@ -153,7 +184,7 @@ IHidServer::IHidServer(Core::System& system_, std::shared_ptr<ResourceManager> r{209, &IHidServer::BeginPermitVibrationSession, "BeginPermitVibrationSession"},{210, &IHidServer::EndPermitVibrationSession, "EndPermitVibrationSession"},{211, &IHidServer::IsVibrationDeviceMounted, "IsVibrationDeviceMounted"},- {212, nullptr, "SendVibrationValueInBool"},+ {212, &IHidServer::SendVibrationValueInBool, "SendVibrationValueInBool"},{300, &IHidServer::ActivateConsoleSixAxisSensor, "ActivateConsoleSixAxisSensor"},{301, &IHidServer::StartConsoleSixAxisSensor, "StartConsoleSixAxisSensor"},{302, &IHidServer::StopConsoleSixAxisSensor, "StopConsoleSixAxisSensor"},@@ -1492,59 +1523,13 @@ void IHidServer::ClearNpadCaptureButtonAssignment(HLERequestContext& ctx) {void IHidServer::GetVibrationDeviceInfo(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto vibration_device_handle{rp.PopRaw<Core::HID::VibrationDeviceHandle>()};- const auto controller = GetResourceManager()->GetNpad();-- Core::HID::VibrationDeviceInfo vibration_device_info;- bool check_device_index = false;-- switch (vibration_device_handle.npad_type) {- case Core::HID::NpadStyleIndex::Fullkey:- case Core::HID::NpadStyleIndex::Handheld:- case Core::HID::NpadStyleIndex::JoyconDual:- case Core::HID::NpadStyleIndex::JoyconLeft:- case Core::HID::NpadStyleIndex::JoyconRight:- vibration_device_info.type = Core::HID::VibrationDeviceType::LinearResonantActuator;- check_device_index = true;- break;- case Core::HID::NpadStyleIndex::GameCube:- vibration_device_info.type = Core::HID::VibrationDeviceType::GcErm;- break;- case Core::HID::NpadStyleIndex::N64:- vibration_device_info.type = Core::HID::VibrationDeviceType::N64;- break;- default:- vibration_device_info.type = Core::HID::VibrationDeviceType::Unknown;- break;- }-- vibration_device_info.position = Core::HID::VibrationDevicePosition::None;- if (check_device_index) {- switch (vibration_device_handle.device_index) {- case Core::HID::DeviceIndex::Left:- vibration_device_info.position = Core::HID::VibrationDevicePosition::Left;- break;- case Core::HID::DeviceIndex::Right:- vibration_device_info.position = Core::HID::VibrationDevicePosition::Right;- break;- case Core::HID::DeviceIndex::None:- default:- ASSERT_MSG(false, "DeviceIndex should never be None!");- break;- }- }- LOG_DEBUG(Service_HID, "called, vibration_device_type={}, vibration_device_position={}",- vibration_device_info.type, vibration_device_info.position);-- const auto result = IsVibrationHandleValid(vibration_device_handle);- if (result.IsError()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(result);- return;- }+ Core::HID::VibrationDeviceInfo vibration_device_info{};+ const auto result = GetResourceManager()->GetVibrationDeviceInfo(vibration_device_info,+ vibration_device_handle);IPC::ResponseBuilder rb{ctx, 4};- rb.Push(ResultSuccess);+ rb.Push(result);rb.PushRaw(vibration_device_info);}@@ -1560,16 +1545,16 @@ void IHidServer::SendVibrationValue(HLERequestContext& ctx) {const auto parameters{rp.PopRaw<Parameters>()};- GetResourceManager()->GetNpad()->VibrateController(parameters.applet_resource_user_id,- parameters.vibration_device_handle,- parameters.vibration_value);-LOG_DEBUG(Service_HID,"called, npad_type={}, npad_id={}, device_index={}, applet_resource_user_id={}",parameters.vibration_device_handle.npad_type,parameters.vibration_device_handle.npad_id,parameters.vibration_device_handle.device_index, parameters.applet_resource_user_id);+ GetResourceManager()->SendVibrationValue(parameters.applet_resource_user_id,+ parameters.vibration_device_handle,+ parameters.vibration_value);+IPC::ResponseBuilder rb{ctx, 2};rb.Push(ResultSuccess);}@@ -1591,10 +1576,28 @@ void IHidServer::GetActualVibrationValue(HLERequestContext& ctx) {parameters.vibration_device_handle.npad_id,parameters.vibration_device_handle.device_index, parameters.applet_resource_user_id);+ bool has_active_aruid{};+ NpadVibrationDevice* device{nullptr};+ Core::HID::VibrationValue vibration_value{};+ Result result = GetResourceManager()->IsVibrationAruidActive(parameters.applet_resource_user_id,+ has_active_aruid);++ if (result.IsSuccess() && has_active_aruid) {+ result = IsVibrationHandleValid(parameters.vibration_device_handle);+ }+ if (result.IsSuccess() && has_active_aruid) {+ device = GetResourceManager()->GetNSVibrationDevice(parameters.vibration_device_handle);+ }+ if (device != nullptr) {+ result = device->GetActualVibrationValue(vibration_value);+ }+ if (result.IsError()) {+ vibration_value = Core::HID::DEFAULT_VIBRATION_VALUE;+ }+IPC::ResponseBuilder rb{ctx, 6};rb.Push(ResultSuccess);- rb.PushRaw(GetResourceManager()->GetNpad()->GetLastVibration(- parameters.applet_resource_user_id, parameters.vibration_device_handle));+ rb.PushRaw(vibration_value);}void IHidServer::CreateActiveVibrationDeviceList(HLERequestContext& ctx) {@@ -1609,25 +1612,27 @@ void IHidServer::PermitVibration(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto can_vibrate{rp.Pop<bool>()};- // nnSDK saves this value as a float. Since it can only be 1.0f or 0.0f we simplify this value- // by converting it to a bool- Settings::values.vibration_enabled.SetValue(can_vibrate);-LOG_DEBUG(Service_HID, "called, can_vibrate={}", can_vibrate);+ const auto result =+ GetResourceManager()->GetNpad()->GetVibrationHandler()->SetVibrationMasterVolume(+ can_vibrate ? 1.0f : 0.0f);+IPC::ResponseBuilder rb{ctx, 2};- rb.Push(ResultSuccess);+ rb.Push(result);}void IHidServer::IsVibrationPermitted(HLERequestContext& ctx) {LOG_DEBUG(Service_HID, "called");- // nnSDK checks if a float is greater than zero. We return the bool we stored earlier- const auto is_enabled = Settings::values.vibration_enabled.GetValue();+ f32 master_volume{};+ const auto result =+ GetResourceManager()->GetNpad()->GetVibrationHandler()->GetVibrationMasterVolume(+ master_volume);IPC::ResponseBuilder rb{ctx, 3};- rb.Push(ResultSuccess);- rb.Push(is_enabled);+ rb.Push(result);+ rb.Push(master_volume > 0.0f);}void IHidServer::SendVibrationValues(HLERequestContext& ctx) {@@ -1645,13 +1650,22 @@ void IHidServer::SendVibrationValues(HLERequestContext& ctx) {auto vibration_values = std::span(reinterpret_cast<const Core::HID::VibrationValue*>(vibration_data.data()), vibration_count);- GetResourceManager()->GetNpad()->VibrateControllers(applet_resource_user_id,- vibration_device_handles, vibration_values);-LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);+ Result result = ResultSuccess;+ if (handle_count != vibration_count) {+ result = ResultVibrationArraySizeMismatch;+ }++ for (std::size_t i = 0; i < handle_count; i++) {+ if (result.IsSuccess()) {+ result = GetResourceManager()->SendVibrationValue(+ applet_resource_user_id, vibration_device_handles[i], vibration_values[i]);+ }+ }+IPC::ResponseBuilder rb{ctx, 2};- rb.Push(ResultSuccess);+ rb.Push(result);}void IHidServer::SendVibrationGcErmCommand(HLERequestContext& ctx) {@@ -1666,43 +1680,6 @@ void IHidServer::SendVibrationGcErmCommand(HLERequestContext& ctx) {const auto parameters{rp.PopRaw<Parameters>()};- /**- * Note: This uses yuzu-specific behavior such that the StopHard command produces- * vibrations where freq_low == 0.0f and freq_high == 0.0f, as defined below,- * in order to differentiate between Stop and StopHard commands.- * This is done to reuse the controller vibration functions made for regular controllers.- */- const auto vibration_value = [parameters] {- switch (parameters.gc_erm_command) {- case Core::HID::VibrationGcErmCommand::Stop:- return Core::HID::VibrationValue{- .low_amplitude = 0.0f,- .low_frequency = 160.0f,- .high_amplitude = 0.0f,- .high_frequency = 320.0f,- };- case Core::HID::VibrationGcErmCommand::Start:- return Core::HID::VibrationValue{- .low_amplitude = 1.0f,- .low_frequency = 160.0f,- .high_amplitude = 1.0f,- .high_frequency = 320.0f,- };- case Core::HID::VibrationGcErmCommand::StopHard:- return Core::HID::VibrationValue{- .low_amplitude = 0.0f,- .low_frequency = 0.0f,- .high_amplitude = 0.0f,- .high_frequency = 0.0f,- };- default:- return Core::HID::DEFAULT_VIBRATION_VALUE;- }- }();-- GetResourceManager()->GetNpad()->VibrateController(- parameters.applet_resource_user_id, parameters.vibration_device_handle, vibration_value);-LOG_DEBUG(Service_HID,"called, npad_type={}, npad_id={}, device_index={}, applet_resource_user_id={}, ""gc_erm_command={}",@@ -1711,8 +1688,23 @@ void IHidServer::SendVibrationGcErmCommand(HLERequestContext& ctx) {parameters.vibration_device_handle.device_index, parameters.applet_resource_user_id,parameters.gc_erm_command);+ bool has_active_aruid{};+ NpadGcVibrationDevice* gc_device{nullptr};+ Result result = GetResourceManager()->IsVibrationAruidActive(parameters.applet_resource_user_id,+ has_active_aruid);++ if (result.IsSuccess() && has_active_aruid) {+ result = IsVibrationHandleValid(parameters.vibration_device_handle);+ }+ if (result.IsSuccess() && has_active_aruid) {+ gc_device = GetResourceManager()->GetGcVibrationDevice(parameters.vibration_device_handle);+ }+ if (gc_device != nullptr) {+ result = gc_device->SendVibrationGcErmCommand(parameters.gc_erm_command);+ }+IPC::ResponseBuilder rb{ctx, 2};- rb.Push(ResultSuccess);+ rb.Push(result);}void IHidServer::GetActualVibrationGcErmCommand(HLERequestContext& ctx) {@@ -1725,33 +1717,31 @@ void IHidServer::GetActualVibrationGcErmCommand(HLERequestContext& ctx) {const auto parameters{rp.PopRaw<Parameters>()};- const auto last_vibration = GetResourceManager()->GetNpad()->GetLastVibration(- parameters.applet_resource_user_id, parameters.vibration_device_handle);-- const auto gc_erm_command = [last_vibration] {- if (last_vibration.low_amplitude != 0.0f || last_vibration.high_amplitude != 0.0f) {- return Core::HID::VibrationGcErmCommand::Start;- }-- /**- * Note: This uses yuzu-specific behavior such that the StopHard command produces- * vibrations where freq_low == 0.0f and freq_high == 0.0f, as defined in the HID function- * SendVibrationGcErmCommand, in order to differentiate between Stop and StopHard commands.- * This is done to reuse the controller vibration functions made for regular controllers.- */- if (last_vibration.low_frequency == 0.0f && last_vibration.high_frequency == 0.0f) {- return Core::HID::VibrationGcErmCommand::StopHard;- }-- return Core::HID::VibrationGcErmCommand::Stop;- }();-LOG_DEBUG(Service_HID,"called, npad_type={}, npad_id={}, device_index={}, applet_resource_user_id={}",parameters.vibration_device_handle.npad_type,parameters.vibration_device_handle.npad_id,parameters.vibration_device_handle.device_index, parameters.applet_resource_user_id);+ bool has_active_aruid{};+ NpadGcVibrationDevice* gc_device{nullptr};+ Core::HID::VibrationGcErmCommand gc_erm_command{};+ Result result = GetResourceManager()->IsVibrationAruidActive(parameters.applet_resource_user_id,+ has_active_aruid);++ if (result.IsSuccess() && has_active_aruid) {+ result = IsVibrationHandleValid(parameters.vibration_device_handle);+ }+ if (result.IsSuccess() && has_active_aruid) {+ gc_device = GetResourceManager()->GetGcVibrationDevice(parameters.vibration_device_handle);+ }+ if (gc_device != nullptr) {+ result = gc_device->GetActualVibrationGcErmCommand(gc_erm_command);+ }+ if (result.IsError()) {+ gc_erm_command = Core::HID::VibrationGcErmCommand::Stop;+ }+IPC::ResponseBuilder rb{ctx, 4};rb.Push(ResultSuccess);rb.PushEnum(gc_erm_command);@@ -1761,21 +1751,24 @@ void IHidServer::BeginPermitVibrationSession(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto applet_resource_user_id{rp.Pop<u64>()};- GetResourceManager()->GetNpad()->SetPermitVibrationSession(true);-LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);+ const auto result =+ GetResourceManager()->GetNpad()->GetVibrationHandler()->BeginPermitVibrationSession(+ applet_resource_user_id);+IPC::ResponseBuilder rb{ctx, 2};- rb.Push(ResultSuccess);+ rb.Push(result);}void IHidServer::EndPermitVibrationSession(HLERequestContext& ctx) {- GetResourceManager()->GetNpad()->SetPermitVibrationSession(false);-LOG_DEBUG(Service_HID, "called");+ const auto result =+ GetResourceManager()->GetNpad()->GetVibrationHandler()->EndPermitVibrationSession();+IPC::ResponseBuilder rb{ctx, 2};- rb.Push(ResultSuccess);+ rb.Push(result);}void IHidServer::IsVibrationDeviceMounted(HLERequestContext& ctx) {@@ -1795,10 +1788,61 @@ void IHidServer::IsVibrationDeviceMounted(HLERequestContext& ctx) {parameters.vibration_device_handle.npad_id,parameters.vibration_device_handle.device_index, parameters.applet_resource_user_id);+ bool is_mounted{};+ NpadVibrationBase* device{nullptr};+ Result result = IsVibrationHandleValid(parameters.vibration_device_handle);++ if (result.IsSuccess()) {+ device = GetResourceManager()->GetVibrationDevice(parameters.vibration_device_handle);+ }++ if (device != nullptr) {+ is_mounted = device->IsVibrationMounted();+ }+IPC::ResponseBuilder rb{ctx, 3};- rb.Push(ResultSuccess);- rb.Push(GetResourceManager()->GetNpad()->IsVibrationDeviceMounted(- parameters.applet_resource_user_id, parameters.vibration_device_handle));+ rb.Push(result);+ rb.Push(is_mounted);+}++void IHidServer::SendVibrationValueInBool(HLERequestContext& ctx) {+ IPC::RequestParser rp{ctx};+ struct Parameters {+ Core::HID::VibrationDeviceHandle vibration_device_handle;+ INSERT_PADDING_WORDS_NOINIT(1);+ u64 applet_resource_user_id;+ bool is_vibrating;+ };+ static_assert(sizeof(Parameters) == 0x18, "Parameters has incorrect size.");++ const auto parameters{rp.PopRaw<Parameters>()};++ LOG_DEBUG(Service_HID,+ "called, npad_type={}, npad_id={}, device_index={}, applet_resource_user_id={}, "+ "is_vibrating={}",+ parameters.vibration_device_handle.npad_type,+ parameters.vibration_device_handle.npad_id,+ parameters.vibration_device_handle.device_index, parameters.applet_resource_user_id,+ parameters.is_vibrating);++ bool has_active_aruid{};+ NpadN64VibrationDevice* n64_device{nullptr};+ Result result = GetResourceManager()->IsVibrationAruidActive(parameters.applet_resource_user_id,+ has_active_aruid);++ if (result.IsSuccess() && has_active_aruid) {+ result = IsVibrationHandleValid(parameters.vibration_device_handle);+ }+ if (result.IsSuccess() && has_active_aruid) {+ n64_device =+ GetResourceManager()->GetN64VibrationDevice(parameters.vibration_device_handle);+ }+ if (n64_device != nullptr) {+ result = n64_device->SendValueInBool(parameters.is_vibrating);+ }++ IPC::ResponseBuilder rb{ctx, 2};+ rb.Push(result);}void IHidServer::ActivateConsoleSixAxisSensor(HLERequestContext& ctx) {diff --git a/src/core/hle/service/hid/hid_server.h b/src/core/hle/service/hid/hid_server.hindex cc7c4ebdd1..3a2e0a2301 100644--- a/src/core/hle/service/hid/hid_server.h+++ b/src/core/hle/service/hid/hid_server.h@@ -97,6 +97,7 @@ private:void BeginPermitVibrationSession(HLERequestContext& ctx);void EndPermitVibrationSession(HLERequestContext& ctx);void IsVibrationDeviceMounted(HLERequestContext& ctx);+ void SendVibrationValueInBool(HLERequestContext& ctx);void ActivateConsoleSixAxisSensor(HLERequestContext& ctx);void StartConsoleSixAxisSensor(HLERequestContext& ctx);void StopConsoleSixAxisSensor(HLERequestContext& ctx);diff --git a/src/core/hle/service/hid/hid_system_server.cpp b/src/core/hle/service/hid/hid_system_server.cppindex 3a0cb3cb1d..4466a189b3 100644--- a/src/core/hle/service/hid/hid_system_server.cpp+++ b/src/core/hle/service/hid/hid_system_server.cpp@@ -7,6 +7,7 @@#include "hid_core/resource_manager.h"#include "hid_core/resources/npad/npad.h"#include "hid_core/resources/npad/npad_types.h"+#include "hid_core/resources/npad/npad_vibration.h"#include "hid_core/resources/palma/palma.h"#include "hid_core/resources/touch_screen/touch_screen.h"@@ -67,14 +68,14 @@ IHidSystemServer::IHidSystemServer(Core::System& system_, std::shared_ptr<Resour{501, &IHidSystemServer::RegisterAppletResourceUserId, "RegisterAppletResourceUserId"},{502, &IHidSystemServer::UnregisterAppletResourceUserId, "UnregisterAppletResourceUserId"},{503, &IHidSystemServer::EnableAppletToGetInput, "EnableAppletToGetInput"},- {504, nullptr, "SetAruidValidForVibration"},+ {504, &IHidSystemServer::SetAruidValidForVibration, "SetAruidValidForVibration"},{505, &IHidSystemServer::EnableAppletToGetSixAxisSensor, "EnableAppletToGetSixAxisSensor"},{506, &IHidSystemServer::EnableAppletToGetPadInput, "EnableAppletToGetPadInput"},{507, &IHidSystemServer::EnableAppletToGetTouchScreen, "EnableAppletToGetTouchScreen"},- {510, nullptr, "SetVibrationMasterVolume"},- {511, nullptr, "GetVibrationMasterVolume"},- {512, nullptr, "BeginPermitVibrationSession"},- {513, nullptr, "EndPermitVibrationSession"},+ {510, &IHidSystemServer::SetVibrationMasterVolume, "SetVibrationMasterVolume"},+ {511, &IHidSystemServer::GetVibrationMasterVolume, "GetVibrationMasterVolume"},+ {512, &IHidSystemServer::BeginPermitVibrationSession, "BeginPermitVibrationSession"},+ {513, &IHidSystemServer::EndPermitVibrationSession, "EndPermitVibrationSession"},{514, nullptr, "Unknown514"},{520, nullptr, "EnableHandheldHids"},{521, nullptr, "DisableHandheldHids"},@@ -156,7 +157,7 @@ IHidSystemServer::IHidSystemServer(Core::System& system_, std::shared_ptr<Resour{1152, nullptr, "SetTouchScreenDefaultConfiguration"},{1153, &IHidSystemServer::GetTouchScreenDefaultConfiguration, "GetTouchScreenDefaultConfiguration"},{1154, nullptr, "IsFirmwareAvailableForNotification"},- {1155, nullptr, "SetForceHandheldStyleVibration"},+ {1155, &IHidSystemServer::SetForceHandheldStyleVibration, "SetForceHandheldStyleVibration"},{1156, nullptr, "SendConnectionTriggerWithoutTimeoutEvent"},{1157, nullptr, "CancelConnectionTrigger"},{1200, nullptr, "IsButtonConfigSupported"},@@ -538,6 +539,27 @@ void IHidSystemServer::EnableAppletToGetInput(HLERequestContext& ctx) {rb.Push(ResultSuccess);}+void IHidSystemServer::SetAruidValidForVibration(HLERequestContext& ctx) {+ IPC::RequestParser rp{ctx};+ struct Parameters {+ bool is_enabled;+ INSERT_PADDING_WORDS_NOINIT(1);+ u64 applet_resource_user_id;+ };+ static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size.");++ const auto parameters{rp.PopRaw<Parameters>()};++ LOG_INFO(Service_HID, "called, is_enabled={}, applet_resource_user_id={}",+ parameters.is_enabled, parameters.applet_resource_user_id);++ GetResourceManager()->SetAruidValidForVibration(parameters.applet_resource_user_id,+ parameters.is_enabled);++ IPC::ResponseBuilder rb{ctx, 2};+ rb.Push(ResultSuccess);+}+void IHidSystemServer::EnableAppletToGetSixAxisSensor(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};struct Parameters {@@ -601,6 +623,57 @@ void IHidSystemServer::EnableAppletToGetTouchScreen(HLERequestContext& ctx) {rb.Push(ResultSuccess);}+void IHidSystemServer::SetVibrationMasterVolume(HLERequestContext& ctx) {+ IPC::RequestParser rp{ctx};+ const auto master_volume{rp.Pop<f32>()};++ LOG_INFO(Service_HID, "called, volume={}", master_volume);++ const auto result =+ GetResourceManager()->GetNpad()->GetVibrationHandler()->SetVibrationMasterVolume(+ master_volume);++ IPC::ResponseBuilder rb{ctx, 2};+ rb.Push(result);+}++void IHidSystemServer::GetVibrationMasterVolume(HLERequestContext& ctx) {+ f32 master_volume{};+ const auto result =+ GetResourceManager()->GetNpad()->GetVibrationHandler()->GetVibrationMasterVolume(+ master_volume);++ LOG_INFO(Service_HID, "called, volume={}", master_volume);++ IPC::ResponseBuilder rb{ctx, 3};+ rb.Push(result);+ rb.Push(master_volume);+}++void IHidSystemServer::BeginPermitVibrationSession(HLERequestContext& ctx) {+ IPC::RequestParser rp{ctx};+ const auto applet_resource_user_id{rp.Pop<u64>()};++ LOG_INFO(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);++ const auto result =+ GetResourceManager()->GetNpad()->GetVibrationHandler()->BeginPermitVibrationSession(+ applet_resource_user_id);++ IPC::ResponseBuilder rb{ctx, 2};+ rb.Push(result);+}++void IHidSystemServer::EndPermitVibrationSession(HLERequestContext& ctx) {+ LOG_INFO(Service_HID, "called");++ const auto result =+ GetResourceManager()->GetNpad()->GetVibrationHandler()->EndPermitVibrationSession();++ IPC::ResponseBuilder rb{ctx, 2};+ rb.Push(result);+}+void IHidSystemServer::IsJoyConAttachedOnAllRail(HLERequestContext& ctx) {const bool is_attached = true;@@ -749,6 +822,19 @@ void IHidSystemServer::GetTouchScreenDefaultConfiguration(HLERequestContext& ctxrb.PushRaw(touchscreen_config);}+void IHidSystemServer::SetForceHandheldStyleVibration(HLERequestContext& ctx) {+ IPC::RequestParser rp{ctx};+ const auto is_forced{rp.Pop<bool>()};++ LOG_INFO(Service_HID, "called, is_forced={}", is_forced);++ GetResourceManager()->SetForceHandheldStyleVibration(is_forced);+ GetResourceManager()->GetNpad()->UpdateHandheldAbstractState();++ IPC::ResponseBuilder rb{ctx, 2};+ rb.Push(ResultSuccess);+}+void IHidSystemServer::IsUsingCustomButtonConfig(HLERequestContext& ctx) {const bool is_enabled = false;diff --git a/src/core/hle/service/hid/hid_system_server.h b/src/core/hle/service/hid/hid_system_server.hindex 0c2634e3f1..90a719f026 100644--- a/src/core/hle/service/hid/hid_system_server.h+++ b/src/core/hle/service/hid/hid_system_server.h@@ -42,9 +42,14 @@ private:void RegisterAppletResourceUserId(HLERequestContext& ctx);void UnregisterAppletResourceUserId(HLERequestContext& ctx);void EnableAppletToGetInput(HLERequestContext& ctx);+ void SetAruidValidForVibration(HLERequestContext& ctx);void EnableAppletToGetSixAxisSensor(HLERequestContext& ctx);void EnableAppletToGetPadInput(HLERequestContext& ctx);void EnableAppletToGetTouchScreen(HLERequestContext& ctx);+ void SetVibrationMasterVolume(HLERequestContext& ctx);+ void GetVibrationMasterVolume(HLERequestContext& ctx);+ void BeginPermitVibrationSession(HLERequestContext& ctx);+ void EndPermitVibrationSession(HLERequestContext& ctx);void IsJoyConAttachedOnAllRail(HLERequestContext& ctx);void AcquireConnectionTriggerTimeoutEvent(HLERequestContext& ctx);void AcquireDeviceRegisteredEventForControllerSupport(HLERequestContext& ctx);@@ -61,6 +66,7 @@ private:void FinalizeUsbFirmwareUpdate(HLERequestContext& ctx);void InitializeUsbFirmwareUpdateWithoutMemory(HLERequestContext& ctx);void GetTouchScreenDefaultConfiguration(HLERequestContext& ctx);+ void SetForceHandheldStyleVibration(HLERequestContext& ctx);void IsUsingCustomButtonConfig(HLERequestContext& ctx);std::shared_ptr<ResourceManager> GetResourceManager();diff --git a/src/hid_core/frontend/emulated_controller.cpp b/src/hid_core/frontend/emulated_controller.cppindex 2ab93402d7..b6c48aba85 100644--- a/src/hid_core/frontend/emulated_controller.cpp+++ b/src/hid_core/frontend/emulated_controller.cpp@@ -144,8 +144,8 @@ void EmulatedController::ReloadColorsFromSettings() {void EmulatedController::LoadDevices() {// TODO(german77): Use more buttons to detect the correct device- const auto left_joycon = button_params[Settings::NativeButton::DRight];- const auto right_joycon = button_params[Settings::NativeButton::A];+ const auto& left_joycon = button_params[Settings::NativeButton::DRight];+ const auto& right_joycon = button_params[Settings::NativeButton::A];// Triggers for GC controllerstrigger_params[LeftIndex] = button_params[Settings::NativeButton::ZL];@@ -1208,20 +1208,43 @@ void EmulatedController::SetNfc(const Common::Input::CallbackStatus& callback) {controller.nfc_state = controller.nfc_values;}-bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue vibration) {+bool EmulatedController::SetVibration(bool should_vibrate) {+ VibrationValue vibration_value = DEFAULT_VIBRATION_VALUE;+ if (should_vibrate) {+ vibration_value.high_amplitude = 1.0f;+ vibration_value.low_amplitude = 1.0f;+ }++ return SetVibration(DeviceIndex::Left, vibration_value);+}++bool EmulatedController::SetVibration(u32 slot, Core::HID::VibrationGcErmCommand erm_command) {+ VibrationValue vibration_value = DEFAULT_VIBRATION_VALUE;+ if (erm_command == Core::HID::VibrationGcErmCommand::Start) {+ vibration_value.high_amplitude = 1.0f;+ vibration_value.low_amplitude = 1.0f;+ }++ return SetVibration(DeviceIndex::Left, vibration_value);+}++bool EmulatedController::SetVibration(DeviceIndex device_index, const VibrationValue& vibration) {if (!is_initialized) {return false;}- if (device_index >= output_devices.size()) {+ if (device_index >= DeviceIndex::MaxDeviceIndex) {return false;}- if (!output_devices[device_index]) {+ const std::size_t index = static_cast<std::size_t>(device_index);+ if (!output_devices[index]) {return false;}const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);const auto& player = Settings::values.players.GetValue()[player_index];const f32 strength = static_cast<f32>(player.vibration_strength) / 100.0f;+ last_vibration_value = vibration;+if (!player.vibration_enabled) {return false;}@@ -1239,8 +1262,11 @@ bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue v.high_frequency = vibration.high_frequency,.type = type,};- return output_devices[device_index]->SetVibration(status) ==- Common::Input::DriverResult::Success;+ return output_devices[index]->SetVibration(status) == Common::Input::DriverResult::Success;+}++VibrationValue EmulatedController::GetActualVibrationValue(DeviceIndex device_index) const {+ return last_vibration_value;}bool EmulatedController::IsVibrationEnabled(std::size_t device_index) {diff --git a/src/hid_core/frontend/emulated_controller.h b/src/hid_core/frontend/emulated_controller.hindex 90e536e072..168abe089d 100644--- a/src/hid_core/frontend/emulated_controller.h+++ b/src/hid_core/frontend/emulated_controller.h@@ -355,11 +355,28 @@ public:/// Returns the latest ntag status from the controllerconst NfcState& GetNfc() const;+ /**+ * Sends an on/off vibration to the left device+ * @return true if vibration had no errors+ */+ bool SetVibration(bool should_vibrate);++ /**+ * Sends an GC vibration to the left device+ * @return true if vibration had no errors+ */+ bool SetVibration(u32 slot, Core::HID::VibrationGcErmCommand erm_command);+/*** Sends a specific vibration to the output device* @return true if vibration had no errors*/- bool SetVibration(std::size_t device_index, VibrationValue vibration);+ bool SetVibration(DeviceIndex device_index, const VibrationValue& vibration);++ /**+ * @return The last sent vibration+ */+ VibrationValue GetActualVibrationValue(DeviceIndex device_index) const;/*** Sends a small vibration to the output device@@ -564,6 +581,7 @@ private:f32 motion_sensitivity{Core::HID::MotionInput::IsAtRestStandard};u32 turbo_button_state{0};std::size_t nfc_handles{0};+ VibrationValue last_vibration_value{DEFAULT_VIBRATION_VALUE};// Temporary values to avoid doing changes while the controller is in configuring modeNpadStyleIndex tmp_npad_type{NpadStyleIndex::None};diff --git a/src/hid_core/resource_manager.cpp b/src/hid_core/resource_manager.cppindex 2c5fe6d512..ca824b4a32 100644--- a/src/hid_core/resource_manager.cpp+++ b/src/hid_core/resource_manager.cpp@@ -7,6 +7,7 @@#include "core/hle/kernel/k_shared_memory.h"#include "core/hle/service/ipc_helpers.h"#include "hid_core/hid_core.h"+#include "hid_core/hid_util.h"#include "hid_core/resource_manager.h"#include "hid_core/resources/applet_resource.h"@@ -27,6 +28,10 @@#include "hid_core/resources/touch_screen/gesture.h"#include "hid_core/resources/touch_screen/touch_screen.h"#include "hid_core/resources/unique_pad/unique_pad.h"+#include "hid_core/resources/vibration/gc_vibration_device.h"+#include "hid_core/resources/vibration/n64_vibration_device.h"+#include "hid_core/resources/vibration/vibration_base.h"+#include "hid_core/resources/vibration/vibration_device.h"namespace Service::HID {@@ -52,6 +57,7 @@ void ResourceManager::Initialize() {system.HIDCore().ReloadInputDevices();+ handheld_config = std::make_shared<HandheldConfig>();InitializeHidCommonSampler();InitializeTouchScreenSampler();InitializeConsoleSixAxisSampler();@@ -174,7 +180,7 @@ void ResourceManager::InitializeHidCommonSampler() {debug_pad->SetAppletResource(applet_resource, &shared_mutex);digitizer->SetAppletResource(applet_resource, &shared_mutex);keyboard->SetAppletResource(applet_resource, &shared_mutex);- npad->SetNpadExternals(applet_resource, &shared_mutex);+ npad->SetNpadExternals(applet_resource, &shared_mutex, handheld_config);six_axis->SetAppletResource(applet_resource, &shared_mutex);mouse->SetAppletResource(applet_resource, &shared_mutex);debug_mouse->SetAppletResource(applet_resource, &shared_mutex);@@ -257,6 +263,121 @@ void ResourceManager::EnableTouchScreen(u64 aruid, bool is_enabled) {applet_resource->EnableTouchScreen(aruid, is_enabled);}+NpadVibrationBase* ResourceManager::GetVibrationDevice(+ const Core::HID::VibrationDeviceHandle& handle) {+ return npad->GetVibrationDevice(handle);+}++NpadN64VibrationDevice* ResourceManager::GetN64VibrationDevice(+ const Core::HID::VibrationDeviceHandle& handle) {+ return npad->GetN64VibrationDevice(handle);+}++NpadVibrationDevice* ResourceManager::GetNSVibrationDevice(+ const Core::HID::VibrationDeviceHandle& handle) {+ return npad->GetNSVibrationDevice(handle);+}++NpadGcVibrationDevice* ResourceManager::GetGcVibrationDevice(+ const Core::HID::VibrationDeviceHandle& handle) {+ return npad->GetGcVibrationDevice(handle);+}++Result ResourceManager::SetAruidValidForVibration(u64 aruid, bool is_enabled) {+ std::scoped_lock lock{shared_mutex};+ const bool has_changed = applet_resource->SetAruidValidForVibration(aruid, is_enabled);++ if (has_changed) {+ auto devices = npad->GetAllVibrationDevices();+ for ([[maybe_unused]] auto* device : devices) {+ // TODO+ }+ }++ auto* vibration_handler = npad->GetVibrationHandler();+ if (aruid != vibration_handler->GetSessionAruid()) {+ vibration_handler->EndPermitVibrationSession();+ }++ return ResultSuccess;+}++void ResourceManager::SetForceHandheldStyleVibration(bool is_forced) {+ handheld_config->is_force_handheld_style_vibration = is_forced;+}++Result ResourceManager::IsVibrationAruidActive(u64 aruid, bool& is_active) const {+ std::scoped_lock lock{shared_mutex};+ is_active = applet_resource->IsVibrationAruidActive(aruid);+ return ResultSuccess;+}++Result ResourceManager::GetVibrationDeviceInfo(Core::HID::VibrationDeviceInfo& device_info,+ const Core::HID::VibrationDeviceHandle& handle) {+ bool check_device_index = false;++ const Result is_valid = IsVibrationHandleValid(handle);+ if (is_valid.IsError()) {+ return is_valid;+ }++ switch (handle.npad_type) {+ case Core::HID::NpadStyleIndex::Fullkey:+ case Core::HID::NpadStyleIndex::Handheld:+ case Core::HID::NpadStyleIndex::JoyconDual:+ case Core::HID::NpadStyleIndex::JoyconLeft:+ case Core::HID::NpadStyleIndex::JoyconRight:+ device_info.type = Core::HID::VibrationDeviceType::LinearResonantActuator;+ check_device_index = true;+ break;+ case Core::HID::NpadStyleIndex::GameCube:+ device_info.type = Core::HID::VibrationDeviceType::GcErm;+ break;+ case Core::HID::NpadStyleIndex::N64:+ device_info.type = Core::HID::VibrationDeviceType::N64;+ break;+ default:+ device_info.type = Core::HID::VibrationDeviceType::Unknown;+ break;+ }++ device_info.position = Core::HID::VibrationDevicePosition::None;+ if (check_device_index) {+ switch (handle.device_index) {+ case Core::HID::DeviceIndex::Left:+ device_info.position = Core::HID::VibrationDevicePosition::Left;+ break;+ case Core::HID::DeviceIndex::Right:+ device_info.position = Core::HID::VibrationDevicePosition::Right;+ break;+ case Core::HID::DeviceIndex::None:+ default:+ ASSERT_MSG(false, "DeviceIndex should never be None!");+ break;+ }+ }+ return ResultSuccess;+}++Result ResourceManager::SendVibrationValue(u64 aruid,+ const Core::HID::VibrationDeviceHandle& handle,+ const Core::HID::VibrationValue& value) {+ bool has_active_aruid{};+ NpadVibrationDevice* device{nullptr};+ Result result = IsVibrationAruidActive(aruid, has_active_aruid);++ if (result.IsSuccess() && has_active_aruid) {+ result = IsVibrationHandleValid(handle);+ }+ if (result.IsSuccess() && has_active_aruid) {+ device = GetNSVibrationDevice(handle);+ }+ if (device != nullptr) {+ result = device->SendVibrationValue(value);+ }+ return result;+}+void ResourceManager::UpdateControllers(std::chrono::nanoseconds ns_late) {auto& core_timing = system.CoreTiming();debug_pad->OnUpdate(core_timing);diff --git a/src/hid_core/resource_manager.h b/src/hid_core/resource_manager.hindex 7a21d8eb8a..128e001252 100644--- a/src/hid_core/resource_manager.h+++ b/src/hid_core/resource_manager.h@@ -10,6 +10,12 @@ namespace Core {class System;}+namespace Core::HID {+struct VibrationDeviceHandle;+struct VibrationValue;+struct VibrationDeviceInfo;+} // namespace Core::HID+namespace Core::Timing {struct EventType;}@@ -37,6 +43,11 @@ class SixAxis;class SleepButton;class TouchScreen;class UniquePad;+class NpadVibrationBase;+class NpadN64VibrationDevice;+class NpadGcVibrationDevice;+class NpadVibrationDevice;+struct HandheldConfig;class ResourceManager {@@ -79,6 +90,18 @@ public:void EnablePadInput(u64 aruid, bool is_enabled);void EnableTouchScreen(u64 aruid, bool is_enabled);+ NpadVibrationBase* GetVibrationDevice(const Core::HID::VibrationDeviceHandle& handle);+ NpadN64VibrationDevice* GetN64VibrationDevice(const Core::HID::VibrationDeviceHandle& handle);+ NpadVibrationDevice* GetNSVibrationDevice(const Core::HID::VibrationDeviceHandle& handle);+ NpadGcVibrationDevice* GetGcVibrationDevice(const Core::HID::VibrationDeviceHandle& handle);+ Result SetAruidValidForVibration(u64 aruid, bool is_enabled);+ void SetForceHandheldStyleVibration(bool is_forced);+ Result IsVibrationAruidActive(u64 aruid, bool& is_active) const;+ Result GetVibrationDeviceInfo(Core::HID::VibrationDeviceInfo& device_info,+ const Core::HID::VibrationDeviceHandle& handle);+ Result SendVibrationValue(u64 aruid, const Core::HID::VibrationDeviceHandle& handle,+ const Core::HID::VibrationValue& value);+void UpdateControllers(std::chrono::nanoseconds ns_late);void UpdateNpad(std::chrono::nanoseconds ns_late);void UpdateMouseKeyboard(std::chrono::nanoseconds ns_late);@@ -113,6 +136,8 @@ private:std::shared_ptr<TouchScreen> touch_screen = nullptr;std::shared_ptr<UniquePad> unique_pad = nullptr;+ std::shared_ptr<HandheldConfig> handheld_config = nullptr;+// TODO: Create these resources// std::shared_ptr<AudioControl> audio_control = nullptr;// std::shared_ptr<ButtonConfig> button_config = nullptr;diff --git a/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.cpp b/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.cppindex d4e4181bfa..e399edfd70 100644--- a/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.cpp+++ b/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.cpp@@ -115,7 +115,7 @@ Result NpadAbstractIrSensorHandler::GetXcdHandleForNpadWithIrSensor(u64& handle)if (sensor_state < NpadIrSensorState::Available) {return ResultIrSensorIsNotReady;}- handle = xcd_handle;+ // handle = xcd_handle;return ResultSuccess;}diff --git a/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.h b/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.hindex fe8e005af6..9978115116 100644--- a/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.h+++ b/src/hid_core/resources/abstracted_pad/abstract_ir_sensor_handler.h@@ -7,6 +7,10 @@#include "core/hle/result.h"#include "hid_core/hid_types.h"+namespace Core::HID {+class EmulatedController;+}+namespace Kernel {class KEvent;class KReadableEvent;@@ -50,7 +54,7 @@ private:s32 ref_counter{};Kernel::KEvent* ir_sensor_event{nullptr};- u64 xcd_handle{};+ Core::HID::EmulatedController* xcd_handle{};NpadIrSensorState sensor_state{};};} // namespace Service::HIDdiff --git a/src/hid_core/resources/abstracted_pad/abstract_pad.cpp b/src/hid_core/resources/abstracted_pad/abstract_pad.cppindex 2c7691d7cc..435b095f02 100644--- a/src/hid_core/resources/abstracted_pad/abstract_pad.cpp+++ b/src/hid_core/resources/abstracted_pad/abstract_pad.cpp@@ -1,6 +1,7 @@// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later+#include "hid_core/hid_core.h"#include "hid_core/hid_result.h"#include "hid_core/resources/abstracted_pad/abstract_pad.h"#include "hid_core/resources/applet_resource.h"@@ -16,7 +17,7 @@ void AbstractPad::SetExternals(AppletResourceHolder* applet_resource,CaptureButtonResource* capture_button_resource,HomeButtonResource* home_button_resource,SixAxisResource* sixaxis_resource, PalmaResource* palma_resource,- VibrationHandler* vibration) {+ NpadVibration* vibration, Core::HID::HIDCore* core) {applet_resource_holder = applet_resource;properties_handler.SetAppletResource(applet_resource_holder);@@ -35,13 +36,14 @@ void AbstractPad::SetExternals(AppletResourceHolder* applet_resource,mcu_handler.SetAbstractPadHolder(&abstract_pad_holder);mcu_handler.SetPropertiesHandler(&properties_handler);- std::array<NpadVibrationDevice*, 2> vibration_devices{&vibration_left, &vibration_right};vibration_handler.SetAppletResource(applet_resource_holder);vibration_handler.SetAbstractPadHolder(&abstract_pad_holder);vibration_handler.SetPropertiesHandler(&properties_handler);vibration_handler.SetN64Vibration(&vibration_n64);- vibration_handler.SetVibration(vibration_devices);+ vibration_handler.SetVibration(&vibration_left, &vibration_right);vibration_handler.SetGcVibration(&vibration_gc);+ vibration_handler.SetVibrationHandler(vibration);+ vibration_handler.SetHidCore(core);sixaxis_handler.SetAppletResource(applet_resource_holder);sixaxis_handler.SetAbstractPadHolder(&abstract_pad_holder);@@ -239,11 +241,6 @@ NpadVibrationDevice* AbstractPad::GetVibrationDevice(Core::HID::DeviceIndex devireturn &vibration_left;}-void AbstractPad::GetLeftRightVibrationDevice(std::vector<NpadVibrationDevice*> list) {- list.emplace_back(&vibration_left);- list.emplace_back(&vibration_right);-}-NpadGcVibrationDevice* AbstractPad::GetGCVibrationDevice() {return &vibration_gc;}diff --git a/src/hid_core/resources/abstracted_pad/abstract_pad.h b/src/hid_core/resources/abstracted_pad/abstract_pad.hindex cbdf84af73..3297924574 100644--- a/src/hid_core/resources/abstracted_pad/abstract_pad.h+++ b/src/hid_core/resources/abstracted_pad/abstract_pad.h@@ -32,7 +32,6 @@ class AppletResource;class SixAxisResource;class PalmaResource;class NPadResource;-class AbstractPad;class NpadLastActiveHandler;class NpadIrNfcHandler;class UniquePads;@@ -44,7 +43,6 @@ class NpadGcVibration;class CaptureButtonResource;class HomeButtonResource;-class VibrationHandler;struct HandheldConfig;@@ -57,7 +55,8 @@ public:void SetExternals(AppletResourceHolder* applet_resource,CaptureButtonResource* capture_button_resource,HomeButtonResource* home_button_resource, SixAxisResource* sixaxis_resource,- PalmaResource* palma_resource, VibrationHandler* vibration);+ PalmaResource* palma_resource, NpadVibration* vibration,+ Core::HID::HIDCore* core);void SetNpadId(Core::HID::NpadIdType npad_id);Result Activate();@@ -78,7 +77,6 @@ public:NpadN64VibrationDevice* GetN64VibrationDevice();NpadVibrationDevice* GetVibrationDevice(Core::HID::DeviceIndex device_index);- void GetLeftRightVibrationDevice(std::vector<NpadVibrationDevice*> list);NpadGcVibrationDevice* GetGCVibrationDevice();Core::HID::NpadIdType GetLastActiveNpad();diff --git a/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.cpp b/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.cppindex a00d6c9de1..ca64b0a437 100644--- a/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.cpp+++ b/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.cpp@@ -1,6 +1,8 @@// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later+#include "hid_core/frontend/emulated_controller.h"+#include "hid_core/hid_core.h"#include "hid_core/hid_result.h"#include "hid_core/hid_util.h"#include "hid_core/resources/abstracted_pad/abstract_pad_holder.h"@@ -30,14 +32,22 @@ void NpadAbstractVibrationHandler::SetPropertiesHandler(NpadAbstractPropertiesHaproperties_handler = handler;}+void NpadAbstractVibrationHandler::SetVibrationHandler(NpadVibration* handler) {+ vibration_handler = handler;+}++void NpadAbstractVibrationHandler::SetHidCore(Core::HID::HIDCore* core) {+ hid_core = core;+}+void NpadAbstractVibrationHandler::SetN64Vibration(NpadN64VibrationDevice* n64_device) {n64_vibration_device = n64_device;}-void NpadAbstractVibrationHandler::SetVibration(std::span<NpadVibrationDevice*> device) {- for (std::size_t i = 0; i < device.size() && i < vibration_device.size(); i++) {- vibration_device[i] = device[i];- }+void NpadAbstractVibrationHandler::SetVibration(NpadVibrationDevice* left_device,+ NpadVibrationDevice* right_device) {+ left_vibration_device = left_device;+ right_vibration_device = right_device;}void NpadAbstractVibrationHandler::SetGcVibration(NpadGcVibrationDevice* gc_device) {@@ -69,5 +79,29 @@ void NpadAbstractVibrationHandler::UpdateVibrationState() {if (!is_handheld_hid_enabled && is_force_handheld_style_vibration) {// TODO}++ // TODO: This function isn't accurate. It's supposed to get 5 abstracted pads from the+ // NpadAbstractPropertiesHandler but this handler isn't fully implemented yet+ IAbstractedPad abstracted_pad{};+ const auto npad_id = properties_handler->GetNpadId();+ abstracted_pad.xcd_handle = hid_core->GetEmulatedController(npad_id);+ abstracted_pad.internal_flags.is_connected.Assign(abstracted_pad.xcd_handle->IsConnected());++ if (abstracted_pad.internal_flags.is_connected) {+ left_vibration_device->Mount(abstracted_pad, Core::HID::DeviceIndex::Left,+ vibration_handler);+ right_vibration_device->Mount(abstracted_pad, Core::HID::DeviceIndex::Right,+ vibration_handler);+ gc_vibration_device->Mount(abstracted_pad, 0, vibration_handler);+ gc_vibration_device->Mount(abstracted_pad, 0, vibration_handler);+ n64_vibration_device->Mount(abstracted_pad, vibration_handler);+ return;+ }++ left_vibration_device->Unmount();+ right_vibration_device->Unmount();+ gc_vibration_device->Unmount();+ gc_vibration_device->Unmount();+ n64_vibration_device->Unmount();}} // namespace Service::HIDdiff --git a/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.h b/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.hindex aeb07ce868..8bc8129c24 100644--- a/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.h+++ b/src/hid_core/resources/abstracted_pad/abstract_vibration_handler.h@@ -9,6 +9,10 @@#include "core/hle/result.h"#include "hid_core/hid_types.h"+namespace Core::HID {+class HIDCore;+}+namespace Service::HID {struct AppletResourceHolder;class NpadAbstractedPadHolder;@@ -27,9 +31,11 @@ public:void SetAbstractPadHolder(NpadAbstractedPadHolder* holder);void SetAppletResource(AppletResourceHolder* applet_resource);void SetPropertiesHandler(NpadAbstractPropertiesHandler* handler);+ void SetVibrationHandler(NpadVibration* handler);+ void SetHidCore(Core::HID::HIDCore* core);void SetN64Vibration(NpadN64VibrationDevice* n64_device);- void SetVibration(std::span<NpadVibrationDevice*> device);+ void SetVibration(NpadVibrationDevice* left_device, NpadVibrationDevice* right_device);void SetGcVibration(NpadGcVibrationDevice* gc_device);Result IncrementRefCounter();@@ -41,9 +47,11 @@ private:AppletResourceHolder* applet_resource_holder{nullptr};NpadAbstractedPadHolder* abstract_pad_holder{nullptr};NpadAbstractPropertiesHandler* properties_handler{nullptr};+ Core::HID::HIDCore* hid_core{nullptr};NpadN64VibrationDevice* n64_vibration_device{nullptr};- std::array<NpadVibrationDevice*, 2> vibration_device{};+ NpadVibrationDevice* left_vibration_device{};+ NpadVibrationDevice* right_vibration_device{};NpadGcVibrationDevice* gc_vibration_device{nullptr};NpadVibration* vibration_handler{nullptr};s32 ref_counter{};diff --git a/src/hid_core/resources/applet_resource.cpp b/src/hid_core/resources/applet_resource.cppindex a84826050a..db4134037d 100644--- a/src/hid_core/resources/applet_resource.cpp+++ b/src/hid_core/resources/applet_resource.cpp@@ -200,6 +200,25 @@ void AppletResource::EnableInput(u64 aruid, bool is_enabled) {data[index].flag.enable_touchscreen.Assign(is_enabled);}+bool AppletResource::SetAruidValidForVibration(u64 aruid, bool is_enabled) {+ const u64 index = GetIndexFromAruid(aruid);+ if (index >= AruidIndexMax) {+ return false;+ }++ if (!is_enabled && aruid == active_vibration_aruid) {+ active_vibration_aruid = SystemAruid;+ return true;+ }++ if (is_enabled && aruid != active_vibration_aruid) {+ active_vibration_aruid = aruid;+ return true;+ }++ return false;+}+void AppletResource::EnableSixAxisSensor(u64 aruid, bool is_enabled) {const u64 index = GetIndexFromAruid(aruid);if (index >= AruidIndexMax) {diff --git a/src/hid_core/resources/applet_resource.h b/src/hid_core/resources/applet_resource.hindex f3f32bac16..e9710d3063 100644--- a/src/hid_core/resources/applet_resource.h+++ b/src/hid_core/resources/applet_resource.h@@ -101,6 +101,7 @@ public:Result DestroySevenSixAxisTransferMemory();void EnableInput(u64 aruid, bool is_enabled);+ bool SetAruidValidForVibration(u64 aruid, bool is_enabled);void EnableSixAxisSensor(u64 aruid, bool is_enabled);void EnablePadInput(u64 aruid, bool is_enabled);void EnableTouchScreen(u64 aruid, bool is_enabled);diff --git a/src/hid_core/resources/npad/npad.cpp b/src/hid_core/resources/npad/npad.cppindex 97537a2e26..310fa8ba74 100644--- a/src/hid_core/resources/npad/npad.cpp+++ b/src/hid_core/resources/npad/npad.cpp@@ -21,6 +21,7 @@#include "hid_core/hid_util.h"#include "hid_core/resources/applet_resource.h"#include "hid_core/resources/npad/npad.h"+#include "hid_core/resources/npad/npad_vibration.h"#include "hid_core/resources/shared_memory_format.h"namespace Service::HID {@@ -31,10 +32,6 @@ NPad::NPad(Core::HID::HIDCore& hid_core_, KernelHelpers::ServiceContext& servicefor (std::size_t i = 0; i < controller_data[aruid_index].size(); ++i) {auto& controller = controller_data[aruid_index][i];controller.device = hid_core.GetEmulatedControllerByIndex(i);- controller.vibration[Core::HID::EmulatedDeviceIndex::LeftIndex].latest_vibration_value =- Core::HID::DEFAULT_VIBRATION_VALUE;- controller.vibration[Core::HID::EmulatedDeviceIndex::RightIndex]- .latest_vibration_value = Core::HID::DEFAULT_VIBRATION_VALUE;Core::HID::ControllerUpdateCallback engine_callback{.on_change =[this, i](Core::HID::ControllerTriggerType type) { ControllerUpdate(type, i); },@@ -43,6 +40,10 @@ NPad::NPad(Core::HID::HIDCore& hid_core_, KernelHelpers::ServiceContext& servicecontroller.callback_key = controller.device->SetCallback(engine_callback);}}+ for (std::size_t i = 0; i < abstracted_pads.size(); ++i) {+ abstracted_pads[i] = AbstractPad{};+ abstracted_pads[i].SetNpadId(IndexToNpadIdType(i));+ }}NPad::~NPad() {@@ -359,6 +360,7 @@ void NPad::InitNewlyAddedController(u64 aruid, Core::HID::NpadIdType npad_id) {npad_resource.SignalStyleSetUpdateEvent(aruid, npad_id);WriteEmptyEntry(controller.shared_memory);hid_core.SetLastActiveController(npad_id);+ abstracted_pads[NpadIdTypeToIndex(npad_id)].Update();}void NPad::WriteEmptyEntry(NpadInternalState* npad) {@@ -740,171 +742,6 @@ bool NPad::SetNpadMode(u64 aruid, Core::HID::NpadIdType& new_npad_id, Core::HID:return true;}-bool NPad::VibrateControllerAtIndex(u64 aruid, Core::HID::NpadIdType npad_id,- std::size_t device_index,- const Core::HID::VibrationValue& vibration_value) {- auto& controller = GetControllerFromNpadIdType(aruid, npad_id);- if (!controller.device->IsConnected()) {- return false;- }-- if (!controller.device->IsVibrationEnabled(device_index)) {- if (controller.vibration[device_index].latest_vibration_value.low_amplitude != 0.0f ||- controller.vibration[device_index].latest_vibration_value.high_amplitude != 0.0f) {- // Send an empty vibration to stop any vibrations.- Core::HID::VibrationValue vibration{0.0f, 160.0f, 0.0f, 320.0f};- controller.device->SetVibration(device_index, vibration);- // Then reset the vibration value to its default value.- controller.vibration[device_index].latest_vibration_value =- Core::HID::DEFAULT_VIBRATION_VALUE;- }-- return false;- }-- if (!Settings::values.enable_accurate_vibrations.GetValue()) {- using std::chrono::duration_cast;- using std::chrono::milliseconds;- using std::chrono::steady_clock;-- const auto now = steady_clock::now();-- // Filter out non-zero vibrations that are within 15ms of each other.- if ((vibration_value.low_amplitude != 0.0f || vibration_value.high_amplitude != 0.0f) &&- duration_cast<milliseconds>(- now - controller.vibration[device_index].last_vibration_timepoint) <- milliseconds(15)) {- return false;- }-- controller.vibration[device_index].last_vibration_timepoint = now;- }-- Core::HID::VibrationValue vibration{- vibration_value.low_amplitude, vibration_value.low_frequency,- vibration_value.high_amplitude, vibration_value.high_frequency};- return controller.device->SetVibration(device_index, vibration);-}--void NPad::VibrateController(u64 aruid,- const Core::HID::VibrationDeviceHandle& vibration_device_handle,- const Core::HID::VibrationValue& vibration_value) {- if (IsVibrationHandleValid(vibration_device_handle).IsError()) {- return;- }-- if (!Settings::values.vibration_enabled.GetValue() && !permit_vibration_session_enabled) {- return;- }-- auto& controller = GetControllerFromHandle(aruid, vibration_device_handle);- const auto device_index = static_cast<std::size_t>(vibration_device_handle.device_index);-- if (!controller.vibration[device_index].device_mounted || !controller.device->IsConnected()) {- return;- }-- if (vibration_device_handle.device_index == Core::HID::DeviceIndex::None) {- ASSERT_MSG(false, "DeviceIndex should never be None!");- return;- }-- // Some games try to send mismatched parameters in the device handle, block these.- if ((controller.device->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconLeft &&- (vibration_device_handle.npad_type == Core::HID::NpadStyleIndex::JoyconRight ||- vibration_device_handle.device_index == Core::HID::DeviceIndex::Right)) ||- (controller.device->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconRight &&- (vibration_device_handle.npad_type == Core::HID::NpadStyleIndex::JoyconLeft ||- vibration_device_handle.device_index == Core::HID::DeviceIndex::Left))) {- return;- }-- // Filter out vibrations with equivalent values to reduce unnecessary state changes.- if (vibration_value.low_amplitude ==- controller.vibration[device_index].latest_vibration_value.low_amplitude &&- vibration_value.high_amplitude ==- controller.vibration[device_index].latest_vibration_value.high_amplitude) {- return;- }-- if (VibrateControllerAtIndex(aruid, controller.device->GetNpadIdType(), device_index,- vibration_value)) {- controller.vibration[device_index].latest_vibration_value = vibration_value;- }-}--void NPad::VibrateControllers(- u64 aruid, std::span<const Core::HID::VibrationDeviceHandle> vibration_device_handles,- std::span<const Core::HID::VibrationValue> vibration_values) {- if (!Settings::values.vibration_enabled.GetValue() && !permit_vibration_session_enabled) {- return;- }-- ASSERT_OR_EXECUTE_MSG(- vibration_device_handles.size() == vibration_values.size(), { return; },- "The amount of device handles does not match with the amount of vibration values,"- "this is undefined behavior!");-- for (std::size_t i = 0; i < vibration_device_handles.size(); ++i) {- VibrateController(aruid, vibration_device_handles[i], vibration_values[i]);- }-}--Core::HID::VibrationValue NPad::GetLastVibration(- u64 aruid, const Core::HID::VibrationDeviceHandle& vibration_device_handle) const {- if (IsVibrationHandleValid(vibration_device_handle).IsError()) {- return {};- }-- const auto& controller = GetControllerFromHandle(aruid, vibration_device_handle);- const auto device_index = static_cast<std::size_t>(vibration_device_handle.device_index);- return controller.vibration[device_index].latest_vibration_value;-}--void NPad::InitializeVibrationDevice(- const Core::HID::VibrationDeviceHandle& vibration_device_handle) {- if (IsVibrationHandleValid(vibration_device_handle).IsError()) {- return;- }-- const auto aruid = applet_resource_holder.applet_resource->GetActiveAruid();- const auto npad_index = static_cast<Core::HID::NpadIdType>(vibration_device_handle.npad_id);- const auto device_index = static_cast<std::size_t>(vibration_device_handle.device_index);-- if (aruid == 0) {- return;- }-- InitializeVibrationDeviceAtIndex(aruid, npad_index, device_index);-}--void NPad::InitializeVibrationDeviceAtIndex(u64 aruid, Core::HID::NpadIdType npad_id,- std::size_t device_index) {- auto& controller = GetControllerFromNpadIdType(aruid, npad_id);- if (!Settings::values.vibration_enabled.GetValue()) {- controller.vibration[device_index].device_mounted = false;- return;- }-- controller.vibration[device_index].device_mounted =- controller.device->IsVibrationEnabled(device_index);-}--void NPad::SetPermitVibrationSession(bool permit_vibration_session) {- permit_vibration_session_enabled = permit_vibration_session;-}--bool NPad::IsVibrationDeviceMounted(- u64 aruid, const Core::HID::VibrationDeviceHandle& vibration_device_handle) const {- if (IsVibrationHandleValid(vibration_device_handle).IsError()) {- return false;- }-- const auto& controller = GetControllerFromHandle(aruid, vibration_device_handle);- const auto device_index = static_cast<std::size_t>(vibration_device_handle.device_index);- return controller.vibration[device_index].device_mounted;-}-Result NPad::AcquireNpadStyleSetUpdateEventHandle(u64 aruid, Kernel::KReadableEvent** out_event,Core::HID::NpadIdType npad_id) {std::scoped_lock lock{mutex};@@ -936,11 +773,6 @@ Result NPad::DisconnectNpad(u64 aruid, Core::HID::NpadIdType npad_id) {LOG_DEBUG(Service_HID, "Npad disconnected {}", npad_id);auto& controller = GetControllerFromNpadIdType(aruid, npad_id);- for (std::size_t device_idx = 0; device_idx < controller.vibration.size(); ++device_idx) {- // Send an empty vibration to stop any vibrations.- VibrateControllerAtIndex(aruid, npad_id, device_idx, {});- controller.vibration[device_idx].device_mounted = false;- }auto* shared_memory = controller.shared_memory;// Don't reset shared_memory->assignment_mode this value is persistent@@ -1236,22 +1068,17 @@ void NPad::UnregisterAppletResourceUserId(u64 aruid) {}void NPad::SetNpadExternals(std::shared_ptr<AppletResource> resource,- std::recursive_mutex* shared_mutex) {+ std::recursive_mutex* shared_mutex,+ std::shared_ptr<HandheldConfig> handheld_config) {applet_resource_holder.applet_resource = resource;applet_resource_holder.shared_mutex = shared_mutex;applet_resource_holder.shared_npad_resource = &npad_resource;-}+ applet_resource_holder.handheld_config = handheld_config;-NPad::NpadControllerData& NPad::GetControllerFromHandle(- u64 aruid, const Core::HID::VibrationDeviceHandle& device_handle) {- const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);- return GetControllerFromNpadIdType(aruid, npad_id);-}--const NPad::NpadControllerData& NPad::GetControllerFromHandle(- u64 aruid, const Core::HID::VibrationDeviceHandle& device_handle) const {- const auto npad_id = static_cast<Core::HID::NpadIdType>(device_handle.npad_id);- return GetControllerFromNpadIdType(aruid, npad_id);+ for (auto& abstract_pad : abstracted_pads) {+ abstract_pad.SetExternals(&applet_resource_holder, nullptr, nullptr, nullptr, nullptr,+ &vibration_handler, &hid_core);+ }}NPad::NpadControllerData& NPad::GetControllerFromHandle(@@ -1389,4 +1216,97 @@ Result NPad::GetLastActiveNpad(Core::HID::NpadIdType& out_npad_id) const {return ResultSuccess;}+NpadVibration* NPad::GetVibrationHandler() {+ return &vibration_handler;+}++std::vector<NpadVibrationBase*> NPad::GetAllVibrationDevices() {+ std::vector<NpadVibrationBase*> vibration_devices;++ for (auto& abstract_pad : abstracted_pads) {+ auto* left_device = abstract_pad.GetVibrationDevice(Core::HID::DeviceIndex::Left);+ auto* right_device = abstract_pad.GetVibrationDevice(Core::HID::DeviceIndex::Right);+ auto* n64_device = abstract_pad.GetGCVibrationDevice();+ auto* gc_device = abstract_pad.GetGCVibrationDevice();++ if (left_device != nullptr) {+ vibration_devices.emplace_back(left_device);+ }+ if (right_device != nullptr) {+ vibration_devices.emplace_back(right_device);+ }+ if (n64_device != nullptr) {+ vibration_devices.emplace_back(n64_device);+ }+ if (gc_device != nullptr) {+ vibration_devices.emplace_back(gc_device);+ }+ }++ return vibration_devices;+}++NpadVibrationBase* NPad::GetVibrationDevice(const Core::HID::VibrationDeviceHandle& handle) {+ if (IsVibrationHandleValid(handle).IsError()) {+ return nullptr;+ }++ const auto npad_index = NpadIdTypeToIndex(static_cast<Core::HID::NpadIdType>(handle.npad_id));+ const auto style_inde = static_cast<Core::HID::NpadStyleIndex>(handle.npad_type);+ if (style_inde == Core::HID::NpadStyleIndex::GameCube) {+ return abstracted_pads[npad_index].GetGCVibrationDevice();+ }+ if (style_inde == Core::HID::NpadStyleIndex::N64) {+ return abstracted_pads[npad_index].GetN64VibrationDevice();+ }+ return abstracted_pads[npad_index].GetVibrationDevice(handle.device_index);+}++NpadN64VibrationDevice* NPad::GetN64VibrationDevice(+ const Core::HID::VibrationDeviceHandle& handle) {+ if (IsVibrationHandleValid(handle).IsError()) {+ return nullptr;+ }++ const auto npad_index = NpadIdTypeToIndex(static_cast<Core::HID::NpadIdType>(handle.npad_id));+ const auto style_inde = static_cast<Core::HID::NpadStyleIndex>(handle.npad_type);+ if (style_inde != Core::HID::NpadStyleIndex::N64) {+ return nullptr;+ }+ return abstracted_pads[npad_index].GetN64VibrationDevice();+}++NpadVibrationDevice* NPad::GetNSVibrationDevice(const Core::HID::VibrationDeviceHandle& handle) {+ if (IsVibrationHandleValid(handle).IsError()) {+ return nullptr;+ }++ const auto npad_index = NpadIdTypeToIndex(static_cast<Core::HID::NpadIdType>(handle.npad_id));+ const auto style_inde = static_cast<Core::HID::NpadStyleIndex>(handle.npad_type);+ if (style_inde == Core::HID::NpadStyleIndex::GameCube ||+ style_inde == Core::HID::NpadStyleIndex::N64) {+ return nullptr;+ }++ return abstracted_pads[npad_index].GetVibrationDevice(handle.device_index);+}++NpadGcVibrationDevice* NPad::GetGcVibrationDevice(const Core::HID::VibrationDeviceHandle& handle) {+ if (IsVibrationHandleValid(handle).IsError()) {+ return nullptr;+ }++ const auto npad_index = NpadIdTypeToIndex(static_cast<Core::HID::NpadIdType>(handle.npad_id));+ const auto style_inde = static_cast<Core::HID::NpadStyleIndex>(handle.npad_type);+ if (style_inde != Core::HID::NpadStyleIndex::GameCube) {+ return nullptr;+ }+ return abstracted_pads[npad_index].GetGCVibrationDevice();+}++void NPad::UpdateHandheldAbstractState() {+ std::scoped_lock lock{mutex};+ abstracted_pads[NpadIdTypeToIndex(Core::HID::NpadIdType::Handheld)].Update();+}+} // namespace Service::HIDdiff --git a/src/hid_core/resources/npad/npad.h b/src/hid_core/resources/npad/npad.hindex 01f3dabb15..18b25c688e 100644--- a/src/hid_core/resources/npad/npad.h+++ b/src/hid_core/resources/npad/npad.h@@ -10,9 +10,15 @@#include "common/common_types.h"#include "hid_core/hid_types.h"+#include "hid_core/resources/abstracted_pad/abstract_pad.h"#include "hid_core/resources/controller_base.h"#include "hid_core/resources/npad/npad_resource.h"#include "hid_core/resources/npad/npad_types.h"+#include "hid_core/resources/npad/npad_vibration.h"+#include "hid_core/resources/vibration/gc_vibration_device.h"+#include "hid_core/resources/vibration/n64_vibration_device.h"+#include "hid_core/resources/vibration/vibration_base.h"+#include "hid_core/resources/vibration/vibration_device.h"namespace Core::HID {class EmulatedController;@@ -32,6 +38,7 @@ union Result;namespace Service::HID {class AppletResource;+struct HandheldConfig;struct NpadInternalState;struct NpadSixAxisSensorLifo;struct NpadSharedMemoryFormat;@@ -68,31 +75,6 @@ public:bool SetNpadMode(u64 aruid, Core::HID::NpadIdType& new_npad_id, Core::HID::NpadIdType npad_id,NpadJoyDeviceType npad_device_type, NpadJoyAssignmentMode assignment_mode);- bool VibrateControllerAtIndex(u64 aruid, Core::HID::NpadIdType npad_id,- std::size_t device_index,- const Core::HID::VibrationValue& vibration_value);-- void VibrateController(u64 aruid,- const Core::HID::VibrationDeviceHandle& vibration_device_handle,- const Core::HID::VibrationValue& vibration_value);-- void VibrateControllers(- u64 aruid, std::span<const Core::HID::VibrationDeviceHandle> vibration_device_handles,- std::span<const Core::HID::VibrationValue> vibration_values);-- Core::HID::VibrationValue GetLastVibration(- u64 aruid, const Core::HID::VibrationDeviceHandle& vibration_device_handle) const;-- void InitializeVibrationDevice(const Core::HID::VibrationDeviceHandle& vibration_device_handle);-- void InitializeVibrationDeviceAtIndex(u64 aruid, Core::HID::NpadIdType npad_id,- std::size_t device_index);-- void SetPermitVibrationSession(bool permit_vibration_session);-- bool IsVibrationDeviceMounted(- u64 aruid, const Core::HID::VibrationDeviceHandle& vibration_device_handle) const;-Result AcquireNpadStyleSetUpdateEventHandle(u64 aruid, Kernel::KReadableEvent** out_event,Core::HID::NpadIdType npad_id);@@ -145,7 +127,8 @@ public:Result RegisterAppletResourceUserId(u64 aruid);void UnregisterAppletResourceUserId(u64 aruid);void SetNpadExternals(std::shared_ptr<AppletResource> resource,- std::recursive_mutex* shared_mutex);+ std::recursive_mutex* shared_mutex,+ std::shared_ptr<HandheldConfig> handheld_config);AppletDetailedUiType GetAppletDetailedUiType(Core::HID::NpadIdType npad_id);@@ -161,18 +144,20 @@ public:Result GetLastActiveNpad(Core::HID::NpadIdType& out_npad_id) const;-private:- struct VibrationData {- bool device_mounted{};- Core::HID::VibrationValue latest_vibration_value{};- std::chrono::steady_clock::time_point last_vibration_timepoint{};- };+ NpadVibration* GetVibrationHandler();+ std::vector<NpadVibrationBase*> GetAllVibrationDevices();+ NpadVibrationBase* GetVibrationDevice(const Core::HID::VibrationDeviceHandle& handle);+ NpadN64VibrationDevice* GetN64VibrationDevice(const Core::HID::VibrationDeviceHandle& handle);+ NpadVibrationDevice* GetNSVibrationDevice(const Core::HID::VibrationDeviceHandle& handle);+ NpadGcVibrationDevice* GetGcVibrationDevice(const Core::HID::VibrationDeviceHandle& handle);+ void UpdateHandheldAbstractState();++private:struct NpadControllerData {NpadInternalState* shared_memory = nullptr;Core::HID::EmulatedController* device = nullptr;- std::array<VibrationData, 2> vibration{};bool is_connected{};// Dual joycons can have only one side connected@@ -191,10 +176,6 @@ private:void RequestPadStateUpdate(u64 aruid, Core::HID::NpadIdType npad_id);void WriteEmptyEntry(NpadInternalState* npad);- NpadControllerData& GetControllerFromHandle(- u64 aruid, const Core::HID::VibrationDeviceHandle& device_handle);- const NpadControllerData& GetControllerFromHandle(- u64 aruid, const Core::HID::VibrationDeviceHandle& device_handle) const;NpadControllerData& GetControllerFromHandle(u64 aruid, const Core::HID::SixAxisSensorHandle& device_handle);const NpadControllerData& GetControllerFromHandle(@@ -215,11 +196,13 @@ private:mutable std::mutex mutex;NPadResource npad_resource;AppletResourceHolder applet_resource_holder{};+ std::array<AbstractPad, MaxSupportedNpadIdTypes> abstracted_pads;+ NpadVibration vibration_handler{};+Kernel::KEvent* input_event{nullptr};std::mutex* input_mutex{nullptr};std::atomic<u64> press_state{};- bool permit_vibration_session_enabled;std::array<std::array<NpadControllerData, MaxSupportedNpadIdTypes>, AruidIndexMax>controller_data{};};diff --git a/src/hid_core/resources/npad/npad_types.h b/src/hid_core/resources/npad/npad_types.hindex fd86c8e403..92700d69a6 100644--- a/src/hid_core/resources/npad/npad_types.h+++ b/src/hid_core/resources/npad/npad_types.h@@ -8,6 +8,10 @@#include "common/common_types.h"#include "hid_core/hid_types.h"+namespace Core::HID {+class EmulatedController;+}+namespace Service::HID {static constexpr std::size_t MaxSupportedNpadIdTypes = 10;static constexpr std::size_t StyleIndexCount = 7;@@ -348,7 +352,7 @@ struct IAbstractedPad {u8 indicator;std::vector<f32> virtual_six_axis_sensor_acceleration;std::vector<f32> virtual_six_axis_sensor_angle;- u64 xcd_handle;+ Core::HID::EmulatedController* xcd_handle;u64 color;};} // namespace Service::HIDdiff --git a/src/hid_core/resources/npad/npad_vibration.cpp b/src/hid_core/resources/npad/npad_vibration.cppindex 7056e8eab7..05aad4c54f 100644--- a/src/hid_core/resources/npad/npad_vibration.cpp+++ b/src/hid_core/resources/npad/npad_vibration.cpp@@ -77,4 +77,8 @@ Result NpadVibration::EndPermitVibrationSession() {return ResultSuccess;}+u64 NpadVibration::GetSessionAruid() const {+ return session_aruid;+}+} // namespace Service::HIDdiff --git a/src/hid_core/resources/npad/npad_vibration.h b/src/hid_core/resources/npad/npad_vibration.hindex 0748aeffc1..d5a95f2a09 100644--- a/src/hid_core/resources/npad/npad_vibration.h+++ b/src/hid_core/resources/npad/npad_vibration.h@@ -25,6 +25,8 @@ public:Result BeginPermitVibrationSession(u64 aruid);Result EndPermitVibrationSession();+ u64 GetSessionAruid() const;+private:f32 volume{};u64 session_aruid{};diff --git a/src/hid_core/resources/vibration/gc_vibration_device.cpp b/src/hid_core/resources/vibration/gc_vibration_device.cppindex f01f81b9a3..ad42b9d660 100644--- a/src/hid_core/resources/vibration/gc_vibration_device.cpp+++ b/src/hid_core/resources/vibration/gc_vibration_device.cpp@@ -1,6 +1,7 @@// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later+#include "hid_core/frontend/emulated_controller.h"#include "hid_core/hid_result.h"#include "hid_core/resources/npad/npad_types.h"#include "hid_core/resources/npad/npad_vibration.h"@@ -10,24 +11,25 @@ namespace Service::HID {NpadGcVibrationDevice::NpadGcVibrationDevice() {}-Result NpadGcVibrationDevice::IncrementRefCounter() {+Result NpadGcVibrationDevice::Activate() {if (ref_counter == 0 && is_mounted) {f32 volume = 1.0f;const auto result = vibration_handler->GetVibrationVolume(volume);if (result.IsSuccess()) {- // TODO: SendVibrationGcErmCommand+ xcd_handle->SetVibration(adapter_slot, Core::HID::VibrationGcErmCommand::Stop);}}+ref_counter++;return ResultSuccess;}-Result NpadGcVibrationDevice::DecrementRefCounter() {- if (ref_counter == 1 && !is_mounted) {+Result NpadGcVibrationDevice::Deactivate() {+ if (ref_counter == 1 && is_mounted) {f32 volume = 1.0f;const auto result = vibration_handler->GetVibrationVolume(volume);if (result.IsSuccess()) {- // TODO: SendVibrationGcErmCommand+ xcd_handle->SetVibration(adapter_slot, Core::HID::VibrationGcErmCommand::Stop);}}@@ -38,6 +40,48 @@ Result NpadGcVibrationDevice::DecrementRefCounter() {return ResultSuccess;}+Result NpadGcVibrationDevice::Mount(IAbstractedPad& abstracted_pad, u32 slot,+ NpadVibration* handler) {+ if (!abstracted_pad.internal_flags.is_connected) {+ return ResultSuccess;+ }++ // TODO: This device doesn't use a xcd handle instead has an GC adapter handle. This is just to+ // keep compatibility with the front end.+ xcd_handle = abstracted_pad.xcd_handle;+ adapter_slot = slot;+ vibration_handler = handler;+ is_mounted = true;++ if (ref_counter == 0) {+ return ResultSuccess;+ }++ f32 volume{1.0f};+ const auto result = vibration_handler->GetVibrationVolume(volume);+ if (result.IsSuccess()) {+ xcd_handle->SetVibration(adapter_slot, Core::HID::VibrationGcErmCommand::Stop);+ }++ return ResultSuccess;+}++Result NpadGcVibrationDevice::Unmount() {+ if (ref_counter == 0 || !is_mounted) {+ is_mounted = false;+ return ResultSuccess;+ }++ f32 volume{1.0f};+ const auto result = vibration_handler->GetVibrationVolume(volume);+ if (result.IsSuccess()) {+ xcd_handle->SetVibration(adapter_slot, Core::HID::VibrationGcErmCommand::Stop);+ }++ is_mounted = false;+ return ResultSuccess;+}+Result NpadGcVibrationDevice::SendVibrationGcErmCommand(Core::HID::VibrationGcErmCommand command) {if (!is_mounted) {return ResultSuccess;@@ -55,7 +99,7 @@ Result NpadGcVibrationDevice::SendVibrationGcErmCommand(Core::HID::VibrationGcErreturn ResultSuccess;}}- // TODO: SendVibrationGcErmCommand+ xcd_handle->SetVibration(adapter_slot, command);return ResultSuccess;}diff --git a/src/hid_core/resources/vibration/gc_vibration_device.h b/src/hid_core/resources/vibration/gc_vibration_device.hindex 87abca57dc..c624cbb28f 100644--- a/src/hid_core/resources/vibration/gc_vibration_device.h+++ b/src/hid_core/resources/vibration/gc_vibration_device.h@@ -20,12 +20,18 @@ class NpadGcVibrationDevice final : public NpadVibrationBase {public:explicit NpadGcVibrationDevice();- Result IncrementRefCounter() override;- Result DecrementRefCounter() override;+ Result Activate() override;+ Result Deactivate() override;++ Result Mount(IAbstractedPad& abstracted_pad, u32 slot, NpadVibration* handler);+ Result Unmount();Result SendVibrationGcErmCommand(Core::HID::VibrationGcErmCommand command);Result GetActualVibrationGcErmCommand(Core::HID::VibrationGcErmCommand& out_command);Result SendVibrationNotificationPattern(Core::HID::VibrationGcErmCommand command);++private:+ u32 adapter_slot;};} // namespace Service::HIDdiff --git a/src/hid_core/resources/vibration/n64_vibration_device.cpp b/src/hid_core/resources/vibration/n64_vibration_device.cppindex 639f87abf3..94ad37c8f7 100644--- a/src/hid_core/resources/vibration/n64_vibration_device.cpp+++ b/src/hid_core/resources/vibration/n64_vibration_device.cpp@@ -1,6 +1,7 @@// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later+#include "hid_core/frontend/emulated_controller.h"#include "hid_core/hid_result.h"#include "hid_core/resources/npad/npad_types.h"#include "hid_core/resources/npad/npad_vibration.h"@@ -10,12 +11,12 @@ namespace Service::HID {NpadN64VibrationDevice::NpadN64VibrationDevice() {}-Result NpadN64VibrationDevice::IncrementRefCounter() {+Result NpadN64VibrationDevice::Activate() {if (ref_counter == 0 && is_mounted) {f32 volume = 1.0f;const auto result = vibration_handler->GetVibrationVolume(volume);if (result.IsSuccess()) {- // TODO: SendVibrationInBool+ xcd_handle->SetVibration(false);}}@@ -23,19 +24,12 @@ Result NpadN64VibrationDevice::IncrementRefCounter() {return ResultSuccess;}-Result NpadN64VibrationDevice::DecrementRefCounter() {- if (ref_counter == 1) {- if (!is_mounted) {- ref_counter = 0;- if (is_mounted != false) {- // TODO: SendVibrationInBool- }- return ResultSuccess;- }+Result NpadN64VibrationDevice::Deactivate() {+ if (ref_counter == 1 && is_mounted) {f32 volume = 1.0f;const auto result = vibration_handler->GetVibrationVolume(volume);if (result.IsSuccess()) {- // TODO+ xcd_handle->SetVibration(false);}}@@ -46,6 +40,43 @@ Result NpadN64VibrationDevice::DecrementRefCounter() {return ResultSuccess;}+Result NpadN64VibrationDevice::Mount(IAbstractedPad& abstracted_pad, NpadVibration* handler) {+ if (!abstracted_pad.internal_flags.is_connected) {+ return ResultSuccess;+ }+ xcd_handle = abstracted_pad.xcd_handle;+ vibration_handler = handler;+ is_mounted = true;++ if (ref_counter == 0) {+ return ResultSuccess;+ }++ f32 volume{1.0f};+ const auto result = vibration_handler->GetVibrationVolume(volume);+ if (result.IsSuccess()) {+ xcd_handle->SetVibration(false);+ }++ return ResultSuccess;+}++Result NpadN64VibrationDevice::Unmount() {+ if (ref_counter == 0 || !is_mounted) {+ is_mounted = false;+ return ResultSuccess;+ }++ f32 volume{1.0f};+ const auto result = vibration_handler->GetVibrationVolume(volume);+ if (result.IsSuccess()) {+ xcd_handle->SetVibration(false);+ }++ is_mounted = false;+ return ResultSuccess;+}+Result NpadN64VibrationDevice::SendValueInBool(bool is_vibrating) {if (ref_counter < 1) {return ResultVibrationNotInitialized;@@ -56,7 +87,7 @@ Result NpadN64VibrationDevice::SendValueInBool(bool is_vibrating) {if (result.IsError()) {return result;}- // TODO: SendVibrationInBool+ xcd_handle->SetVibration(false);}return ResultSuccess;}diff --git a/src/hid_core/resources/vibration/n64_vibration_device.h b/src/hid_core/resources/vibration/n64_vibration_device.hindex 54e6efc1ae..09de7701cb 100644--- a/src/hid_core/resources/vibration/n64_vibration_device.h+++ b/src/hid_core/resources/vibration/n64_vibration_device.h@@ -14,14 +14,18 @@namespace Service::HID {class NpadVibration;+struct IAbstractedPad;/// Handles Npad request from HID interfacesclass NpadN64VibrationDevice final : public NpadVibrationBase {public:explicit NpadN64VibrationDevice();- Result IncrementRefCounter() override;- Result DecrementRefCounter() override;+ Result Activate() override;+ Result Deactivate() override;++ Result Mount(IAbstractedPad& abstracted_pad, NpadVibration* handler);+ Result Unmount();Result SendValueInBool(bool is_vibrating);Result SendVibrationNotificationPattern(u32 pattern);diff --git a/src/hid_core/resources/vibration/vibration_base.cpp b/src/hid_core/resources/vibration/vibration_base.cppindex 350f349c22..f28d304060 100644--- a/src/hid_core/resources/vibration/vibration_base.cpp+++ b/src/hid_core/resources/vibration/vibration_base.cpp@@ -10,12 +10,12 @@ namespace Service::HID {NpadVibrationBase::NpadVibrationBase() {}-Result NpadVibrationBase::IncrementRefCounter() {+Result NpadVibrationBase::Activate() {ref_counter++;return ResultSuccess;}-Result NpadVibrationBase::DecrementRefCounter() {+Result NpadVibrationBase::Deactivate() {if (ref_counter > 0) {ref_counter--;}diff --git a/src/hid_core/resources/vibration/vibration_base.h b/src/hid_core/resources/vibration/vibration_base.hindex c6c5fc4d94..69c26e6690 100644--- a/src/hid_core/resources/vibration/vibration_base.h+++ b/src/hid_core/resources/vibration/vibration_base.h@@ -6,6 +6,10 @@#include "common/common_types.h"#include "core/hle/result.h"+namespace Core::HID {+class EmulatedController;+}+namespace Service::HID {class NpadVibration;@@ -14,13 +18,13 @@ class NpadVibrationBase {public:explicit NpadVibrationBase();- virtual Result IncrementRefCounter();- virtual Result DecrementRefCounter();+ virtual Result Activate();+ virtual Result Deactivate();bool IsVibrationMounted() const;protected:- u64 xcd_handle{};+ Core::HID::EmulatedController* xcd_handle{nullptr};s32 ref_counter{};bool is_mounted{};NpadVibration* vibration_handler{nullptr};diff --git a/src/hid_core/resources/vibration/vibration_device.cpp b/src/hid_core/resources/vibration/vibration_device.cppindex 888c3a7ed6..08b14591f9 100644--- a/src/hid_core/resources/vibration/vibration_device.cpp+++ b/src/hid_core/resources/vibration/vibration_device.cpp@@ -1,6 +1,7 @@// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later+#include "hid_core/frontend/emulated_controller.h"#include "hid_core/hid_result.h"#include "hid_core/resources/npad/npad_types.h"#include "hid_core/resources/npad/npad_vibration.h"@@ -10,12 +11,30 @@ namespace Service::HID {NpadVibrationDevice::NpadVibrationDevice() {}-Result NpadVibrationDevice::IncrementRefCounter() {+Result NpadVibrationDevice::Activate() {+ if (ref_counter == 0 && is_mounted) {+ f32 volume = 1.0f;+ const auto result = vibration_handler->GetVibrationVolume(volume);+ if (result.IsSuccess()) {+ xcd_handle->SetVibration(device_index, Core::HID::DEFAULT_VIBRATION_VALUE);+ // TODO: SendNotificationPattern;+ }+ }+ref_counter++;return ResultSuccess;}-Result NpadVibrationDevice::DecrementRefCounter() {+Result NpadVibrationDevice::Deactivate() {+ if (ref_counter == 1 && is_mounted) {+ f32 volume = 1.0f;+ const auto result = vibration_handler->GetVibrationVolume(volume);+ if (result.IsSuccess()) {+ xcd_handle->SetVibration(device_index, Core::HID::DEFAULT_VIBRATION_VALUE);+ // TODO: SendNotificationPattern;+ }+ }+if (ref_counter > 0) {ref_counter--;}@@ -23,6 +42,45 @@ Result NpadVibrationDevice::DecrementRefCounter() {return ResultSuccess;}+Result NpadVibrationDevice::Mount(IAbstractedPad& abstracted_pad, Core::HID::DeviceIndex index,+ NpadVibration* handler) {+ if (!abstracted_pad.internal_flags.is_connected) {+ return ResultSuccess;+ }+ xcd_handle = abstracted_pad.xcd_handle;+ device_index = index;+ vibration_handler = handler;+ is_mounted = true;++ if (ref_counter == 0) {+ return ResultSuccess;+ }++ f32 volume{1.0f};+ const auto result = vibration_handler->GetVibrationVolume(volume);+ if (result.IsSuccess()) {+ xcd_handle->SetVibration(false);+ }++ return ResultSuccess;+}++Result NpadVibrationDevice::Unmount() {+ if (ref_counter == 0 || !is_mounted) {+ is_mounted = false;+ return ResultSuccess;+ }++ f32 volume{1.0f};+ const auto result = vibration_handler->GetVibrationVolume(volume);+ if (result.IsSuccess()) {+ xcd_handle->SetVibration(device_index, Core::HID::DEFAULT_VIBRATION_VALUE);+ }++ is_mounted = false;+ return ResultSuccess;+}+Result NpadVibrationDevice::SendVibrationValue(const Core::HID::VibrationValue& value) {if (ref_counter == 0) {return ResultVibrationNotInitialized;@@ -37,7 +95,7 @@ Result NpadVibrationDevice::SendVibrationValue(const Core::HID::VibrationValue&return result;}if (volume <= 0.0f) {- // TODO: SendVibrationValue+ xcd_handle->SetVibration(device_index, Core::HID::DEFAULT_VIBRATION_VALUE);return ResultSuccess;}@@ -45,7 +103,7 @@ Result NpadVibrationDevice::SendVibrationValue(const Core::HID::VibrationValue&vibration_value.high_amplitude *= volume;vibration_value.low_amplitude *= volume;- // TODO: SendVibrationValue+ xcd_handle->SetVibration(device_index, vibration_value);return ResultSuccess;}@@ -63,11 +121,11 @@ Result NpadVibrationDevice::SendVibrationNotificationPattern([[maybe_unused]] u3pattern = 0;}- // return xcd_handle->SendVibrationNotificationPattern(pattern);+ // TODO: SendVibrationNotificationPattern;return ResultSuccess;}-Result NpadVibrationDevice::GetActualVibrationValue(Core::HID::VibrationValue& out_value) {+Result NpadVibrationDevice::GetActualVibrationValue(Core::HID::VibrationValue& out_value) const {if (ref_counter < 1) {return ResultVibrationNotInitialized;}@@ -77,7 +135,7 @@ Result NpadVibrationDevice::GetActualVibrationValue(Core::HID::VibrationValue& oreturn ResultSuccess;}- // TODO: SendVibrationValue+ out_value = xcd_handle->GetActualVibrationValue(device_index);return ResultSuccess;}diff --git a/src/hid_core/resources/vibration/vibration_device.h b/src/hid_core/resources/vibration/vibration_device.hindex 3574ad60b7..c2f9891d3a 100644--- a/src/hid_core/resources/vibration/vibration_device.h+++ b/src/hid_core/resources/vibration/vibration_device.h@@ -12,6 +12,10 @@#include "hid_core/resources/npad/npad_types.h"#include "hid_core/resources/vibration/vibration_base.h"+namespace Core::HID {+enum class DeviceIndex : u8;+}+namespace Service::HID {class NpadVibration;@@ -20,16 +24,20 @@ class NpadVibrationDevice final : public NpadVibrationBase {public:explicit NpadVibrationDevice();- Result IncrementRefCounter();- Result DecrementRefCounter();+ Result Activate();+ Result Deactivate();++ Result Mount(IAbstractedPad& abstracted_pad, Core::HID::DeviceIndex index,+ NpadVibration* handler);+ Result Unmount();Result SendVibrationValue(const Core::HID::VibrationValue& value);Result SendVibrationNotificationPattern(u32 pattern);- Result GetActualVibrationValue(Core::HID::VibrationValue& out_value);+ Result GetActualVibrationValue(Core::HID::VibrationValue& out_value) const;private:- u32 device_index{};+ Core::HID::DeviceIndex device_index{};};} // namespace Service::HIDdiff --git a/src/yuzu/configuration/configure_vibration.cpp b/src/yuzu/configuration/configure_vibration.cppindex d898d8accf..6b1f4527b8 100644--- a/src/yuzu/configuration/configure_vibration.cpp+++ b/src/yuzu/configuration/configure_vibration.cpp@@ -116,8 +116,8 @@ void ConfigureVibration::VibrateController(Core::HID::ControllerTriggerType type.high_amplitude = 1.0f,.high_frequency = 320.0f,};- controller->SetVibration(0, vibration);- controller->SetVibration(1, vibration);+ controller->SetVibration(Core::HID::DeviceIndex::Left, vibration);+ controller->SetVibration(Core::HID::DeviceIndex::Right, vibration);// Restore previous valuesplayer.vibration_enabled = old_vibration_enabled;@@ -127,7 +127,7 @@ void ConfigureVibration::VibrateController(Core::HID::ControllerTriggerType typevoid ConfigureVibration::StopVibrations() {for (std::size_t i = 0; i < NUM_PLAYERS; ++i) {auto controller = hid_core.GetEmulatedControllerByIndex(i);- controller->SetVibration(0, Core::HID::DEFAULT_VIBRATION_VALUE);- controller->SetVibration(1, Core::HID::DEFAULT_VIBRATION_VALUE);+ controller->SetVibration(Core::HID::DeviceIndex::Left, Core::HID::DEFAULT_VIBRATION_VALUE);+ controller->SetVibration(Core::HID::DeviceIndex::Right, Core::HID::DEFAULT_VIBRATION_VALUE);}}