yuzu-emu
/
yuzu-mainline
Archived
1
0
Fork 0
Code

core/hid: Rename NpadType to NpadStyleIndex

This commit is contained in:
german77 2021-11-04 12:08:54 -06:00 committed by Narr the Reg
parent 84c58666a4
commit 5d0f3540c4
15 changed files with 228 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/core/frontend/applets/controller.cpp
View File

@ -44,26 +44,26 @@ void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callb
// Connect controllers based on the following priority list from highest to lowest priority: // Connect controllers based on the following priority list from highest to lowest priority:
// Pro Controller -> Dual Joycons -> Left Joycon/Right Joycon -> Handheld // Pro Controller -> Dual Joycons -> Left Joycon/Right Joycon -> Handheld
if (parameters.allow_pro_controller) { if (parameters.allow_pro_controller) {
controller->SetNpadType(Core::HID::NpadType::ProController); controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::ProController);
controller->Connect(); controller->Connect();
} else if (parameters.allow_dual_joycons) { } else if (parameters.allow_dual_joycons) {
controller->SetNpadType(Core::HID::NpadType::JoyconDual); controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::JoyconDual);
controller->Connect(); controller->Connect();
} else if (parameters.allow_left_joycon && parameters.allow_right_joycon) { } else if (parameters.allow_left_joycon && parameters.allow_right_joycon) {
// Assign left joycons to even player indices and right joycons to odd player indices. // Assign left joycons to even player indices and right joycons to odd player indices.
// We do this since Captain Toad Treasure Tracker expects a left joycon for Player 1 and // We do this since Captain Toad Treasure Tracker expects a left joycon for Player 1 and
// a right Joycon for Player 2 in 2 Player Assist mode. // a right Joycon for Player 2 in 2 Player Assist mode.
if (index % 2 == 0) { if (index % 2 == 0) {
controller->SetNpadType(Core::HID::NpadType::JoyconLeft); controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::JoyconLeft);
controller->Connect(); controller->Connect();
} else { } else {
controller->SetNpadType(Core::HID::NpadType::JoyconRight); controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::JoyconRight);
controller->Connect(); controller->Connect();
} }
} else if (index == 0 && parameters.enable_single_mode && parameters.allow_handheld && } else if (index == 0 && parameters.enable_single_mode && parameters.allow_handheld &&
!Settings::values.use_docked_mode.GetValue()) { !Settings::values.use_docked_mode.GetValue()) {
// We should *never* reach here under any normal circumstances. // We should *never* reach here under any normal circumstances.
controller->SetNpadType(Core::HID::NpadType::Handheld); controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Handheld);
controller->Connect(); controller->Connect();
} else { } else {
UNREACHABLE_MSG("Unable to add a new controller based on the given parameters!"); UNREACHABLE_MSG("Unable to add a new controller based on the given parameters!");

44
src/core/hid/emulated_controller.cpp
View File

@ -13,38 +13,38 @@ EmulatedController::EmulatedController(NpadIdType npad_id_type_) : npad_id_type(
EmulatedController::~EmulatedController() = default; EmulatedController::~EmulatedController() = default;
NpadType EmulatedController::MapSettingsTypeToNPad(Settings::ControllerType type) { NpadStyleIndex EmulatedController::MapSettingsTypeToNPad(Settings::ControllerType type) {
switch (type) { switch (type) {
case Settings::ControllerType::ProController: case Settings::ControllerType::ProController:
return NpadType::ProController; return NpadStyleIndex::ProController;
case Settings::ControllerType::DualJoyconDetached: case Settings::ControllerType::DualJoyconDetached:
return NpadType::JoyconDual; return NpadStyleIndex::JoyconDual;
case Settings::ControllerType::LeftJoycon: case Settings::ControllerType::LeftJoycon:
return NpadType::JoyconLeft; return NpadStyleIndex::JoyconLeft;
case Settings::ControllerType::RightJoycon: case Settings::ControllerType::RightJoycon:
return NpadType::JoyconRight; return NpadStyleIndex::JoyconRight;
case Settings::ControllerType::Handheld: case Settings::ControllerType::Handheld:
return NpadType::Handheld; return NpadStyleIndex::Handheld;
case Settings::ControllerType::GameCube: case Settings::ControllerType::GameCube:
return NpadType::GameCube; return NpadStyleIndex::GameCube;
default: default:
return NpadType::ProController; return NpadStyleIndex::ProController;
} }
} }
Settings::ControllerType EmulatedController::MapNPadToSettingsType(NpadType type) { Settings::ControllerType EmulatedController::MapNPadToSettingsType(NpadStyleIndex type) {
switch (type) { switch (type) {
case NpadType::ProController: case NpadStyleIndex::ProController:
return Settings::ControllerType::ProController; return Settings::ControllerType::ProController;
case NpadType::JoyconDual: case NpadStyleIndex::JoyconDual:
return Settings::ControllerType::DualJoyconDetached; return Settings::ControllerType::DualJoyconDetached;
case NpadType::JoyconLeft: case NpadStyleIndex::JoyconLeft:
return Settings::ControllerType::LeftJoycon; return Settings::ControllerType::LeftJoycon;
case NpadType::JoyconRight: case NpadStyleIndex::JoyconRight:
return Settings::ControllerType::RightJoycon; return Settings::ControllerType::RightJoycon;
case NpadType::Handheld: case NpadStyleIndex::Handheld:
return Settings::ControllerType::Handheld; return Settings::ControllerType::Handheld;
case NpadType::GameCube: case NpadStyleIndex::GameCube:
return Settings::ControllerType::GameCube; return Settings::ControllerType::GameCube;
default: default:
return Settings::ControllerType::ProController; return Settings::ControllerType::ProController;
@ -79,9 +79,9 @@ void EmulatedController::ReloadFromSettings() {
// Other or debug controller should always be a pro controller // Other or debug controller should always be a pro controller
if (npad_id_type != NpadIdType::Other) { if (npad_id_type != NpadIdType::Other) {
SetNpadType(MapSettingsTypeToNPad(player.controller_type)); SetNpadStyleIndex(MapSettingsTypeToNPad(player.controller_type));
} else { } else {
SetNpadType(NpadType::ProController); SetNpadStyleIndex(NpadStyleIndex::ProController);
} }
if (player.connected) { if (player.connected) {
@ -306,7 +306,7 @@ void EmulatedController::DisableConfiguration() {
if (is_connected) { if (is_connected) {
Disconnect(); Disconnect();
} }
SetNpadType(tmp_npad_type); SetNpadStyleIndex(tmp_npad_type);
} }
// Apply temporary connected status to the real controller // Apply temporary connected status to the real controller
@ -569,10 +569,10 @@ void EmulatedController::SetButton(Common::Input::CallbackStatus callback, std::
} }
} }
if (!is_connected) { if (!is_connected) {
if (npad_id_type == NpadIdType::Player1 && npad_type != NpadType::Handheld) { if (npad_id_type == NpadIdType::Player1 && npad_type != NpadStyleIndex::Handheld) {
Connect(); Connect();
} }
if (npad_id_type == NpadIdType::Handheld && npad_type == NpadType::Handheld) { if (npad_id_type == NpadIdType::Handheld && npad_type == NpadStyleIndex::Handheld) {
Connect(); Connect();
} }
} }
@ -896,14 +896,14 @@ NpadIdType EmulatedController::GetNpadIdType() const {
return npad_id_type; return npad_id_type;
} }
NpadType EmulatedController::GetNpadType(bool get_temporary_value) const { NpadStyleIndex EmulatedController::GetNpadStyleIndex(bool get_temporary_value) const {
if (get_temporary_value) { if (get_temporary_value) {
return tmp_npad_type; return tmp_npad_type;
} }
return npad_type; return npad_type;
} }
void EmulatedController::SetNpadType(NpadType npad_type_) { void EmulatedController::SetNpadStyleIndex(NpadStyleIndex npad_type_) {
{ {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};

18
src/core/hid/emulated_controller.h
View File

@ -142,23 +142,23 @@ public:
YUZU_NON_MOVEABLE(EmulatedController); YUZU_NON_MOVEABLE(EmulatedController);
/// Converts the controller type from settings to npad type /// Converts the controller type from settings to npad type
static NpadType MapSettingsTypeToNPad(Settings::ControllerType type); static NpadStyleIndex MapSettingsTypeToNPad(Settings::ControllerType type);
/// Converts npad type to the equivalent of controller type from settings /// Converts npad type to the equivalent of controller type from settings
static Settings::ControllerType MapNPadToSettingsType(NpadType type); static Settings::ControllerType MapNPadToSettingsType(NpadStyleIndex type);
/// Gets the NpadIdType for this controller /// Gets the NpadIdType for this controller
NpadIdType GetNpadIdType() const; NpadIdType GetNpadIdType() const;
/// Sets the NpadType for this controller /// Sets the NpadStyleIndex for this controller
void SetNpadType(NpadType npad_type_); void SetNpadStyleIndex(NpadStyleIndex npad_type_);
/** /**
* Gets the NpadType for this controller * Gets the NpadStyleIndex for this controller
* @param If true tmp_npad_type will be returned * @param If true tmp_npad_type will be returned
* @return NpadType set on the controller * @return NpadStyleIndex set on the controller
*/ */
NpadType GetNpadType(bool get_temporary_value = false) const; NpadStyleIndex GetNpadStyleIndex(bool get_temporary_value = false) const;
/// Sets the connected status to true /// Sets the connected status to true
void Connect(); void Connect();
@ -351,14 +351,14 @@ private:
void TriggerOnChange(ControllerTriggerType type, bool is_service_update); void TriggerOnChange(ControllerTriggerType type, bool is_service_update);
NpadIdType npad_id_type; NpadIdType npad_id_type;
NpadType npad_type{NpadType::None}; NpadStyleIndex npad_type{NpadStyleIndex::None};
bool is_connected{false}; bool is_connected{false};
bool is_configuring{false}; bool is_configuring{false};
f32 motion_sensitivity{0.01f}; f32 motion_sensitivity{0.01f};
bool force_update_motion{false}; bool force_update_motion{false};
// Temporary values to avoid doing changes while the controller is on configuration mode // Temporary values to avoid doing changes while the controller is on configuration mode
NpadType tmp_npad_type{NpadType::None}; NpadStyleIndex tmp_npad_type{NpadStyleIndex::None};
bool tmp_is_connected{false}; bool tmp_is_connected{false};
ButtonParams button_params; ButtonParams button_params;

13
src/core/hid/hid_types.h
View File

@ -84,8 +84,8 @@ constexpr NpadIdType IndexToNpadIdType(size_t index) {
} }
} }
// This is nn::hid::NpadType // This is nn::hid::NpadStyleIndex
enum class NpadType : u8 { enum class NpadStyleIndex : u8 {
None = 0, None = 0,
ProController = 3, ProController = 3,
Handheld = 4, Handheld = 4,
@ -94,7 +94,14 @@ enum class NpadType : u8 {
JoyconRight = 7, JoyconRight = 7,
GameCube = 8, GameCube = 8,
Pokeball = 9, Pokeball = 9,
MaxNpadType = 10, NES = 10,
HandheldNES = 11,
SNES = 12,
N64 = 13,
SegaGenesis = 14,
SystemExt = 32,
System = 33,
MaxNpadType = 34,
}; };
// This is nn::hid::NpadStyleTag // This is nn::hid::NpadStyleTag

129
src/core/hle/service/hid/controllers/npad.cpp
View File

@ -93,7 +93,7 @@ bool Controller_NPad::IsNpadIdValid(u32 npad_id) {
bool Controller_NPad::IsDeviceHandleValid(const DeviceHandle& device_handle) { bool Controller_NPad::IsDeviceHandleValid(const DeviceHandle& device_handle) {
return IsNpadIdValid(device_handle.npad_id) && return IsNpadIdValid(device_handle.npad_id) &&
device_handle.npad_type < Core::HID::NpadType::MaxNpadType && device_handle.npad_type < Core::HID::NpadStyleIndex::MaxNpadType &&
device_handle.device_index < DeviceIndex::MaxDeviceIndex; device_handle.device_index < DeviceIndex::MaxDeviceIndex;
} }
@ -134,7 +134,7 @@ void Controller_NPad::ControllerUpdate(Core::HID::ControllerTriggerType type,
auto& controller = controller_data[controller_idx]; auto& controller = controller_data[controller_idx];
const auto is_connected = controller.device->IsConnected(); const auto is_connected = controller.device->IsConnected();
const auto npad_type = controller.device->GetNpadType(); const auto npad_type = controller.device->GetNpadStyleIndex();
switch (type) { switch (type) {
case Core::HID::ControllerTriggerType::Connected: case Core::HID::ControllerTriggerType::Connected:
case Core::HID::ControllerTriggerType::Disconnected: case Core::HID::ControllerTriggerType::Disconnected:
@ -161,9 +161,9 @@ void Controller_NPad::ControllerUpdate(Core::HID::ControllerTriggerType type,
void Controller_NPad::InitNewlyAddedController(std::size_t controller_idx) { void Controller_NPad::InitNewlyAddedController(std::size_t controller_idx) {
auto& controller = controller_data[controller_idx]; auto& controller = controller_data[controller_idx];
const auto controller_type = controller.device->GetNpadType(); const auto controller_type = controller.device->GetNpadStyleIndex();
auto& shared_memory = controller.shared_memory_entry; auto& shared_memory = controller.shared_memory_entry;
if (controller_type == Core::HID::NpadType::None) { if (controller_type == Core::HID::NpadStyleIndex::None) {
controller.styleset_changed_event->GetWritableEvent().Signal(); controller.styleset_changed_event->GetWritableEvent().Signal();
return; return;
} }
@ -171,10 +171,10 @@ void Controller_NPad::InitNewlyAddedController(std::size_t controller_idx) {
shared_memory.device_type.raw = 0; shared_memory.device_type.raw = 0;
shared_memory.system_properties.raw = 0; shared_memory.system_properties.raw = 0;
switch (controller_type) { switch (controller_type) {
case Core::HID::NpadType::None: case Core::HID::NpadStyleIndex::None:
UNREACHABLE(); UNREACHABLE();
break; break;
case Core::HID::NpadType::ProController: case Core::HID::NpadStyleIndex::ProController:
shared_memory.style_set.fullkey.Assign(1); shared_memory.style_set.fullkey.Assign(1);
shared_memory.device_type.fullkey.Assign(1); shared_memory.device_type.fullkey.Assign(1);
shared_memory.system_properties.is_vertical.Assign(1); shared_memory.system_properties.is_vertical.Assign(1);
@ -183,7 +183,7 @@ void Controller_NPad::InitNewlyAddedController(std::size_t controller_idx) {
shared_memory.assignment_mode = NpadJoyAssignmentMode::Single; shared_memory.assignment_mode = NpadJoyAssignmentMode::Single;
shared_memory.applet_footer.type = AppletFooterUiType::SwitchProController; shared_memory.applet_footer.type = AppletFooterUiType::SwitchProController;
break; break;
case Core::HID::NpadType::Handheld: case Core::HID::NpadStyleIndex::Handheld:
shared_memory.style_set.handheld.Assign(1); shared_memory.style_set.handheld.Assign(1);
shared_memory.device_type.handheld_left.Assign(1); shared_memory.device_type.handheld_left.Assign(1);
shared_memory.device_type.handheld_right.Assign(1); shared_memory.device_type.handheld_right.Assign(1);
@ -193,7 +193,7 @@ void Controller_NPad::InitNewlyAddedController(std::size_t controller_idx) {
shared_memory.assignment_mode = NpadJoyAssignmentMode::Dual; shared_memory.assignment_mode = NpadJoyAssignmentMode::Dual;
shared_memory.applet_footer.type = AppletFooterUiType::HandheldJoyConLeftJoyConRight; shared_memory.applet_footer.type = AppletFooterUiType::HandheldJoyConLeftJoyConRight;
break; break;
case Core::HID::NpadType::JoyconDual: case Core::HID::NpadStyleIndex::JoyconDual:
shared_memory.style_set.joycon_dual.Assign(1); shared_memory.style_set.joycon_dual.Assign(1);
shared_memory.device_type.joycon_left.Assign(1); shared_memory.device_type.joycon_left.Assign(1);
shared_memory.device_type.joycon_right.Assign(1); shared_memory.device_type.joycon_right.Assign(1);
@ -203,7 +203,7 @@ void Controller_NPad::InitNewlyAddedController(std::size_t controller_idx) {
shared_memory.assignment_mode = NpadJoyAssignmentMode::Dual; shared_memory.assignment_mode = NpadJoyAssignmentMode::Dual;
shared_memory.applet_footer.type = AppletFooterUiType::JoyDual; shared_memory.applet_footer.type = AppletFooterUiType::JoyDual;
break; break;
case Core::HID::NpadType::JoyconLeft: case Core::HID::NpadStyleIndex::JoyconLeft:
shared_memory.style_set.joycon_left.Assign(1); shared_memory.style_set.joycon_left.Assign(1);
shared_memory.device_type.joycon_left.Assign(1); shared_memory.device_type.joycon_left.Assign(1);
shared_memory.system_properties.is_horizontal.Assign(1); shared_memory.system_properties.is_horizontal.Assign(1);
@ -211,7 +211,7 @@ void Controller_NPad::InitNewlyAddedController(std::size_t controller_idx) {
shared_memory.assignment_mode = NpadJoyAssignmentMode::Single; shared_memory.assignment_mode = NpadJoyAssignmentMode::Single;
shared_memory.applet_footer.type = AppletFooterUiType::JoyLeftHorizontal; shared_memory.applet_footer.type = AppletFooterUiType::JoyLeftHorizontal;
break; break;
case Core::HID::NpadType::JoyconRight: case Core::HID::NpadStyleIndex::JoyconRight:
shared_memory.style_set.joycon_right.Assign(1); shared_memory.style_set.joycon_right.Assign(1);
shared_memory.device_type.joycon_right.Assign(1); shared_memory.device_type.joycon_right.Assign(1);
shared_memory.system_properties.is_horizontal.Assign(1); shared_memory.system_properties.is_horizontal.Assign(1);
@ -219,14 +219,14 @@ void Controller_NPad::InitNewlyAddedController(std::size_t controller_idx) {
shared_memory.assignment_mode = NpadJoyAssignmentMode::Single; shared_memory.assignment_mode = NpadJoyAssignmentMode::Single;
shared_memory.applet_footer.type = AppletFooterUiType::JoyRightHorizontal; shared_memory.applet_footer.type = AppletFooterUiType::JoyRightHorizontal;
break; break;
case Core::HID::NpadType::GameCube: case Core::HID::NpadStyleIndex::GameCube:
shared_memory.style_set.gamecube.Assign(1); shared_memory.style_set.gamecube.Assign(1);
// The GC Controller behaves like a wired Pro Controller // The GC Controller behaves like a wired Pro Controller
shared_memory.device_type.fullkey.Assign(1); shared_memory.device_type.fullkey.Assign(1);
shared_memory.system_properties.is_vertical.Assign(1); shared_memory.system_properties.is_vertical.Assign(1);
shared_memory.system_properties.use_plus.Assign(1); shared_memory.system_properties.use_plus.Assign(1);
break; break;
case Core::HID::NpadType::Pokeball: case Core::HID::NpadStyleIndex::Pokeball:
shared_memory.style_set.palma.Assign(1); shared_memory.style_set.palma.Assign(1);
shared_memory.device_type.palma.Assign(1); shared_memory.device_type.palma.Assign(1);
shared_memory.assignment_mode = NpadJoyAssignmentMode::Single; shared_memory.assignment_mode = NpadJoyAssignmentMode::Single;
@ -307,7 +307,7 @@ void Controller_NPad::OnInit() {
const auto& device = controller.device; const auto& device = controller.device;
if (device->IsConnected()) { if (device->IsConnected()) {
const std::size_t index = Core::HID::NpadIdTypeToIndex(device->GetNpadIdType()); const std::size_t index = Core::HID::NpadIdTypeToIndex(device->GetNpadIdType());
AddNewControllerAt(device->GetNpadType(), index); AddNewControllerAt(device->GetNpadStyleIndex(), index);
} }
} }
} }
@ -347,7 +347,7 @@ void Controller_NPad::RequestPadStateUpdate(u32 npad_id) {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
const auto controller_idx = NPadIdToIndex(npad_id); const auto controller_idx = NPadIdToIndex(npad_id);
auto& controller = controller_data[controller_idx]; auto& controller = controller_data[controller_idx];
const auto controller_type = controller.device->GetNpadType(); const auto controller_type = controller.device->GetNpadStyleIndex();
if (!controller.device->IsConnected()) { if (!controller.device->IsConnected()) {
return; return;
} }
@ -359,7 +359,7 @@ void Controller_NPad::RequestPadStateUpdate(u32 npad_id) {
using btn = Core::HID::NpadButton; using btn = Core::HID::NpadButton;
pad_entry.npad_buttons.raw = btn::None; pad_entry.npad_buttons.raw = btn::None;
if (controller_type != Core::HID::NpadType::JoyconLeft) { if (controller_type != Core::HID::NpadStyleIndex::JoyconLeft) {
constexpr btn right_button_mask = btn::A | btn::B | btn::X | btn::Y | btn::StickR | btn::R | constexpr btn right_button_mask = btn::A | btn::B | btn::X | btn::Y | btn::StickR | btn::R |
btn::ZR | btn::Plus | btn::StickRLeft | btn::StickRUp | btn::ZR | btn::Plus | btn::StickRLeft | btn::StickRUp |
btn::StickRRight | btn::StickRDown; btn::StickRRight | btn::StickRDown;
@ -367,7 +367,7 @@ void Controller_NPad::RequestPadStateUpdate(u32 npad_id) {
pad_entry.r_stick = stick_state.right; pad_entry.r_stick = stick_state.right;
} }
if (controller_type != Core::HID::NpadType::JoyconRight) { if (controller_type != Core::HID::NpadStyleIndex::JoyconRight) {
constexpr btn left_button_mask = constexpr btn left_button_mask =
btn::Left | btn::Up | btn::Right | btn::Down | btn::StickL | btn::L | btn::ZL | btn::Left | btn::Up | btn::Right | btn::Down | btn::StickL | btn::L | btn::ZL |
btn::Minus | btn::StickLLeft | btn::StickLUp | btn::StickLRight | btn::StickLDown; btn::Minus | btn::StickLLeft | btn::StickLUp | btn::StickLRight | btn::StickLDown;
@ -375,17 +375,17 @@ void Controller_NPad::RequestPadStateUpdate(u32 npad_id) {
pad_entry.l_stick = stick_state.left; pad_entry.l_stick = stick_state.left;
} }
if (controller_type == Core::HID::NpadType::JoyconLeft) { if (controller_type == Core::HID::NpadStyleIndex::JoyconLeft) {
pad_entry.npad_buttons.left_sl.Assign(button_state.left_sl); pad_entry.npad_buttons.left_sl.Assign(button_state.left_sl);
pad_entry.npad_buttons.left_sr.Assign(button_state.left_sr); pad_entry.npad_buttons.left_sr.Assign(button_state.left_sr);
} }
if (controller_type == Core::HID::NpadType::JoyconRight) { if (controller_type == Core::HID::NpadStyleIndex::JoyconRight) {
pad_entry.npad_buttons.right_sl.Assign(button_state.right_sl); pad_entry.npad_buttons.right_sl.Assign(button_state.right_sl);
pad_entry.npad_buttons.right_sr.Assign(button_state.right_sr); pad_entry.npad_buttons.right_sr.Assign(button_state.right_sr);
} }
if (controller_type == Core::HID::NpadType::GameCube) { if (controller_type == Core::HID::NpadStyleIndex::GameCube) {
const auto& trigger_state = controller.device->GetTriggers(); const auto& trigger_state = controller.device->GetTriggers();
trigger_entry.l_analog = trigger_state.left; trigger_entry.l_analog = trigger_state.left;
trigger_entry.r_analog = trigger_state.right; trigger_entry.r_analog = trigger_state.right;
@ -406,9 +406,10 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
auto& controller = controller_data[i]; auto& controller = controller_data[i];
auto& npad = controller.shared_memory_entry; auto& npad = controller.shared_memory_entry;
const auto& controller_type = controller.device->GetNpadType(); const auto& controller_type = controller.device->GetNpadStyleIndex();
if (controller_type == Core::HID::NpadType::None || !controller.device->IsConnected()) { if (controller_type == Core::HID::NpadStyleIndex::None ||
!controller.device->IsConnected()) {
// Refresh shared memory // Refresh shared memory
std::memcpy(data + NPAD_OFFSET + (i * sizeof(NpadInternalState)), std::memcpy(data + NPAD_OFFSET + (i * sizeof(NpadInternalState)),
&controller.shared_memory_entry, sizeof(NpadInternalState)); &controller.shared_memory_entry, sizeof(NpadInternalState));
@ -426,10 +427,10 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
libnx_state.connection_status.raw = 0; libnx_state.connection_status.raw = 0;
libnx_state.connection_status.is_connected.Assign(1); libnx_state.connection_status.is_connected.Assign(1);
switch (controller_type) { switch (controller_type) {
case Core::HID::NpadType::None: case Core::HID::NpadStyleIndex::None:
UNREACHABLE(); UNREACHABLE();
break; break;
case Core::HID::NpadType::ProController: case Core::HID::NpadStyleIndex::ProController:
pad_state.connection_status.raw = 0; pad_state.connection_status.raw = 0;
pad_state.connection_status.is_connected.Assign(1); pad_state.connection_status.is_connected.Assign(1);
pad_state.connection_status.is_wired.Assign(1); pad_state.connection_status.is_wired.Assign(1);
@ -439,7 +440,7 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
npad.fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1; npad.fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
npad.fullkey_lifo.WriteNextEntry(pad_state); npad.fullkey_lifo.WriteNextEntry(pad_state);
break; break;
case Core::HID::NpadType::Handheld: case Core::HID::NpadStyleIndex::Handheld:
pad_state.connection_status.raw = 0; pad_state.connection_status.raw = 0;
pad_state.connection_status.is_connected.Assign(1); pad_state.connection_status.is_connected.Assign(1);
pad_state.connection_status.is_wired.Assign(1); pad_state.connection_status.is_wired.Assign(1);
@ -457,7 +458,7 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
npad.handheld_lifo.ReadCurrentEntry().state.sampling_number + 1; npad.handheld_lifo.ReadCurrentEntry().state.sampling_number + 1;
npad.handheld_lifo.WriteNextEntry(pad_state); npad.handheld_lifo.WriteNextEntry(pad_state);
break; break;
case Core::HID::NpadType::JoyconDual: case Core::HID::NpadStyleIndex::JoyconDual:
pad_state.connection_status.raw = 0; pad_state.connection_status.raw = 0;
pad_state.connection_status.is_connected.Assign(1); pad_state.connection_status.is_connected.Assign(1);
pad_state.connection_status.is_left_connected.Assign(1); pad_state.connection_status.is_left_connected.Assign(1);
@ -469,7 +470,7 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
npad.joy_dual_lifo.ReadCurrentEntry().state.sampling_number + 1; npad.joy_dual_lifo.ReadCurrentEntry().state.sampling_number + 1;
npad.joy_dual_lifo.WriteNextEntry(pad_state); npad.joy_dual_lifo.WriteNextEntry(pad_state);
break; break;
case Core::HID::NpadType::JoyconLeft: case Core::HID::NpadStyleIndex::JoyconLeft:
pad_state.connection_status.raw = 0; pad_state.connection_status.raw = 0;
pad_state.connection_status.is_connected.Assign(1); pad_state.connection_status.is_connected.Assign(1);
pad_state.connection_status.is_left_connected.Assign(1); pad_state.connection_status.is_left_connected.Assign(1);
@ -479,7 +480,7 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
npad.joy_left_lifo.ReadCurrentEntry().state.sampling_number + 1; npad.joy_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
npad.joy_left_lifo.WriteNextEntry(pad_state); npad.joy_left_lifo.WriteNextEntry(pad_state);
break; break;
case Core::HID::NpadType::JoyconRight: case Core::HID::NpadStyleIndex::JoyconRight:
pad_state.connection_status.raw = 0; pad_state.connection_status.raw = 0;
pad_state.connection_status.is_connected.Assign(1); pad_state.connection_status.is_connected.Assign(1);
pad_state.connection_status.is_right_connected.Assign(1); pad_state.connection_status.is_right_connected.Assign(1);
@ -489,7 +490,7 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
npad.joy_right_lifo.ReadCurrentEntry().state.sampling_number + 1; npad.joy_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
npad.joy_right_lifo.WriteNextEntry(pad_state); npad.joy_right_lifo.WriteNextEntry(pad_state);
break; break;
case Core::HID::NpadType::GameCube: case Core::HID::NpadStyleIndex::GameCube:
pad_state.connection_status.raw = 0; pad_state.connection_status.raw = 0;
pad_state.connection_status.is_connected.Assign(1); pad_state.connection_status.is_connected.Assign(1);
pad_state.connection_status.is_wired.Assign(1); pad_state.connection_status.is_wired.Assign(1);
@ -502,7 +503,7 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
npad.fullkey_lifo.WriteNextEntry(pad_state); npad.fullkey_lifo.WriteNextEntry(pad_state);
npad.gc_trigger_lifo.WriteNextEntry(trigger_state); npad.gc_trigger_lifo.WriteNextEntry(trigger_state);
break; break;
case Core::HID::NpadType::Pokeball: case Core::HID::NpadStyleIndex::Pokeball:
pad_state.connection_status.raw = 0; pad_state.connection_status.raw = 0;
pad_state.connection_status.is_connected.Assign(1); pad_state.connection_status.is_connected.Assign(1);
pad_state.sampling_number = pad_state.sampling_number =
@ -534,9 +535,10 @@ void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing
for (std::size_t i = 0; i < controller_data.size(); ++i) { for (std::size_t i = 0; i < controller_data.size(); ++i) {
auto& controller = controller_data[i]; auto& controller = controller_data[i];
const auto& controller_type = controller.device->GetNpadType(); const auto& controller_type = controller.device->GetNpadStyleIndex();
if (controller_type == Core::HID::NpadType::None || !controller.device->IsConnected()) { if (controller_type == Core::HID::NpadStyleIndex::None ||
!controller.device->IsConnected()) {
continue; continue;
} }
@ -557,10 +559,10 @@ void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing
} }
switch (controller_type) { switch (controller_type) {
case Core::HID::NpadType::None: case Core::HID::NpadStyleIndex::None:
UNREACHABLE(); UNREACHABLE();
break; break;
case Core::HID::NpadType::ProController: case Core::HID::NpadStyleIndex::ProController:
sixaxis_fullkey_state.attribute.raw = 0; sixaxis_fullkey_state.attribute.raw = 0;
if (sixaxis_sensors_enabled) { if (sixaxis_sensors_enabled) {
sixaxis_fullkey_state.attribute.is_connected.Assign(1); sixaxis_fullkey_state.attribute.is_connected.Assign(1);
@ -570,7 +572,7 @@ void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing
sixaxis_fullkey_state.orientation = motion_state[0].orientation; sixaxis_fullkey_state.orientation = motion_state[0].orientation;
} }
break; break;
case Core::HID::NpadType::Handheld: case Core::HID::NpadStyleIndex::Handheld:
sixaxis_handheld_state.attribute.raw = 0; sixaxis_handheld_state.attribute.raw = 0;
if (sixaxis_sensors_enabled) { if (sixaxis_sensors_enabled) {
sixaxis_handheld_state.attribute.is_connected.Assign(1); sixaxis_handheld_state.attribute.is_connected.Assign(1);
@ -580,7 +582,7 @@ void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing
sixaxis_handheld_state.orientation = motion_state[0].orientation; sixaxis_handheld_state.orientation = motion_state[0].orientation;
} }
break; break;
case Core::HID::NpadType::JoyconDual: case Core::HID::NpadStyleIndex::JoyconDual:
sixaxis_dual_left_state.attribute.raw = 0; sixaxis_dual_left_state.attribute.raw = 0;
sixaxis_dual_right_state.attribute.raw = 0; sixaxis_dual_right_state.attribute.raw = 0;
if (sixaxis_sensors_enabled) { if (sixaxis_sensors_enabled) {
@ -600,7 +602,7 @@ void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing
sixaxis_dual_right_state.orientation = motion_state[1].orientation; sixaxis_dual_right_state.orientation = motion_state[1].orientation;
} }
break; break;
case Core::HID::NpadType::JoyconLeft: case Core::HID::NpadStyleIndex::JoyconLeft:
sixaxis_left_lifo_state.attribute.raw = 0; sixaxis_left_lifo_state.attribute.raw = 0;
if (sixaxis_sensors_enabled) { if (sixaxis_sensors_enabled) {
sixaxis_left_lifo_state.attribute.is_connected.Assign(1); sixaxis_left_lifo_state.attribute.is_connected.Assign(1);
@ -610,7 +612,7 @@ void Controller_NPad::OnMotionUpdate(const Core::Timing::CoreTiming& core_timing
sixaxis_left_lifo_state.orientation = motion_state[0].orientation; sixaxis_left_lifo_state.orientation = motion_state[0].orientation;
} }
break; break;
case Core::HID::NpadType::JoyconRight: case Core::HID::NpadStyleIndex::JoyconRight:
sixaxis_right_lifo_state.attribute.raw = 0; sixaxis_right_lifo_state.attribute.raw = 0;
if (sixaxis_sensors_enabled) { if (sixaxis_sensors_enabled) {
sixaxis_right_lifo_state.attribute.is_connected.Assign(1); sixaxis_right_lifo_state.attribute.is_connected.Assign(1);
@ -779,11 +781,11 @@ void Controller_NPad::VibrateController(const DeviceHandle& vibration_device_han
} }
// Some games try to send mismatched parameters in the device handle, block these. // Some games try to send mismatched parameters in the device handle, block these.
if ((controller.device->GetNpadType() == Core::HID::NpadType::JoyconLeft && if ((controller.device->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconLeft &&
(vibration_device_handle.npad_type == Core::HID::NpadType::JoyconRight || (vibration_device_handle.npad_type == Core::HID::NpadStyleIndex::JoyconRight ||
vibration_device_handle.device_index == DeviceIndex::Right)) || vibration_device_handle.device_index == DeviceIndex::Right)) ||
(controller.device->GetNpadType() == Core::HID::NpadType::JoyconRight && (controller.device->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconRight &&
(vibration_device_handle.npad_type == Core::HID::NpadType::JoyconLeft || (vibration_device_handle.npad_type == Core::HID::NpadStyleIndex::JoyconLeft ||
vibration_device_handle.device_index == DeviceIndex::Left))) { vibration_device_handle.device_index == DeviceIndex::Left))) {
return; return;
} }
@ -876,11 +878,12 @@ void Controller_NPad::SignalStyleSetChangedEvent(u32 npad_id) const {
controller.styleset_changed_event->GetWritableEvent().Signal(); controller.styleset_changed_event->GetWritableEvent().Signal();
} }
void Controller_NPad::AddNewControllerAt(Core::HID::NpadType controller, std::size_t npad_index) { void Controller_NPad::AddNewControllerAt(Core::HID::NpadStyleIndex controller,
std::size_t npad_index) {
UpdateControllerAt(controller, npad_index, true); UpdateControllerAt(controller, npad_index, true);
} }
void Controller_NPad::UpdateControllerAt(Core::HID::NpadType type, std::size_t npad_index, void Controller_NPad::UpdateControllerAt(Core::HID::NpadStyleIndex type, std::size_t npad_index,
bool connected) { bool connected) {
auto& controller = controller_data[npad_index]; auto& controller = controller_data[npad_index];
if (!connected) { if (!connected) {
@ -888,7 +891,7 @@ void Controller_NPad::UpdateControllerAt(Core::HID::NpadType type, std::size_t n
return; return;
} }
controller.device->SetNpadType(type); controller.device->SetNpadStyleIndex(type);
InitNewlyAddedController(npad_index); InitNewlyAddedController(npad_index);
} }
@ -971,13 +974,13 @@ void Controller_NPad::MergeSingleJoyAsDualJoy(u32 npad_id_1, u32 npad_id_2) {
// If the controllers at both npad indices form a pair of left and right joycons, merge them. // If the controllers at both npad indices form a pair of left and right joycons, merge them.
// Otherwise, do nothing. // Otherwise, do nothing.
if ((controller_1->GetNpadType() == Core::HID::NpadType::JoyconLeft && if ((controller_1->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconLeft &&
controller_2->GetNpadType() == Core::HID::NpadType::JoyconRight) || controller_2->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconRight) ||
(controller_2->GetNpadType() == Core::HID::NpadType::JoyconLeft && (controller_2->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconLeft &&
controller_1->GetNpadType() == Core::HID::NpadType::JoyconRight)) { controller_1->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconRight)) {
// Disconnect the joycon at the second id and connect the dual joycon at the first index. // Disconnect the joycon at the second id and connect the dual joycon at the first index.
DisconnectNpad(npad_id_2); DisconnectNpad(npad_id_2);
AddNewControllerAt(Core::HID::NpadType::JoyconDual, npad_index_1); AddNewControllerAt(Core::HID::NpadStyleIndex::JoyconDual, npad_index_1);
} }
} }
@ -1000,8 +1003,8 @@ bool Controller_NPad::SwapNpadAssignment(u32 npad_id_1, u32 npad_id_2) {
const auto npad_index_2 = NPadIdToIndex(npad_id_2); const auto npad_index_2 = NPadIdToIndex(npad_id_2);
const auto& controller_1 = controller_data[npad_index_1].device; const auto& controller_1 = controller_data[npad_index_1].device;
const auto& controller_2 = controller_data[npad_index_2].device; const auto& controller_2 = controller_data[npad_index_2].device;
const auto type_index_1 = controller_1->GetNpadType(); const auto type_index_1 = controller_1->GetNpadStyleIndex();
const auto type_index_2 = controller_2->GetNpadType(); const auto type_index_2 = controller_2->GetNpadStyleIndex();
if (!IsControllerSupported(type_index_1) || !IsControllerSupported(type_index_2)) { if (!IsControllerSupported(type_index_1) || !IsControllerSupported(type_index_2)) {
return false; return false;
@ -1039,9 +1042,9 @@ void Controller_NPad::SetAnalogStickUseCenterClamp(bool use_center_clamp) {
void Controller_NPad::ClearAllConnectedControllers() { void Controller_NPad::ClearAllConnectedControllers() {
for (auto& controller : controller_data) { for (auto& controller : controller_data) {
if (controller.device->IsConnected() && if (controller.device->IsConnected() &&
controller.device->GetNpadType() != Core::HID::NpadType::None) { controller.device->GetNpadStyleIndex() != Core::HID::NpadStyleIndex::None) {
controller.device->SetNpadType(Core::HID::NpadType::None);
controller.device->Disconnect(); controller.device->Disconnect();
controller.device->SetNpadStyleIndex(Core::HID::NpadStyleIndex::None);
} }
} }
} }
@ -1054,7 +1057,7 @@ void Controller_NPad::DisconnectAllConnectedControllers() {
void Controller_NPad::ConnectAllDisconnectedControllers() { void Controller_NPad::ConnectAllDisconnectedControllers() {
for (auto& controller : controller_data) { for (auto& controller : controller_data) {
if (controller.device->GetNpadType() != Core::HID::NpadType::None && if (controller.device->GetNpadStyleIndex() != Core::HID::NpadStyleIndex::None &&
!controller.device->IsConnected()) { !controller.device->IsConnected()) {
controller.device->Connect(); controller.device->Connect();
} }
@ -1063,8 +1066,8 @@ void Controller_NPad::ConnectAllDisconnectedControllers() {
void Controller_NPad::ClearAllControllers() { void Controller_NPad::ClearAllControllers() {
for (auto& controller : controller_data) { for (auto& controller : controller_data) {
controller.device->SetNpadType(Core::HID::NpadType::None);
controller.device->Disconnect(); controller.device->Disconnect();
controller.device->SetNpadStyleIndex(Core::HID::NpadStyleIndex::None);
} }
} }
@ -1072,8 +1075,8 @@ u32 Controller_NPad::GetAndResetPressState() {
return press_state.exchange(0); return press_state.exchange(0);
} }
bool Controller_NPad::IsControllerSupported(Core::HID::NpadType controller) const { bool Controller_NPad::IsControllerSupported(Core::HID::NpadStyleIndex controller) const {
if (controller == Core::HID::NpadType::Handheld) { if (controller == Core::HID::NpadStyleIndex::Handheld) {
const bool support_handheld = const bool support_handheld =
std::find(supported_npad_id_types.begin(), supported_npad_id_types.end(), std::find(supported_npad_id_types.begin(), supported_npad_id_types.end(),
NPAD_HANDHELD) != supported_npad_id_types.end(); NPAD_HANDHELD) != supported_npad_id_types.end();
@ -1093,17 +1096,17 @@ bool Controller_NPad::IsControllerSupported(Core::HID::NpadType controller) cons
[](u32 npad_id) { return npad_id <= MAX_NPAD_ID; })) { [](u32 npad_id) { return npad_id <= MAX_NPAD_ID; })) {
Core::HID::NpadStyleTag style = GetSupportedStyleSet(); Core::HID::NpadStyleTag style = GetSupportedStyleSet();
switch (controller) { switch (controller) {
case Core::HID::NpadType::ProController: case Core::HID::NpadStyleIndex::ProController:
return style.fullkey; return style.fullkey;
case Core::HID::NpadType::JoyconDual: case Core::HID::NpadStyleIndex::JoyconDual:
return style.joycon_dual; return style.joycon_dual;
case Core::HID::NpadType::JoyconLeft: case Core::HID::NpadStyleIndex::JoyconLeft:
return style.joycon_left; return style.joycon_left;
case Core::HID::NpadType::JoyconRight: case Core::HID::NpadStyleIndex::JoyconRight:
return style.joycon_right; return style.joycon_right;
case Core::HID::NpadType::GameCube: case Core::HID::NpadStyleIndex::GameCube:
return style.gamecube; return style.gamecube;
case Core::HID::NpadType::Pokeball: case Core::HID::NpadStyleIndex::Pokeball:
return style.palma; return style.palma;
default: default:
return false; return false;

11
src/core/hle/service/hid/controllers/npad.h
View File

@ -96,7 +96,7 @@ public:
}; };
struct DeviceHandle { struct DeviceHandle {
Core::HID::NpadType npad_type; Core::HID::NpadStyleIndex npad_type;
u8 npad_id; u8 npad_id;
DeviceIndex device_index; DeviceIndex device_index;
INSERT_PADDING_BYTES_NOINIT(1); INSERT_PADDING_BYTES_NOINIT(1);
@ -160,9 +160,10 @@ public:
void SignalStyleSetChangedEvent(u32 npad_id) const; void SignalStyleSetChangedEvent(u32 npad_id) const;
// Adds a new controller at an index. // Adds a new controller at an index.
void AddNewControllerAt(Core::HID::NpadType controller, std::size_t npad_index); void AddNewControllerAt(Core::HID::NpadStyleIndex controller, std::size_t npad_index);
// Adds a new controller at an index with connection status. // Adds a new controller at an index with connection status.
void UpdateControllerAt(Core::HID::NpadType controller, std::size_t npad_index, bool connected); void UpdateControllerAt(Core::HID::NpadStyleIndex controller, std::size_t npad_index,
bool connected);
void DisconnectNpad(u32 npad_id); void DisconnectNpad(u32 npad_id);
void DisconnectNpadAtIndex(std::size_t index); void DisconnectNpadAtIndex(std::size_t index);
@ -496,7 +497,7 @@ private:
std::array<VibrationData, 2> vibration{}; std::array<VibrationData, 2> vibration{};
bool unintended_home_button_input_protection{}; bool unintended_home_button_input_protection{};
bool is_connected{}; bool is_connected{};
Core::HID::NpadType npad_type{Core::HID::NpadType::None}; Core::HID::NpadStyleIndex npad_type{Core::HID::NpadStyleIndex::None};
// Current pad state // Current pad state
NPadGenericState npad_pad_state{}; NPadGenericState npad_pad_state{};
@ -513,7 +514,7 @@ private:
void ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t controller_idx); void ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t controller_idx);
void InitNewlyAddedController(std::size_t controller_idx); void InitNewlyAddedController(std::size_t controller_idx);
bool IsControllerSupported(Core::HID::NpadType controller) const; bool IsControllerSupported(Core::HID::NpadStyleIndex controller) const;
void RequestPadStateUpdate(u32 npad_id); void RequestPadStateUpdate(u32 npad_id);
void WriteEmptyEntry(NpadInternalState& npad); void WriteEmptyEntry(NpadInternalState& npad);

14
src/core/hle/service/hid/hid.cpp
View File

@ -1131,18 +1131,18 @@ void Hid::GetVibrationDeviceInfo(Kernel::HLERequestContext& ctx) {
Core::HID::VibrationDeviceInfo vibration_device_info; Core::HID::VibrationDeviceInfo vibration_device_info;
switch (vibration_device_handle.npad_type) { switch (vibration_device_handle.npad_type) {
case Core::HID::NpadType::ProController: case Core::HID::NpadStyleIndex::ProController:
case Core::HID::NpadType::Handheld: case Core::HID::NpadStyleIndex::Handheld:
case Core::HID::NpadType::JoyconDual: case Core::HID::NpadStyleIndex::JoyconDual:
case Core::HID::NpadType::JoyconLeft: case Core::HID::NpadStyleIndex::JoyconLeft:
case Core::HID::NpadType::JoyconRight: case Core::HID::NpadStyleIndex::JoyconRight:
default: default:
vibration_device_info.type = Core::HID::VibrationDeviceType::LinearResonantActuator; vibration_device_info.type = Core::HID::VibrationDeviceType::LinearResonantActuator;
break; break;
case Core::HID::NpadType::GameCube: case Core::HID::NpadStyleIndex::GameCube:
vibration_device_info.type = Core::HID::VibrationDeviceType::GcErm; vibration_device_info.type = Core::HID::VibrationDeviceType::GcErm;
break; break;
case Core::HID::NpadType::Pokeball: case Core::HID::NpadStyleIndex::Pokeball:
vibration_device_info.type = Core::HID::VibrationDeviceType::Unknown; vibration_device_info.type = Core::HID::VibrationDeviceType::Unknown;
break; break;
} }

65
src/yuzu/applets/qt_controller.cpp
View File

@ -28,31 +28,31 @@
namespace { namespace {
void UpdateController(Core::HID::EmulatedController* controller, void UpdateController(Core::HID::EmulatedController* controller,
Core::HID::NpadType controller_type, bool connected) { Core::HID::NpadStyleIndex controller_type, bool connected) {
if (controller->IsConnected()) { if (controller->IsConnected()) {
controller->Disconnect(); controller->Disconnect();
} }
controller->SetNpadType(controller_type); controller->SetNpadStyleIndex(controller_type);
if (connected) { if (connected) {
controller->Connect(); controller->Connect();
} }
} }
// Returns true if the given controller type is compatible with the given parameters. // Returns true if the given controller type is compatible with the given parameters.
bool IsControllerCompatible(Core::HID::NpadType controller_type, bool IsControllerCompatible(Core::HID::NpadStyleIndex controller_type,
Core::Frontend::ControllerParameters parameters) { Core::Frontend::ControllerParameters parameters) {
switch (controller_type) { switch (controller_type) {
case Core::HID::NpadType::ProController: case Core::HID::NpadStyleIndex::ProController:
return parameters.allow_pro_controller; return parameters.allow_pro_controller;
case Core::HID::NpadType::JoyconDual: case Core::HID::NpadStyleIndex::JoyconDual:
return parameters.allow_dual_joycons; return parameters.allow_dual_joycons;
case Core::HID::NpadType::JoyconLeft: case Core::HID::NpadStyleIndex::JoyconLeft:
return parameters.allow_left_joycon; return parameters.allow_left_joycon;
case Core::HID::NpadType::JoyconRight: case Core::HID::NpadStyleIndex::JoyconRight:
return parameters.allow_right_joycon; return parameters.allow_right_joycon;
case Core::HID::NpadType::Handheld: case Core::HID::NpadStyleIndex::Handheld:
return parameters.enable_single_mode && parameters.allow_handheld; return parameters.enable_single_mode && parameters.allow_handheld;
case Core::HID::NpadType::GameCube: case Core::HID::NpadStyleIndex::GameCube:
return parameters.allow_gamecube_controller; return parameters.allow_gamecube_controller;
default: default:
return false; return false;
@ -183,7 +183,7 @@ QtControllerSelectorDialog::QtControllerSelectorDialog(
connect(emulated_controllers[i], qOverload<int>(&QComboBox::currentIndexChanged), connect(emulated_controllers[i], qOverload<int>(&QComboBox::currentIndexChanged),
[this, i](int index) { [this, i](int index) {
UpdateDockedState(GetControllerTypeFromIndex(index, i) == UpdateDockedState(GetControllerTypeFromIndex(index, i) ==
Core::HID::NpadType::Handheld); Core::HID::NpadStyleIndex::Handheld);
}); });
} }
} }
@ -243,7 +243,7 @@ void QtControllerSelectorDialog::LoadConfiguration() {
player_groupboxes[index]->setChecked(connected); player_groupboxes[index]->setChecked(connected);
connected_controller_checkboxes[index]->setChecked(connected); connected_controller_checkboxes[index]->setChecked(connected);
emulated_controllers[index]->setCurrentIndex( emulated_controllers[index]->setCurrentIndex(
GetIndexFromControllerType(controller->GetNpadType(), index)); GetIndexFromControllerType(controller->GetNpadStyleIndex(), index));
} }
UpdateDockedState(handheld->IsConnected()); UpdateDockedState(handheld->IsConnected());
@ -402,32 +402,33 @@ void QtControllerSelectorDialog::SetEmulatedControllers(std::size_t player_index
emulated_controllers[player_index]->clear(); emulated_controllers[player_index]->clear();
pairs.emplace_back(emulated_controllers[player_index]->count(), pairs.emplace_back(emulated_controllers[player_index]->count(),
Core::HID::NpadType::ProController); Core::HID::NpadStyleIndex::ProController);
emulated_controllers[player_index]->addItem(tr("Pro Controller")); emulated_controllers[player_index]->addItem(tr("Pro Controller"));
pairs.emplace_back(emulated_controllers[player_index]->count(), pairs.emplace_back(emulated_controllers[player_index]->count(),
Core::HID::NpadType::JoyconDual); Core::HID::NpadStyleIndex::JoyconDual);
emulated_controllers[player_index]->addItem(tr("Dual Joycons")); emulated_controllers[player_index]->addItem(tr("Dual Joycons"));
pairs.emplace_back(emulated_controllers[player_index]->count(), pairs.emplace_back(emulated_controllers[player_index]->count(),
Core::HID::NpadType::JoyconLeft); Core::HID::NpadStyleIndex::JoyconLeft);
emulated_controllers[player_index]->addItem(tr("Left Joycon")); emulated_controllers[player_index]->addItem(tr("Left Joycon"));
pairs.emplace_back(emulated_controllers[player_index]->count(), pairs.emplace_back(emulated_controllers[player_index]->count(),
Core::HID::NpadType::JoyconRight); Core::HID::NpadStyleIndex::JoyconRight);
emulated_controllers[player_index]->addItem(tr("Right Joycon")); emulated_controllers[player_index]->addItem(tr("Right Joycon"));
if (player_index == 0) { if (player_index == 0) {
pairs.emplace_back(emulated_controllers[player_index]->count(), pairs.emplace_back(emulated_controllers[player_index]->count(),
Core::HID::NpadType::Handheld); Core::HID::NpadStyleIndex::Handheld);
emulated_controllers[player_index]->addItem(tr("Handheld")); emulated_controllers[player_index]->addItem(tr("Handheld"));
} }
pairs.emplace_back(emulated_controllers[player_index]->count(), Core::HID::NpadType::GameCube); pairs.emplace_back(emulated_controllers[player_index]->count(),
Core::HID::NpadStyleIndex::GameCube);
emulated_controllers[player_index]->addItem(tr("GameCube Controller")); emulated_controllers[player_index]->addItem(tr("GameCube Controller"));
} }
Core::HID::NpadType QtControllerSelectorDialog::GetControllerTypeFromIndex( Core::HID::NpadStyleIndex QtControllerSelectorDialog::GetControllerTypeFromIndex(
int index, std::size_t player_index) const { int index, std::size_t player_index) const {
const auto& pairs = index_controller_type_pairs[player_index]; const auto& pairs = index_controller_type_pairs[player_index];
@ -435,13 +436,13 @@ Core::HID::NpadType QtControllerSelectorDialog::GetControllerTypeFromIndex(
[index](const auto& pair) { return pair.first == index; }); [index](const auto& pair) { return pair.first == index; });
if (it == pairs.end()) { if (it == pairs.end()) {
return Core::HID::NpadType::ProController; return Core::HID::NpadStyleIndex::ProController;
} }
return it->second; return it->second;
} }
int QtControllerSelectorDialog::GetIndexFromControllerType(Core::HID::NpadType type, int QtControllerSelectorDialog::GetIndexFromControllerType(Core::HID::NpadStyleIndex type,
std::size_t player_index) const { std::size_t player_index) const {
const auto& pairs = index_controller_type_pairs[player_index]; const auto& pairs = index_controller_type_pairs[player_index];
@ -465,16 +466,16 @@ void QtControllerSelectorDialog::UpdateControllerIcon(std::size_t player_index)
const QString stylesheet = [this, player_index] { const QString stylesheet = [this, player_index] {
switch (GetControllerTypeFromIndex(emulated_controllers[player_index]->currentIndex(), switch (GetControllerTypeFromIndex(emulated_controllers[player_index]->currentIndex(),
player_index)) { player_index)) {
case Core::HID::NpadType::ProController: case Core::HID::NpadStyleIndex::ProController:
case Core::HID::NpadType::GameCube: case Core::HID::NpadStyleIndex::GameCube:
return QStringLiteral("image: url(:/controller/applet_pro_controller%0); "); return QStringLiteral("image: url(:/controller/applet_pro_controller%0); ");
case Core::HID::NpadType::JoyconDual: case Core::HID::NpadStyleIndex::JoyconDual:
return QStringLiteral("image: url(:/controller/applet_dual_joycon%0); "); return QStringLiteral("image: url(:/controller/applet_dual_joycon%0); ");
case Core::HID::NpadType::JoyconLeft: case Core::HID::NpadStyleIndex::JoyconLeft:
return QStringLiteral("image: url(:/controller/applet_joycon_left%0); "); return QStringLiteral("image: url(:/controller/applet_joycon_left%0); ");
case Core::HID::NpadType::JoyconRight: case Core::HID::NpadStyleIndex::JoyconRight:
return QStringLiteral("image: url(:/controller/applet_joycon_right%0); "); return QStringLiteral("image: url(:/controller/applet_joycon_right%0); ");
case Core::HID::NpadType::Handheld: case Core::HID::NpadStyleIndex::Handheld:
return QStringLiteral("image: url(:/controller/applet_handheld%0); "); return QStringLiteral("image: url(:/controller/applet_handheld%0); ");
default: default:
return QString{}; return QString{};
@ -507,9 +508,9 @@ void QtControllerSelectorDialog::UpdateControllerState(std::size_t player_index)
const auto controller_type = GetControllerTypeFromIndex( const auto controller_type = GetControllerTypeFromIndex(
emulated_controllers[player_index]->currentIndex(), player_index); emulated_controllers[player_index]->currentIndex(), player_index);
const auto player_connected = player_groupboxes[player_index]->isChecked() && const auto player_connected = player_groupboxes[player_index]->isChecked() &&
controller_type != Core::HID::NpadType::Handheld; controller_type != Core::HID::NpadStyleIndex::Handheld;
if (controller->GetNpadType() == controller_type && if (controller->GetNpadStyleIndex() == controller_type &&
controller->IsConnected() == player_connected) { controller->IsConnected() == player_connected) {
// Set vibration devices in the event that the input device has changed. // Set vibration devices in the event that the input device has changed.
ConfigureVibration::SetVibrationDevices(player_index); ConfigureVibration::SetVibrationDevices(player_index);
@ -523,10 +524,10 @@ void QtControllerSelectorDialog::UpdateControllerState(std::size_t player_index)
// Handheld // Handheld
if (player_index == 0) { if (player_index == 0) {
if (controller_type == Core::HID::NpadType::Handheld) { if (controller_type == Core::HID::NpadStyleIndex::Handheld) {
auto* handheld = auto* handheld =
system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld); system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
UpdateController(handheld, Core::HID::NpadType::Handheld, UpdateController(handheld, Core::HID::NpadStyleIndex::Handheld,
player_groupboxes[player_index]->isChecked()); player_groupboxes[player_index]->isChecked());
} }
} }
@ -537,7 +538,7 @@ void QtControllerSelectorDialog::UpdateControllerState(std::size_t player_index)
void QtControllerSelectorDialog::UpdateLEDPattern(std::size_t player_index) { void QtControllerSelectorDialog::UpdateLEDPattern(std::size_t player_index) {
if (!player_groupboxes[player_index]->isChecked() || if (!player_groupboxes[player_index]->isChecked() ||
GetControllerTypeFromIndex(emulated_controllers[player_index]->currentIndex(), GetControllerTypeFromIndex(emulated_controllers[player_index]->currentIndex(),
player_index) == Core::HID::NpadType::Handheld) { player_index) == Core::HID::NpadStyleIndex::Handheld) {
led_patterns_boxes[player_index][0]->setChecked(false); led_patterns_boxes[player_index][0]->setChecked(false);
led_patterns_boxes[player_index][1]->setChecked(false); led_patterns_boxes[player_index][1]->setChecked(false);
led_patterns_boxes[player_index][2]->setChecked(false); led_patterns_boxes[player_index][2]->setChecked(false);
@ -632,7 +633,7 @@ void QtControllerSelectorDialog::DisableUnsupportedPlayers() {
for (std::size_t index = max_supported_players; index < NUM_PLAYERS; ++index) { for (std::size_t index = max_supported_players; index < NUM_PLAYERS; ++index) {
auto* controller = system.HIDCore().GetEmulatedControllerByIndex(index); auto* controller = system.HIDCore().GetEmulatedControllerByIndex(index);
// Disconnect any unsupported players here and disable or hide them if applicable. // Disconnect any unsupported players here and disable or hide them if applicable.
UpdateController(controller, controller->GetNpadType(), false); UpdateController(controller, controller->GetNpadStyleIndex(), false);
// Hide the player widgets when max_supported_controllers is less than or equal to 4. // Hide the player widgets when max_supported_controllers is less than or equal to 4.
if (max_supported_players <= 4) { if (max_supported_players <= 4) {
player_widgets[index]->hide(); player_widgets[index]->hide();

8
src/yuzu/applets/qt_controller.h
View File

@ -32,7 +32,7 @@ class System;
} }
namespace Core::HID { namespace Core::HID {
enum class NpadType : u8; enum class NpadStyleIndex : u8;
} }
class QtControllerSelectorDialog final : public QDialog { class QtControllerSelectorDialog final : public QDialog {
@ -74,10 +74,10 @@ private:
void SetEmulatedControllers(std::size_t player_index); void SetEmulatedControllers(std::size_t player_index);
// Gets the Controller Type for a given controller combobox index per player. // Gets the Controller Type for a given controller combobox index per player.
Core::HID::NpadType GetControllerTypeFromIndex(int index, std::size_t player_index) const; Core::HID::NpadStyleIndex GetControllerTypeFromIndex(int index, std::size_t player_index) const;
// Gets the controller combobox index for a given Controller Type per player. // Gets the controller combobox index for a given Controller Type per player.
int GetIndexFromControllerType(Core::HID::NpadType type, std::size_t player_index) const; int GetIndexFromControllerType(Core::HID::NpadStyleIndex type, std::size_t player_index) const;
// Updates the controller icons per player. // Updates the controller icons per player.
void UpdateControllerIcon(std::size_t player_index); void UpdateControllerIcon(std::size_t player_index);
@ -139,7 +139,7 @@ private:
std::array<QComboBox*, NUM_PLAYERS> emulated_controllers; std::array<QComboBox*, NUM_PLAYERS> emulated_controllers;
/// Pairs of emulated controller index and Controller Type enum per player. /// Pairs of emulated controller index and Controller Type enum per player.
std::array<std::vector<std::pair<int, Core::HID::NpadType>>, NUM_PLAYERS> std::array<std::vector<std::pair<int, Core::HID::NpadStyleIndex>>, NUM_PLAYERS>
index_controller_type_pairs; index_controller_type_pairs;
// Labels representing the number of connected controllers // Labels representing the number of connected controllers

14
src/yuzu/applets/qt_software_keyboard.cpp
View File

@ -801,7 +801,7 @@ void QtSoftwareKeyboardDialog::SetControllerImage() {
const auto* handheld = system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld); const auto* handheld = system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
const auto* player_1 = system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1); const auto* player_1 = system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
const auto controller_type = const auto controller_type =
handheld->IsConnected() ? handheld->GetNpadType() : player_1->GetNpadType(); handheld->IsConnected() ? handheld->GetNpadStyleIndex() : player_1->GetNpadStyleIndex();
const QString theme = [] { const QString theme = [] {
if (QIcon::themeName().contains(QStringLiteral("dark")) || if (QIcon::themeName().contains(QStringLiteral("dark")) ||
@ -813,8 +813,8 @@ void QtSoftwareKeyboardDialog::SetControllerImage() {
}(); }();
switch (controller_type) { switch (controller_type) {
case Core::HID::NpadType::ProController: case Core::HID::NpadStyleIndex::ProController:
case Core::HID::NpadType::GameCube: case Core::HID::NpadStyleIndex::GameCube:
ui->icon_controller->setStyleSheet( ui->icon_controller->setStyleSheet(
QStringLiteral("image: url(:/overlay/controller_pro%1.png);").arg(theme)); QStringLiteral("image: url(:/overlay/controller_pro%1.png);").arg(theme));
ui->icon_controller_shift->setStyleSheet( ui->icon_controller_shift->setStyleSheet(
@ -822,7 +822,7 @@ void QtSoftwareKeyboardDialog::SetControllerImage() {
ui->icon_controller_num->setStyleSheet( ui->icon_controller_num->setStyleSheet(
QStringLiteral("image: url(:/overlay/controller_pro%1.png);").arg(theme)); QStringLiteral("image: url(:/overlay/controller_pro%1.png);").arg(theme));
break; break;
case Core::HID::NpadType::JoyconDual: case Core::HID::NpadStyleIndex::JoyconDual:
ui->icon_controller->setStyleSheet( ui->icon_controller->setStyleSheet(
QStringLiteral("image: url(:/overlay/controller_dual_joycon%1.png);").arg(theme)); QStringLiteral("image: url(:/overlay/controller_dual_joycon%1.png);").arg(theme));
ui->icon_controller_shift->setStyleSheet( ui->icon_controller_shift->setStyleSheet(
@ -830,7 +830,7 @@ void QtSoftwareKeyboardDialog::SetControllerImage() {
ui->icon_controller_num->setStyleSheet( ui->icon_controller_num->setStyleSheet(
QStringLiteral("image: url(:/overlay/controller_dual_joycon%1.png);").arg(theme)); QStringLiteral("image: url(:/overlay/controller_dual_joycon%1.png);").arg(theme));
break; break;
case Core::HID::NpadType::JoyconLeft: case Core::HID::NpadStyleIndex::JoyconLeft:
ui->icon_controller->setStyleSheet( ui->icon_controller->setStyleSheet(
QStringLiteral("image: url(:/overlay/controller_single_joycon_left%1.png);") QStringLiteral("image: url(:/overlay/controller_single_joycon_left%1.png);")
.arg(theme)); .arg(theme));
@ -841,7 +841,7 @@ void QtSoftwareKeyboardDialog::SetControllerImage() {
QStringLiteral("image: url(:/overlay/controller_single_joycon_left%1.png);") QStringLiteral("image: url(:/overlay/controller_single_joycon_left%1.png);")
.arg(theme)); .arg(theme));
break; break;
case Core::HID::NpadType::JoyconRight: case Core::HID::NpadStyleIndex::JoyconRight:
ui->icon_controller->setStyleSheet( ui->icon_controller->setStyleSheet(
QStringLiteral("image: url(:/overlay/controller_single_joycon_right%1.png);") QStringLiteral("image: url(:/overlay/controller_single_joycon_right%1.png);")
.arg(theme)); .arg(theme));
@ -852,7 +852,7 @@ void QtSoftwareKeyboardDialog::SetControllerImage() {
QStringLiteral("image: url(:/overlay/controller_single_joycon_right%1.png);") QStringLiteral("image: url(:/overlay/controller_single_joycon_right%1.png);")
.arg(theme)); .arg(theme));
break; break;
case Core::HID::NpadType::Handheld: case Core::HID::NpadStyleIndex::Handheld:
ui->icon_controller->setStyleSheet( ui->icon_controller->setStyleSheet(
QStringLiteral("image: url(:/overlay/controller_handheld%1.png);").arg(theme)); QStringLiteral("image: url(:/overlay/controller_handheld%1.png);").arg(theme));
ui->icon_controller_shift->setStyleSheet( ui->icon_controller_shift->setStyleSheet(

87
src/yuzu/configuration/configure_input_player.cpp
View File

@ -455,7 +455,7 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
connect(ui->comboControllerType, qOverload<int>(&QComboBox::currentIndexChanged), connect(ui->comboControllerType, qOverload<int>(&QComboBox::currentIndexChanged),
[this](int index) { [this](int index) {
emit HandheldStateChanged(GetControllerTypeFromIndex(index) == emit HandheldStateChanged(GetControllerTypeFromIndex(index) ==
Core::HID::NpadType::Handheld); Core::HID::NpadStyleIndex::Handheld);
}); });
} }
@ -482,7 +482,7 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
UpdateControllerEnabledButtons(); UpdateControllerEnabledButtons();
UpdateControllerButtonNames(); UpdateControllerButtonNames();
UpdateMotionButtons(); UpdateMotionButtons();
const Core::HID::NpadType type = const Core::HID::NpadStyleIndex type =
GetControllerTypeFromIndex(ui->comboControllerType->currentIndex()); GetControllerTypeFromIndex(ui->comboControllerType->currentIndex());
if (player_index == 0) { if (player_index == 0) {
@ -492,10 +492,10 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld); system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
bool is_connected = emulated_controller->IsConnected(true); bool is_connected = emulated_controller->IsConnected(true);
emulated_controller_p1->SetNpadType(type); emulated_controller_p1->SetNpadStyleIndex(type);
emulated_controller_hanheld->SetNpadType(type); emulated_controller_hanheld->SetNpadStyleIndex(type);
if (is_connected) { if (is_connected) {
if (type == Core::HID::NpadType::Handheld) { if (type == Core::HID::NpadStyleIndex::Handheld) {
emulated_controller_p1->Disconnect(); emulated_controller_p1->Disconnect();
emulated_controller_hanheld->Connect(); emulated_controller_hanheld->Connect();
emulated_controller = emulated_controller_hanheld; emulated_controller = emulated_controller_hanheld;
@ -507,7 +507,7 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
} }
ui->controllerFrame->SetController(emulated_controller); ui->controllerFrame->SetController(emulated_controller);
} }
emulated_controller->SetNpadType(type); emulated_controller->SetNpadStyleIndex(type);
}); });
connect(ui->comboDevices, qOverload<int>(&QComboBox::activated), this, connect(ui->comboDevices, qOverload<int>(&QComboBox::activated), this,
@ -607,7 +607,8 @@ void ConfigureInputPlayer::LoadConfiguration() {
return; return;
} }
const int comboBoxIndex = GetIndexFromControllerType(emulated_controller->GetNpadType(true)); const int comboBoxIndex =
GetIndexFromControllerType(emulated_controller->GetNpadStyleIndex(true));
ui->comboControllerType->setCurrentIndex(comboBoxIndex); ui->comboControllerType->setCurrentIndex(comboBoxIndex);
ui->groupConnectedController->setChecked(emulated_controller->IsConnected(true)); ui->groupConnectedController->setChecked(emulated_controller->IsConnected(true));
} }
@ -810,37 +811,37 @@ void ConfigureInputPlayer::SetConnectableControllers() {
if (enable_all || npad_style_set.fullkey == 1) { if (enable_all || npad_style_set.fullkey == 1) {
index_controller_type_pairs.emplace_back(ui->comboControllerType->count(), index_controller_type_pairs.emplace_back(ui->comboControllerType->count(),
Core::HID::NpadType::ProController); Core::HID::NpadStyleIndex::ProController);
ui->comboControllerType->addItem(tr("Pro Controller")); ui->comboControllerType->addItem(tr("Pro Controller"));
} }
if (enable_all || npad_style_set.joycon_dual == 1) { if (enable_all || npad_style_set.joycon_dual == 1) {
index_controller_type_pairs.emplace_back(ui->comboControllerType->count(), index_controller_type_pairs.emplace_back(ui->comboControllerType->count(),
Core::HID::NpadType::JoyconDual); Core::HID::NpadStyleIndex::JoyconDual);
ui->comboControllerType->addItem(tr("Dual Joycons")); ui->comboControllerType->addItem(tr("Dual Joycons"));
} }
if (enable_all || npad_style_set.joycon_left == 1) { if (enable_all || npad_style_set.joycon_left == 1) {
index_controller_type_pairs.emplace_back(ui->comboControllerType->count(), index_controller_type_pairs.emplace_back(ui->comboControllerType->count(),
Core::HID::NpadType::JoyconLeft); Core::HID::NpadStyleIndex::JoyconLeft);
ui->comboControllerType->addItem(tr("Left Joycon")); ui->comboControllerType->addItem(tr("Left Joycon"));
} }
if (enable_all || npad_style_set.joycon_right == 1) { if (enable_all || npad_style_set.joycon_right == 1) {
index_controller_type_pairs.emplace_back(ui->comboControllerType->count(), index_controller_type_pairs.emplace_back(ui->comboControllerType->count(),
Core::HID::NpadType::JoyconRight); Core::HID::NpadStyleIndex::JoyconRight);
ui->comboControllerType->addItem(tr("Right Joycon")); ui->comboControllerType->addItem(tr("Right Joycon"));
} }
if (player_index == 0 && (enable_all || npad_style_set.handheld == 1)) { if (player_index == 0 && (enable_all || npad_style_set.handheld == 1)) {
index_controller_type_pairs.emplace_back(ui->comboControllerType->count(), index_controller_type_pairs.emplace_back(ui->comboControllerType->count(),
Core::HID::NpadType::Handheld); Core::HID::NpadStyleIndex::Handheld);
ui->comboControllerType->addItem(tr("Handheld")); ui->comboControllerType->addItem(tr("Handheld"));
} }
if (enable_all || npad_style_set.gamecube == 1) { if (enable_all || npad_style_set.gamecube == 1) {
index_controller_type_pairs.emplace_back(ui->comboControllerType->count(), index_controller_type_pairs.emplace_back(ui->comboControllerType->count(),
Core::HID::NpadType::GameCube); Core::HID::NpadStyleIndex::GameCube);
ui->comboControllerType->addItem(tr("GameCube Controller")); ui->comboControllerType->addItem(tr("GameCube Controller"));
} }
}; };
@ -853,19 +854,19 @@ void ConfigureInputPlayer::SetConnectableControllers() {
add_controllers(false, system.HIDCore().GetSupportedStyleTag()); add_controllers(false, system.HIDCore().GetSupportedStyleTag());
} }
Core::HID::NpadType ConfigureInputPlayer::GetControllerTypeFromIndex(int index) const { Core::HID::NpadStyleIndex ConfigureInputPlayer::GetControllerTypeFromIndex(int index) const {
const auto it = const auto it =
std::find_if(index_controller_type_pairs.begin(), index_controller_type_pairs.end(), std::find_if(index_controller_type_pairs.begin(), index_controller_type_pairs.end(),
[index](const auto& pair) { return pair.first == index; }); [index](const auto& pair) { return pair.first == index; });
if (it == index_controller_type_pairs.end()) { if (it == index_controller_type_pairs.end()) {
return Core::HID::NpadType::ProController; return Core::HID::NpadStyleIndex::ProController;
} }
return it->second; return it->second;
} }
int ConfigureInputPlayer::GetIndexFromControllerType(Core::HID::NpadType type) const { int ConfigureInputPlayer::GetIndexFromControllerType(Core::HID::NpadStyleIndex type) const {
const auto it = const auto it =
std::find_if(index_controller_type_pairs.begin(), index_controller_type_pairs.end(), std::find_if(index_controller_type_pairs.begin(), index_controller_type_pairs.end(),
[type](const auto& pair) { return pair.second == type; }); [type](const auto& pair) { return pair.second == type; });
@ -888,7 +889,7 @@ void ConfigureInputPlayer::UpdateInputDevices() {
void ConfigureInputPlayer::UpdateControllerAvailableButtons() { void ConfigureInputPlayer::UpdateControllerAvailableButtons() {
auto layout = GetControllerTypeFromIndex(ui->comboControllerType->currentIndex()); auto layout = GetControllerTypeFromIndex(ui->comboControllerType->currentIndex());
if (debug) { if (debug) {
layout = Core::HID::NpadType::ProController; layout = Core::HID::NpadStyleIndex::ProController;
} }
// List of all the widgets that will be hidden by any of the following layouts that need // List of all the widgets that will be hidden by any of the following layouts that need
@ -913,15 +914,15 @@ void ConfigureInputPlayer::UpdateControllerAvailableButtons() {
std::vector<QWidget*> layout_hidden; std::vector<QWidget*> layout_hidden;
switch (layout) { switch (layout) {
case Core::HID::NpadType::ProController: case Core::HID::NpadStyleIndex::ProController:
case Core::HID::NpadType::JoyconDual: case Core::HID::NpadStyleIndex::JoyconDual:
case Core::HID::NpadType::Handheld: case Core::HID::NpadStyleIndex::Handheld:
layout_hidden = { layout_hidden = {
ui->buttonShoulderButtonsSLSR, ui->buttonShoulderButtonsSLSR,
ui->horizontalSpacerShoulderButtonsWidget2, ui->horizontalSpacerShoulderButtonsWidget2,
}; };
break; break;
case Core::HID::NpadType::JoyconLeft: case Core::HID::NpadStyleIndex::JoyconLeft:
layout_hidden = { layout_hidden = {
ui->horizontalSpacerShoulderButtonsWidget2, ui->horizontalSpacerShoulderButtonsWidget2,
ui->buttonShoulderButtonsRight, ui->buttonShoulderButtonsRight,
@ -929,7 +930,7 @@ void ConfigureInputPlayer::UpdateControllerAvailableButtons() {
ui->bottomRight, ui->bottomRight,
}; };
break; break;
case Core::HID::NpadType::JoyconRight: case Core::HID::NpadStyleIndex::JoyconRight:
layout_hidden = { layout_hidden = {
ui->horizontalSpacerShoulderButtonsWidget, ui->horizontalSpacerShoulderButtonsWidget,
ui->buttonShoulderButtonsLeft, ui->buttonShoulderButtonsLeft,
@ -937,7 +938,7 @@ void ConfigureInputPlayer::UpdateControllerAvailableButtons() {
ui->bottomLeft, ui->bottomLeft,
}; };
break; break;
case Core::HID::NpadType::GameCube: case Core::HID::NpadStyleIndex::GameCube:
layout_hidden = { layout_hidden = {
ui->buttonShoulderButtonsSLSR, ui->buttonShoulderButtonsSLSR,
ui->horizontalSpacerShoulderButtonsWidget2, ui->horizontalSpacerShoulderButtonsWidget2,
@ -957,7 +958,7 @@ void ConfigureInputPlayer::UpdateControllerAvailableButtons() {
void ConfigureInputPlayer::UpdateControllerEnabledButtons() { void ConfigureInputPlayer::UpdateControllerEnabledButtons() {
auto layout = GetControllerTypeFromIndex(ui->comboControllerType->currentIndex()); auto layout = GetControllerTypeFromIndex(ui->comboControllerType->currentIndex());
if (debug) { if (debug) {
layout = Core::HID::NpadType::ProController; layout = Core::HID::NpadStyleIndex::ProController;
} }
// List of all the widgets that will be disabled by any of the following layouts that need // List of all the widgets that will be disabled by any of the following layouts that need
@ -974,13 +975,13 @@ void ConfigureInputPlayer::UpdateControllerEnabledButtons() {
std::vector<QWidget*> layout_disable; std::vector<QWidget*> layout_disable;
switch (layout) { switch (layout) {
case Core::HID::NpadType::ProController: case Core::HID::NpadStyleIndex::ProController:
case Core::HID::NpadType::JoyconDual: case Core::HID::NpadStyleIndex::JoyconDual:
case Core::HID::NpadType::Handheld: case Core::HID::NpadStyleIndex::Handheld:
case Core::HID::NpadType::JoyconLeft: case Core::HID::NpadStyleIndex::JoyconLeft:
case Core::HID::NpadType::JoyconRight: case Core::HID::NpadStyleIndex::JoyconRight:
break; break;
case Core::HID::NpadType::GameCube: case Core::HID::NpadStyleIndex::GameCube:
layout_disable = { layout_disable = {
ui->buttonHome, ui->buttonHome,
ui->buttonLStickPressedGroup, ui->buttonLStickPressedGroup,
@ -1007,24 +1008,24 @@ void ConfigureInputPlayer::UpdateMotionButtons() {
// Show/hide the "Motion 1/2" groupboxes depending on the currently selected controller. // Show/hide the "Motion 1/2" groupboxes depending on the currently selected controller.
switch (GetControllerTypeFromIndex(ui->comboControllerType->currentIndex())) { switch (GetControllerTypeFromIndex(ui->comboControllerType->currentIndex())) {
case Core::HID::NpadType::ProController: case Core::HID::NpadStyleIndex::ProController:
case Core::HID::NpadType::JoyconLeft: case Core::HID::NpadStyleIndex::JoyconLeft:
case Core::HID::NpadType::Handheld: case Core::HID::NpadStyleIndex::Handheld:
// Show "Motion 1" and hide "Motion 2". // Show "Motion 1" and hide "Motion 2".
ui->buttonMotionLeftGroup->show(); ui->buttonMotionLeftGroup->show();
ui->buttonMotionRightGroup->hide(); ui->buttonMotionRightGroup->hide();
break; break;
case Core::HID::NpadType::JoyconRight: case Core::HID::NpadStyleIndex::JoyconRight:
// Show "Motion 2" and hide "Motion 1". // Show "Motion 2" and hide "Motion 1".
ui->buttonMotionLeftGroup->hide(); ui->buttonMotionLeftGroup->hide();
ui->buttonMotionRightGroup->show(); ui->buttonMotionRightGroup->show();
break; break;
case Core::HID::NpadType::GameCube: case Core::HID::NpadStyleIndex::GameCube:
// Hide both "Motion 1/2". // Hide both "Motion 1/2".
ui->buttonMotionLeftGroup->hide(); ui->buttonMotionLeftGroup->hide();
ui->buttonMotionRightGroup->hide(); ui->buttonMotionRightGroup->hide();
break; break;
case Core::HID::NpadType::JoyconDual: case Core::HID::NpadStyleIndex::JoyconDual:
default: default:
// Show both "Motion 1/2". // Show both "Motion 1/2".
ui->buttonMotionLeftGroup->show(); ui->buttonMotionLeftGroup->show();
@ -1036,15 +1037,15 @@ void ConfigureInputPlayer::UpdateMotionButtons() {
void ConfigureInputPlayer::UpdateControllerButtonNames() { void ConfigureInputPlayer::UpdateControllerButtonNames() {
auto layout = GetControllerTypeFromIndex(ui->comboControllerType->currentIndex()); auto layout = GetControllerTypeFromIndex(ui->comboControllerType->currentIndex());
if (debug) { if (debug) {
layout = Core::HID::NpadType::ProController; layout = Core::HID::NpadStyleIndex::ProController;
} }
switch (layout) { switch (layout) {
case Core::HID::NpadType::ProController: case Core::HID::NpadStyleIndex::ProController:
case Core::HID::NpadType::JoyconDual: case Core::HID::NpadStyleIndex::JoyconDual:
case Core::HID::NpadType::Handheld: case Core::HID::NpadStyleIndex::Handheld:
case Core::HID::NpadType::JoyconLeft: case Core::HID::NpadStyleIndex::JoyconLeft:
case Core::HID::NpadType::JoyconRight: case Core::HID::NpadStyleIndex::JoyconRight:
ui->buttonMiscButtonsPlusGroup->setTitle(tr("Plus")); ui->buttonMiscButtonsPlusGroup->setTitle(tr("Plus"));
ui->buttonShoulderButtonsButtonZLGroup->setTitle(tr("ZL")); ui->buttonShoulderButtonsButtonZLGroup->setTitle(tr("ZL"));
ui->buttonShoulderButtonsZRGroup->setTitle(tr("ZR")); ui->buttonShoulderButtonsZRGroup->setTitle(tr("ZR"));
@ -1052,7 +1053,7 @@ void ConfigureInputPlayer::UpdateControllerButtonNames() {
ui->LStick->setTitle(tr("Left Stick")); ui->LStick->setTitle(tr("Left Stick"));
ui->RStick->setTitle(tr("Right Stick")); ui->RStick->setTitle(tr("Right Stick"));
break; break;
case Core::HID::NpadType::GameCube: case Core::HID::NpadStyleIndex::GameCube:
ui->buttonMiscButtonsPlusGroup->setTitle(tr("Start / Pause")); ui->buttonMiscButtonsPlusGroup->setTitle(tr("Start / Pause"));
ui->buttonShoulderButtonsButtonZLGroup->setTitle(tr("L")); ui->buttonShoulderButtonsButtonZLGroup->setTitle(tr("L"));
ui->buttonShoulderButtonsZRGroup->setTitle(tr("R")); ui->buttonShoulderButtonsZRGroup->setTitle(tr("R"));

8
src/yuzu/configuration/configure_input_player.h
View File

@ -51,7 +51,7 @@ class System;
namespace Core::HID { namespace Core::HID {
class EmulatedController; class EmulatedController;
enum class NpadType : u8; enum class NpadStyleIndex : u8;
} // namespace Core::HID } // namespace Core::HID
class ConfigureInputPlayer : public QWidget { class ConfigureInputPlayer : public QWidget {
@ -134,10 +134,10 @@ private:
void SetConnectableControllers(); void SetConnectableControllers();
/// Gets the Controller Type for a given controller combobox index. /// Gets the Controller Type for a given controller combobox index.
Core::HID::NpadType GetControllerTypeFromIndex(int index) const; Core::HID::NpadStyleIndex GetControllerTypeFromIndex(int index) const;
/// Gets the controller combobox index for a given Controller Type. /// Gets the controller combobox index for a given Controller Type.
int GetIndexFromControllerType(Core::HID::NpadType type) const; int GetIndexFromControllerType(Core::HID::NpadStyleIndex type) const;
/// Update the available input devices. /// Update the available input devices.
void UpdateInputDevices(); void UpdateInputDevices();
@ -182,7 +182,7 @@ private:
std::unique_ptr<QTimer> poll_timer; std::unique_ptr<QTimer> poll_timer;
/// Stores a pair of "Connected Controllers" combobox index and Controller Type enum. /// Stores a pair of "Connected Controllers" combobox index and Controller Type enum.
std::vector<std::pair<int, Core::HID::NpadType>> index_controller_type_pairs; std::vector<std::pair<int, Core::HID::NpadStyleIndex>> index_controller_type_pairs;
static constexpr int PLAYER_COUNT = 8; static constexpr int PLAYER_COUNT = 8;
std::array<QCheckBox*, PLAYER_COUNT> player_connected_checkbox; std::array<QCheckBox*, PLAYER_COUNT> player_connected_checkbox;

18
src/yuzu/configuration/configure_input_player_widget.cpp
View File

@ -147,7 +147,7 @@ void PlayerControlPreview::ControllerUpdate(Core::HID::ControllerTriggerType typ
needs_redraw = true; needs_redraw = true;
break; break;
case Core::HID::ControllerTriggerType::Type: case Core::HID::ControllerTriggerType::Type:
controller_type = controller->GetNpadType(true); controller_type = controller->GetNpadStyleIndex(true);
needs_redraw = true; needs_redraw = true;
break; break;
case Core::HID::ControllerTriggerType::Color: case Core::HID::ControllerTriggerType::Color:
@ -221,22 +221,22 @@ void PlayerControlPreview::paintEvent(QPaintEvent* event) {
const QPointF center = rect().center(); const QPointF center = rect().center();
switch (controller_type) { switch (controller_type) {
case Core::HID::NpadType::Handheld: case Core::HID::NpadStyleIndex::Handheld:
DrawHandheldController(p, center); DrawHandheldController(p, center);
break; break;
case Core::HID::NpadType::JoyconDual: case Core::HID::NpadStyleIndex::JoyconDual:
DrawDualController(p, center); DrawDualController(p, center);
break; break;
case Core::HID::NpadType::JoyconLeft: case Core::HID::NpadStyleIndex::JoyconLeft:
DrawLeftController(p, center); DrawLeftController(p, center);
break; break;
case Core::HID::NpadType::JoyconRight: case Core::HID::NpadStyleIndex::JoyconRight:
DrawRightController(p, center); DrawRightController(p, center);
break; break;
case Core::HID::NpadType::GameCube: case Core::HID::NpadStyleIndex::GameCube:
DrawGCController(p, center); DrawGCController(p, center);
break; break;
case Core::HID::NpadType::ProController: case Core::HID::NpadStyleIndex::ProController:
default: default:
DrawProController(p, center); DrawProController(p, center);
break; break;
@ -2394,7 +2394,7 @@ void PlayerControlPreview::DrawGCJoystick(QPainter& p, const QPointF center,
void PlayerControlPreview::DrawRawJoystick(QPainter& p, QPointF center_left, QPointF center_right) { void PlayerControlPreview::DrawRawJoystick(QPainter& p, QPointF center_left, QPointF center_right) {
using namespace Settings::NativeAnalog; using namespace Settings::NativeAnalog;
if (controller_type != Core::HID::NpadType::JoyconLeft) { if (controller_type != Core::HID::NpadStyleIndex::JoyconLeft) {
DrawJoystickProperties(p, center_right, stick_values[RStick].x.properties); DrawJoystickProperties(p, center_right, stick_values[RStick].x.properties);
p.setPen(colors.indicator); p.setPen(colors.indicator);
p.setBrush(colors.indicator); p.setBrush(colors.indicator);
@ -2404,7 +2404,7 @@ void PlayerControlPreview::DrawRawJoystick(QPainter& p, QPointF center_left, QPo
DrawJoystickDot(p, center_right, stick_values[RStick], false); DrawJoystickDot(p, center_right, stick_values[RStick], false);
} }
if (controller_type != Core::HID::NpadType::JoyconRight) { if (controller_type != Core::HID::NpadStyleIndex::JoyconRight) {
DrawJoystickProperties(p, center_left, stick_values[LStick].x.properties); DrawJoystickProperties(p, center_left, stick_values[LStick].x.properties);
p.setPen(colors.indicator); p.setPen(colors.indicator);
p.setBrush(colors.indicator); p.setBrush(colors.indicator);

2
src/yuzu/configuration/configure_input_player_widget.h
View File

@ -203,7 +203,7 @@ private:
bool is_controller_set{}; bool is_controller_set{};
bool is_connected{}; bool is_connected{};
bool needs_redraw{}; bool needs_redraw{};
Core::HID::NpadType controller_type; Core::HID::NpadStyleIndex controller_type;
bool mapping_active{}; bool mapping_active{};
int blink_counter{}; int blink_counter{};

2
src/yuzu/main.cpp
View File

@ -841,7 +841,7 @@ void GMainWindow::InitializeWidgets() {
tr("Handheld controller can't be used on docked mode. Pro " tr("Handheld controller can't be used on docked mode. Pro "
"controller will be selected.")); "controller will be selected."));
handheld->Disconnect(); handheld->Disconnect();
player_1->SetNpadType(Core::HID::NpadType::ProController); player_1->SetNpadStyleIndex(Core::HID::NpadStyleIndex::ProController);
player_1->Connect(); player_1->Connect();
} }