mirror/pineapple
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity

early-access version 2311

Browse source
This commit is contained in:
pineappleEA 2021-12-15 05:46:01 +01:00
parent bcb2d177fd
commit 7a8b0afcb8
30 changed files with 527 additions and 467 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -1,7 +1,7 @@
yuzu emulator early access yuzu emulator early access
============= =============
This is the source code for early-access 2305. This is the source code for early-access 2311.
## Legal Notice ## Legal Notice

18
src/common/input.h
View file

@ -227,7 +227,7 @@ struct CallbackStatus {
// Triggered once every input change // Triggered once every input change
struct InputCallback { struct InputCallback {
std::function<void(CallbackStatus)> on_change; std::function<void(const CallbackStatus&)> on_change;
}; };
/// An abstract class template for an input device (a button, an analog input, etc.). /// An abstract class template for an input device (a button, an analog input, etc.).
@ -236,14 +236,10 @@ public:
virtual ~InputDevice() = default; virtual ~InputDevice() = default;
// Request input device to update if necessary // Request input device to update if necessary
virtual void SoftUpdate() { virtual void SoftUpdate() {}
return;
}
// Force input device to update data regardless of the current state // Force input device to update data regardless of the current state
virtual void ForceUpdate() { virtual void ForceUpdate() {}
return;
}
// Sets the function to be triggered when input changes // Sets the function to be triggered when input changes
void SetCallback(InputCallback callback_) { void SetCallback(InputCallback callback_) {
@ -251,7 +247,7 @@ public:
} }
// Triggers the function set in the callback // Triggers the function set in the callback
void TriggerOnChange(CallbackStatus status) { void TriggerOnChange(const CallbackStatus& status) {
if (callback.on_change) { if (callback.on_change) {
callback.on_change(status); callback.on_change(status);
} }
@ -266,11 +262,9 @@ class OutputDevice {
public: public:
virtual ~OutputDevice() = default; virtual ~OutputDevice() = default;
virtual void SetLED([[maybe_unused]] LedStatus led_status) { virtual void SetLED([[maybe_unused]] const LedStatus& led_status) {}
return;
}
virtual VibrationError SetVibration([[maybe_unused]] VibrationStatus vibration_status) { virtual VibrationError SetVibration([[maybe_unused]] const VibrationStatus& vibration_status) {
return VibrationError::NotSupported; return VibrationError::NotSupported;
} }

21
src/core/hid/emulated_console.cpp
View file

@ -66,9 +66,10 @@ void EmulatedConsole::ReloadInput() {
motion_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(motion_params); motion_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(motion_params);
if (motion_devices) { if (motion_devices) {
Common::Input::InputCallback motion_callback{ motion_devices->SetCallback({
[this](Common::Input::CallbackStatus callback) { SetMotion(callback); }}; .on_change =
motion_devices->SetCallback(motion_callback); [this](const Common::Input::CallbackStatus& callback) { SetMotion(callback); },
});
} }
// Unique index for identifying touch device source // Unique index for identifying touch device source
@ -78,9 +79,12 @@ void EmulatedConsole::ReloadInput() {
if (!touch_device) { if (!touch_device) {
continue; continue;
} }
Common::Input::InputCallback touch_callback{ touch_device->SetCallback({
[this, index](Common::Input::CallbackStatus callback) { SetTouch(callback, index); }}; .on_change =
touch_device->SetCallback(touch_callback); [this, index](const Common::Input::CallbackStatus& callback) {
SetTouch(callback, index);
},
});
index++; index++;
} }
} }
@ -127,7 +131,7 @@ void EmulatedConsole::SetMotionParam(Common::ParamPackage param) {
ReloadInput(); ReloadInput();
} }
void EmulatedConsole::SetMotion(Common::Input::CallbackStatus callback) { void EmulatedConsole::SetMotion(const Common::Input::CallbackStatus& callback) {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
auto& raw_status = console.motion_values.raw_status; auto& raw_status = console.motion_values.raw_status;
auto& emulated = console.motion_values.emulated; auto& emulated = console.motion_values.emulated;
@ -162,8 +166,7 @@ void EmulatedConsole::SetMotion(Common::Input::CallbackStatus callback) {
TriggerOnChange(ConsoleTriggerType::Motion); TriggerOnChange(ConsoleTriggerType::Motion);
} }
void EmulatedConsole::SetTouch(Common::Input::CallbackStatus callback, void EmulatedConsole::SetTouch(const Common::Input::CallbackStatus& callback, std::size_t index) {
[[maybe_unused]] std::size_t index) {
if (index >= console.touch_values.size()) { if (index >= console.touch_values.size()) {
return; return;
} }

4
src/core/hid/emulated_console.h
View file

@ -155,14 +155,14 @@ private:
* Updates the motion status of the console * Updates the motion status of the console
* @param callback A CallbackStatus containing gyro and accelerometer data * @param callback A CallbackStatus containing gyro and accelerometer data
*/ */
void SetMotion(Common::Input::CallbackStatus callback); void SetMotion(const Common::Input::CallbackStatus& callback);
/** /**
* Updates the touch status of the console * Updates the touch status of the console
* @param callback A CallbackStatus containing the touch position * @param callback A CallbackStatus containing the touch position
* @param index Finger ID to be updated * @param index Finger ID to be updated
*/ */
void SetTouch(Common::Input::CallbackStatus callback, std::size_t index); void SetTouch(const Common::Input::CallbackStatus& callback, std::size_t index);
/** /**
* Triggers a callback that something has changed on the console status * Triggers a callback that something has changed on the console status

89
src/core/hid/emulated_controller.cpp
View file

@ -205,11 +205,12 @@ void EmulatedController::ReloadInput() {
continue; continue;
} }
const auto uuid = Common::UUID{button_params[index].Get("guid", "")}; const auto uuid = Common::UUID{button_params[index].Get("guid", "")};
Common::Input::InputCallback button_callback{ button_devices[index]->SetCallback({
[this, index, uuid](Common::Input::CallbackStatus callback) { .on_change =
[this, index, uuid](const Common::Input::CallbackStatus& callback) {
SetButton(callback, index, uuid); SetButton(callback, index, uuid);
}}; },
button_devices[index]->SetCallback(button_callback); });
button_devices[index]->ForceUpdate(); button_devices[index]->ForceUpdate();
} }
@ -218,11 +219,12 @@ void EmulatedController::ReloadInput() {
continue; continue;
} }
const auto uuid = Common::UUID{stick_params[index].Get("guid", "")}; const auto uuid = Common::UUID{stick_params[index].Get("guid", "")};
Common::Input::InputCallback stick_callback{ stick_devices[index]->SetCallback({
[this, index, uuid](Common::Input::CallbackStatus callback) { .on_change =
[this, index, uuid](const Common::Input::CallbackStatus& callback) {
SetStick(callback, index, uuid); SetStick(callback, index, uuid);
}}; },
stick_devices[index]->SetCallback(stick_callback); });
stick_devices[index]->ForceUpdate(); stick_devices[index]->ForceUpdate();
} }
@ -231,11 +233,12 @@ void EmulatedController::ReloadInput() {
continue; continue;
} }
const auto uuid = Common::UUID{trigger_params[index].Get("guid", "")}; const auto uuid = Common::UUID{trigger_params[index].Get("guid", "")};
Common::Input::InputCallback trigger_callback{ trigger_devices[index]->SetCallback({
[this, index, uuid](Common::Input::CallbackStatus callback) { .on_change =
[this, index, uuid](const Common::Input::CallbackStatus& callback) {
SetTrigger(callback, index, uuid); SetTrigger(callback, index, uuid);
}}; },
trigger_devices[index]->SetCallback(trigger_callback); });
trigger_devices[index]->ForceUpdate(); trigger_devices[index]->ForceUpdate();
} }
@ -243,9 +246,12 @@ void EmulatedController::ReloadInput() {
if (!battery_devices[index]) { if (!battery_devices[index]) {
continue; continue;
} }
Common::Input::InputCallback battery_callback{ battery_devices[index]->SetCallback({
[this, index](Common::Input::CallbackStatus callback) { SetBattery(callback, index); }}; .on_change =
battery_devices[index]->SetCallback(battery_callback); [this, index](const Common::Input::CallbackStatus& callback) {
SetBattery(callback, index);
},
});
battery_devices[index]->ForceUpdate(); battery_devices[index]->ForceUpdate();
} }
@ -253,9 +259,12 @@ void EmulatedController::ReloadInput() {
if (!motion_devices[index]) { if (!motion_devices[index]) {
continue; continue;
} }
Common::Input::InputCallback motion_callback{ motion_devices[index]->SetCallback({
[this, index](Common::Input::CallbackStatus callback) { SetMotion(callback, index); }}; .on_change =
motion_devices[index]->SetCallback(motion_callback); [this, index](const Common::Input::CallbackStatus& callback) {
SetMotion(callback, index);
},
});
motion_devices[index]->ForceUpdate(); motion_devices[index]->ForceUpdate();
} }
@ -267,22 +276,24 @@ void EmulatedController::ReloadInput() {
if (!tas_button_devices[index]) { if (!tas_button_devices[index]) {
continue; continue;
} }
Common::Input::InputCallback button_callback{ tas_button_devices[index]->SetCallback({
[this, index, tas_uuid](Common::Input::CallbackStatus callback) { .on_change =
[this, index, tas_uuid](const Common::Input::CallbackStatus& callback) {
SetButton(callback, index, tas_uuid); SetButton(callback, index, tas_uuid);
}}; },
tas_button_devices[index]->SetCallback(button_callback); });
} }
for (std::size_t index = 0; index < tas_stick_devices.size(); ++index) { for (std::size_t index = 0; index < tas_stick_devices.size(); ++index) {
if (!tas_stick_devices[index]) { if (!tas_stick_devices[index]) {
continue; continue;
} }
Common::Input::InputCallback stick_callback{ tas_stick_devices[index]->SetCallback({
[this, index, tas_uuid](Common::Input::CallbackStatus callback) { .on_change =
[this, index, tas_uuid](const Common::Input::CallbackStatus& callback) {
SetStick(callback, index, tas_uuid); SetStick(callback, index, tas_uuid);
}}; },
tas_stick_devices[index]->SetCallback(stick_callback); });
} }
} }
@ -440,7 +451,7 @@ void EmulatedController::SetButtonParam(std::size_t index, Common::ParamPackage
if (index >= button_params.size()) { if (index >= button_params.size()) {
return; return;
} }
button_params[index] = param; button_params[index] = std::move(param);
ReloadInput(); ReloadInput();
} }
@ -448,7 +459,7 @@ void EmulatedController::SetStickParam(std::size_t index, Common::ParamPackage p
if (index >= stick_params.size()) { if (index >= stick_params.size()) {
return; return;
} }
stick_params[index] = param; stick_params[index] = std::move(param);
ReloadInput(); ReloadInput();
} }
@ -456,11 +467,11 @@ void EmulatedController::SetMotionParam(std::size_t index, Common::ParamPackage
if (index >= motion_params.size()) { if (index >= motion_params.size()) {
return; return;
} }
motion_params[index] = param; motion_params[index] = std::move(param);
ReloadInput(); ReloadInput();
} }
void EmulatedController::SetButton(Common::Input::CallbackStatus callback, std::size_t index, void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback, std::size_t index,
Common::UUID uuid) { Common::UUID uuid) {
if (index >= controller.button_values.size()) { if (index >= controller.button_values.size()) {
return; return;
@ -600,7 +611,7 @@ void EmulatedController::SetButton(Common::Input::CallbackStatus callback, std::
TriggerOnChange(ControllerTriggerType::Button, true); TriggerOnChange(ControllerTriggerType::Button, true);
} }
void EmulatedController::SetStick(Common::Input::CallbackStatus callback, std::size_t index, void EmulatedController::SetStick(const Common::Input::CallbackStatus& callback, std::size_t index,
Common::UUID uuid) { Common::UUID uuid) {
if (index >= controller.stick_values.size()) { if (index >= controller.stick_values.size()) {
return; return;
@ -650,8 +661,8 @@ void EmulatedController::SetStick(Common::Input::CallbackStatus callback, std::s
TriggerOnChange(ControllerTriggerType::Stick, true); TriggerOnChange(ControllerTriggerType::Stick, true);
} }
void EmulatedController::SetTrigger(Common::Input::CallbackStatus callback, std::size_t index, void EmulatedController::SetTrigger(const Common::Input::CallbackStatus& callback,
Common::UUID uuid) { std::size_t index, Common::UUID uuid) {
if (index >= controller.trigger_values.size()) { if (index >= controller.trigger_values.size()) {
return; return;
} }
@ -659,7 +670,7 @@ void EmulatedController::SetTrigger(Common::Input::CallbackStatus callback, std:
const auto trigger_value = TransformToTrigger(callback); const auto trigger_value = TransformToTrigger(callback);
// Only read trigger values that have the same uuid or are pressed once // Only read trigger values that have the same uuid or are pressed once
if (controller.stick_values[index].uuid != uuid) { if (controller.trigger_values[index].uuid != uuid) {
if (!trigger_value.pressed.value) { if (!trigger_value.pressed.value) {
return; return;
} }
@ -675,7 +686,7 @@ void EmulatedController::SetTrigger(Common::Input::CallbackStatus callback, std:
return; return;
} }
const auto trigger = controller.trigger_values[index]; const auto& trigger = controller.trigger_values[index];
switch (index) { switch (index) {
case Settings::NativeTrigger::LTrigger: case Settings::NativeTrigger::LTrigger:
@ -692,7 +703,8 @@ void EmulatedController::SetTrigger(Common::Input::CallbackStatus callback, std:
TriggerOnChange(ControllerTriggerType::Trigger, true); TriggerOnChange(ControllerTriggerType::Trigger, true);
} }
void EmulatedController::SetMotion(Common::Input::CallbackStatus callback, std::size_t index) { void EmulatedController::SetMotion(const Common::Input::CallbackStatus& callback,
std::size_t index) {
if (index >= controller.motion_values.size()) { if (index >= controller.motion_values.size()) {
return; return;
} }
@ -730,7 +742,8 @@ void EmulatedController::SetMotion(Common::Input::CallbackStatus callback, std::
TriggerOnChange(ControllerTriggerType::Motion, true); TriggerOnChange(ControllerTriggerType::Motion, true);
} }
void EmulatedController::SetBattery(Common::Input::CallbackStatus callback, std::size_t index) { void EmulatedController::SetBattery(const Common::Input::CallbackStatus& callback,
std::size_t index) {
if (index >= controller.battery_values.size()) { if (index >= controller.battery_values.size()) {
return; return;
} }
@ -1110,7 +1123,7 @@ void EmulatedController::TriggerOnChange(ControllerTriggerType type, bool is_npa
int EmulatedController::SetCallback(ControllerUpdateCallback update_callback) { int EmulatedController::SetCallback(ControllerUpdateCallback update_callback) {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
callback_list.insert_or_assign(last_callback_key, update_callback); callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
return last_callback_key++; return last_callback_key++;
} }

13
src/core/hid/emulated_controller.h
View file

@ -328,35 +328,38 @@ private:
* @param callback A CallbackStatus containing the button status * @param callback A CallbackStatus containing the button status
* @param index Button ID of the to be updated * @param index Button ID of the to be updated
*/ */
void SetButton(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid); void SetButton(const Common::Input::CallbackStatus& callback, std::size_t index,
Common::UUID uuid);
/** /**
* Updates the analog stick status of the controller * Updates the analog stick status of the controller
* @param callback A CallbackStatus containing the analog stick status * @param callback A CallbackStatus containing the analog stick status
* @param index stick ID of the to be updated * @param index stick ID of the to be updated
*/ */
void SetStick(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid); void SetStick(const Common::Input::CallbackStatus& callback, std::size_t index,
Common::UUID uuid);
/** /**
* Updates the trigger status of the controller * Updates the trigger status of the controller
* @param callback A CallbackStatus containing the trigger status * @param callback A CallbackStatus containing the trigger status
* @param index trigger ID of the to be updated * @param index trigger ID of the to be updated
*/ */
void SetTrigger(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid); void SetTrigger(const Common::Input::CallbackStatus& callback, std::size_t index,
Common::UUID uuid);
/** /**
* Updates the motion status of the controller * Updates the motion status of the controller
* @param callback A CallbackStatus containing gyro and accelerometer data * @param callback A CallbackStatus containing gyro and accelerometer data
* @param index motion ID of the to be updated * @param index motion ID of the to be updated
*/ */
void SetMotion(Common::Input::CallbackStatus callback, std::size_t index); void SetMotion(const Common::Input::CallbackStatus& callback, std::size_t index);
/** /**
* Updates the battery status of the controller * Updates the battery status of the controller
* @param callback A CallbackStatus containing the battery status * @param callback A CallbackStatus containing the battery status
* @param index Button ID of the to be updated * @param index Button ID of the to be updated
*/ */
void SetBattery(Common::Input::CallbackStatus callback, std::size_t index); void SetBattery(const Common::Input::CallbackStatus& callback, std::size_t index);
/** /**
* Triggers a callback that something has changed on the controller status * Triggers a callback that something has changed on the controller status

58
src/core/hid/emulated_devices.cpp
View file

@ -70,50 +70,55 @@ void EmulatedDevices::ReloadInput() {
if (!mouse_button_devices[index]) { if (!mouse_button_devices[index]) {
continue; continue;
} }
Common::Input::InputCallback button_callback{ mouse_button_devices[index]->SetCallback({
[this, index](Common::Input::CallbackStatus callback) { .on_change =
[this, index](const Common::Input::CallbackStatus& callback) {
SetMouseButton(callback, index); SetMouseButton(callback, index);
}}; },
mouse_button_devices[index]->SetCallback(button_callback); });
} }
for (std::size_t index = 0; index < mouse_analog_devices.size(); ++index) { for (std::size_t index = 0; index < mouse_analog_devices.size(); ++index) {
if (!mouse_analog_devices[index]) { if (!mouse_analog_devices[index]) {
continue; continue;
} }
Common::Input::InputCallback button_callback{ mouse_analog_devices[index]->SetCallback({
[this, index](Common::Input::CallbackStatus callback) { .on_change =
[this, index](const Common::Input::CallbackStatus& callback) {
SetMouseAnalog(callback, index); SetMouseAnalog(callback, index);
}}; },
mouse_analog_devices[index]->SetCallback(button_callback); });
} }
if (mouse_stick_device) { if (mouse_stick_device) {
Common::Input::InputCallback button_callback{ mouse_stick_device->SetCallback({
[this](Common::Input::CallbackStatus callback) { SetMouseStick(callback); }}; .on_change =
mouse_stick_device->SetCallback(button_callback); [this](const Common::Input::CallbackStatus& callback) { SetMouseStick(callback); },
});
} }
for (std::size_t index = 0; index < keyboard_devices.size(); ++index) { for (std::size_t index = 0; index < keyboard_devices.size(); ++index) {
if (!keyboard_devices[index]) { if (!keyboard_devices[index]) {
continue; continue;
} }
Common::Input::InputCallback button_callback{ keyboard_devices[index]->SetCallback({
[this, index](Common::Input::CallbackStatus callback) { .on_change =
[this, index](const Common::Input::CallbackStatus& callback) {
SetKeyboardButton(callback, index); SetKeyboardButton(callback, index);
}}; },
keyboard_devices[index]->SetCallback(button_callback); });
} }
for (std::size_t index = 0; index < keyboard_modifier_devices.size(); ++index) { for (std::size_t index = 0; index < keyboard_modifier_devices.size(); ++index) {
if (!keyboard_modifier_devices[index]) { if (!keyboard_modifier_devices[index]) {
continue; continue;
} }
Common::Input::InputCallback button_callback{ keyboard_modifier_devices[index]->SetCallback({
[this, index](Common::Input::CallbackStatus callback) { .on_change =
[this, index](const Common::Input::CallbackStatus& callback) {
SetKeyboardModifier(callback, index); SetKeyboardModifier(callback, index);
}}; },
keyboard_modifier_devices[index]->SetCallback(button_callback); });
} }
} }
@ -159,7 +164,8 @@ void EmulatedDevices::RestoreConfig() {
ReloadFromSettings(); ReloadFromSettings();
} }
void EmulatedDevices::SetKeyboardButton(Common::Input::CallbackStatus callback, std::size_t index) { void EmulatedDevices::SetKeyboardButton(const Common::Input::CallbackStatus& callback,
std::size_t index) {
if (index >= device_status.keyboard_values.size()) { if (index >= device_status.keyboard_values.size()) {
return; return;
} }
@ -216,7 +222,7 @@ void EmulatedDevices::UpdateKey(std::size_t key_index, bool status) {
} }
} }
void EmulatedDevices::SetKeyboardModifier(Common::Input::CallbackStatus callback, void EmulatedDevices::SetKeyboardModifier(const Common::Input::CallbackStatus& callback,
std::size_t index) { std::size_t index) {
if (index >= device_status.keyboard_moddifier_values.size()) { if (index >= device_status.keyboard_moddifier_values.size()) {
return; return;
@ -286,7 +292,8 @@ void EmulatedDevices::SetKeyboardModifier(Common::Input::CallbackStatus callback
TriggerOnChange(DeviceTriggerType::KeyboardModdifier); TriggerOnChange(DeviceTriggerType::KeyboardModdifier);
} }
void EmulatedDevices::SetMouseButton(Common::Input::CallbackStatus callback, std::size_t index) { void EmulatedDevices::SetMouseButton(const Common::Input::CallbackStatus& callback,
std::size_t index) {
if (index >= device_status.mouse_button_values.size()) { if (index >= device_status.mouse_button_values.size()) {
return; return;
} }
@ -347,7 +354,8 @@ void EmulatedDevices::SetMouseButton(Common::Input::CallbackStatus callback, std
TriggerOnChange(DeviceTriggerType::Mouse); TriggerOnChange(DeviceTriggerType::Mouse);
} }
void EmulatedDevices::SetMouseAnalog(Common::Input::CallbackStatus callback, std::size_t index) { void EmulatedDevices::SetMouseAnalog(const Common::Input::CallbackStatus& callback,
std::size_t index) {
if (index >= device_status.mouse_analog_values.size()) { if (index >= device_status.mouse_analog_values.size()) {
return; return;
} }
@ -374,7 +382,7 @@ void EmulatedDevices::SetMouseAnalog(Common::Input::CallbackStatus callback, std
TriggerOnChange(DeviceTriggerType::Mouse); TriggerOnChange(DeviceTriggerType::Mouse);
} }
void EmulatedDevices::SetMouseStick(Common::Input::CallbackStatus callback) { void EmulatedDevices::SetMouseStick(const Common::Input::CallbackStatus& callback) {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
const auto touch_value = TransformToTouch(callback); const auto touch_value = TransformToTouch(callback);
@ -435,7 +443,7 @@ void EmulatedDevices::TriggerOnChange(DeviceTriggerType type) {
int EmulatedDevices::SetCallback(InterfaceUpdateCallback update_callback) { int EmulatedDevices::SetCallback(InterfaceUpdateCallback update_callback) {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
callback_list.insert_or_assign(last_callback_key, update_callback); callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
return last_callback_key++; return last_callback_key++;
} }

11
src/core/hid/emulated_devices.h
View file

@ -156,35 +156,34 @@ private:
* @param callback A CallbackStatus containing the key status * @param callback A CallbackStatus containing the key status
* @param index key ID to be updated * @param index key ID to be updated
*/ */
void SetKeyboardButton(Common::Input::CallbackStatus callback, std::size_t index); void SetKeyboardButton(const Common::Input::CallbackStatus& callback, std::size_t index);
/** /**
* Updates the keyboard status of the keyboard device * Updates the keyboard status of the keyboard device
* @param callback A CallbackStatus containing the modifier key status * @param callback A CallbackStatus containing the modifier key status
* @param index modifier key ID to be updated * @param index modifier key ID to be updated
*/ */
void SetKeyboardModifier(Common::Input::CallbackStatus callback, std::size_t index); void SetKeyboardModifier(const Common::Input::CallbackStatus& callback, std::size_t index);
/** /**
* Updates the mouse button status of the mouse device * Updates the mouse button status of the mouse device
* @param callback A CallbackStatus containing the button status * @param callback A CallbackStatus containing the button status
* @param index Button ID to be updated * @param index Button ID to be updated
*/ */
void SetMouseButton(Common::Input::CallbackStatus callback, std::size_t index); void SetMouseButton(const Common::Input::CallbackStatus& callback, std::size_t index);
/** /**
* Updates the mouse wheel status of the mouse device * Updates the mouse wheel status of the mouse device
* @param callback A CallbackStatus containing the wheel status * @param callback A CallbackStatus containing the wheel status
* @param index wheel ID to be updated * @param index wheel ID to be updated
*/ */
void SetMouseAnalog(Common::Input::CallbackStatus callback, std::size_t index); void SetMouseAnalog(const Common::Input::CallbackStatus& callback, std::size_t index);
/** /**
* Updates the mouse position status of the mouse device * Updates the mouse position status of the mouse device
* @param callback A CallbackStatus containing the position status * @param callback A CallbackStatus containing the position status
* @param index stick ID to be updated
*/ */
void SetMouseStick(Common::Input::CallbackStatus callback); void SetMouseStick(const Common::Input::CallbackStatus& callback);
/** /**
* Triggers a callback that something has changed on the device status * Triggers a callback that something has changed on the device status

6
src/input_common/drivers/gc_adapter.cpp
View file

@ -69,7 +69,7 @@ private:
libusb_device_handle* handle{}; libusb_device_handle* handle{};
}; };
GCAdapter::GCAdapter(const std::string& input_engine_) : InputEngine(input_engine_) { GCAdapter::GCAdapter(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
if (usb_adapter_handle) { if (usb_adapter_handle) {
return; return;
} }
@ -325,8 +325,8 @@ bool GCAdapter::GetGCEndpoint(libusb_device* device) {
return true; return true;
} }
Common::Input::VibrationError GCAdapter::SetRumble(const PadIdentifier& identifier, Common::Input::VibrationError GCAdapter::SetRumble(
const Common::Input::VibrationStatus vibration) { const PadIdentifier& identifier, const Common::Input::VibrationStatus& vibration) {
const auto mean_amplitude = (vibration.low_amplitude + vibration.high_amplitude) * 0.5f; const auto mean_amplitude = (vibration.low_amplitude + vibration.high_amplitude) * 0.5f;
const auto processed_amplitude = const auto processed_amplitude =
static_cast<u8>((mean_amplitude + std::pow(mean_amplitude, 0.3f)) * 0.5f * 0x8); static_cast<u8>((mean_amplitude + std::pow(mean_amplitude, 0.3f)) * 0.5f * 0x8);

8
src/input_common/drivers/gc_adapter.h
View file

@ -22,13 +22,13 @@ namespace InputCommon {
class LibUSBContext; class LibUSBContext;
class LibUSBDeviceHandle; class LibUSBDeviceHandle;
class GCAdapter : public InputCommon::InputEngine { class GCAdapter : public InputEngine {
public: public:
explicit GCAdapter(const std::string& input_engine_); explicit GCAdapter(std::string input_engine_);
~GCAdapter(); ~GCAdapter() override;
Common::Input::VibrationError SetRumble( Common::Input::VibrationError SetRumble(
const PadIdentifier& identifier, const Common::Input::VibrationStatus vibration) override; const PadIdentifier& identifier, const Common::Input::VibrationStatus& vibration) override;
/// Used for automapping features /// Used for automapping features
std::vector<Common::ParamPackage> GetInputDevices() const override; std::vector<Common::ParamPackage> GetInputDevices() const override;

2
src/input_common/drivers/keyboard.cpp
View file

@ -24,7 +24,7 @@ constexpr PadIdentifier keyboard_modifier_identifier = {
.pad = 1, .pad = 1,
}; };
Keyboard::Keyboard(const std::string& input_engine_) : InputEngine(input_engine_) { Keyboard::Keyboard(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
// Keyboard is broken into 3 diferent sets: // Keyboard is broken into 3 diferent sets:
// key: Unfiltered intended for controllers. // key: Unfiltered intended for controllers.
// keyboard_key: Allows only Settings::NativeKeyboard::Keys intended for keyboard emulation. // keyboard_key: Allows only Settings::NativeKeyboard::Keys intended for keyboard emulation.

4
src/input_common/drivers/keyboard.h
View file

@ -12,9 +12,9 @@ namespace InputCommon {
* A button device factory representing a keyboard. It receives keyboard events and forward them * A button device factory representing a keyboard. It receives keyboard events and forward them
* to all button devices it created. * to all button devices it created.
*/ */
class Keyboard final : public InputCommon::InputEngine { class Keyboard final : public InputEngine {
public: public:
explicit Keyboard(const std::string& input_engine_); explicit Keyboard(std::string input_engine_);
/** /**
* Sets the status of all buttons bound with the key to pressed * Sets the status of all buttons bound with the key to pressed

2
src/input_common/drivers/mouse.cpp
View file

@ -24,7 +24,7 @@ constexpr PadIdentifier identifier = {
.pad = 0, .pad = 0,
}; };
Mouse::Mouse(const std::string& input_engine_) : InputEngine(input_engine_) { Mouse::Mouse(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
PreSetController(identifier); PreSetController(identifier);
PreSetAxis(identifier, mouse_axis_x); PreSetAxis(identifier, mouse_axis_x);
PreSetAxis(identifier, mouse_axis_y); PreSetAxis(identifier, mouse_axis_y);

4
src/input_common/drivers/mouse.h
View file

@ -27,9 +27,9 @@ enum class MouseButton {
* A button device factory representing a keyboard. It receives keyboard events and forward them * A button device factory representing a keyboard. It receives keyboard events and forward them
* to all button devices it created. * to all button devices it created.
*/ */
class Mouse final : public InputCommon::InputEngine { class Mouse final : public InputEngine {
public: public:
explicit Mouse(const std::string& input_engine_); explicit Mouse(std::string input_engine_);
/** /**
* Signals that mouse has moved. * Signals that mouse has moved.

19
src/input_common/drivers/sdl_driver.cpp
View file

@ -88,7 +88,7 @@ public:
return true; return true;
} }
BasicMotion GetMotion() { const BasicMotion& GetMotion() const {
return motion; return motion;
} }
@ -367,7 +367,7 @@ void SDLDriver::HandleGameControllerEvent(const SDL_Event& event) {
if (joystick->UpdateMotion(event.csensor)) { if (joystick->UpdateMotion(event.csensor)) {
const PadIdentifier identifier = joystick->GetPadIdentifier(); const PadIdentifier identifier = joystick->GetPadIdentifier();
SetMotion(identifier, 0, joystick->GetMotion()); SetMotion(identifier, 0, joystick->GetMotion());
}; }
} }
break; break;
} }
@ -387,7 +387,7 @@ void SDLDriver::CloseJoysticks() {
joystick_map.clear(); joystick_map.clear();
} }
SDLDriver::SDLDriver(const std::string& input_engine_) : InputEngine(input_engine_) { SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
if (!Settings::values.enable_raw_input) { if (!Settings::values.enable_raw_input) {
// Disable raw input. When enabled this setting causes SDL to die when a web applet opens // Disable raw input. When enabled this setting causes SDL to die when a web applet opens
SDL_SetHint(SDL_HINT_JOYSTICK_RAWINPUT, "0"); SDL_SetHint(SDL_HINT_JOYSTICK_RAWINPUT, "0");
@ -403,10 +403,11 @@ SDLDriver::SDLDriver(const std::string& input_engine_) : InputEngine(input_engin
// Use hidapi driver for joycons. This will allow joycons to be detected as a GameController and // Use hidapi driver for joycons. This will allow joycons to be detected as a GameController and
// not a generic one // not a generic one
SDL_SetHint("SDL_JOYSTICK_HIDAPI_JOY_CONS", "1"); SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, "1");
// Turn off Pro controller home led // Disable hidapi driver for xbox. Already default on Windows, this causes conflict with native
SDL_SetHint("SDL_JOYSTICK_HIDAPI_SWITCH_HOME_LED", "0"); // driver on Linux.
SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_XBOX, "0");
// If the frontend is going to manage the event loop, then we don't start one here // If the frontend is going to manage the event loop, then we don't start one here
start_thread = SDL_WasInit(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) == 0; start_thread = SDL_WasInit(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) == 0;
@ -491,8 +492,9 @@ std::vector<Common::ParamPackage> SDLDriver::GetInputDevices() const {
} }
return devices; return devices;
} }
Common::Input::VibrationError SDLDriver::SetRumble(const PadIdentifier& identifier,
const Common::Input::VibrationStatus vibration) { Common::Input::VibrationError SDLDriver::SetRumble(
const PadIdentifier& identifier, const Common::Input::VibrationStatus& vibration) {
const auto joystick = const auto joystick =
GetSDLJoystickByGUID(identifier.guid.Format(), static_cast<int>(identifier.port)); GetSDLJoystickByGUID(identifier.guid.Format(), static_cast<int>(identifier.port));
const auto process_amplitude_exp = [](f32 amplitude, f32 factor) { const auto process_amplitude_exp = [](f32 amplitude, f32 factor) {
@ -526,6 +528,7 @@ Common::Input::VibrationError SDLDriver::SetRumble(const PadIdentifier& identifi
return Common::Input::VibrationError::None; return Common::Input::VibrationError::None;
} }
Common::ParamPackage SDLDriver::BuildAnalogParamPackageForButton(int port, std::string guid, Common::ParamPackage SDLDriver::BuildAnalogParamPackageForButton(int port, std::string guid,
s32 axis, float value) const { s32 axis, float value) const {
Common::ParamPackage params{}; Common::ParamPackage params{};

14
src/input_common/drivers/sdl_driver.h
View file

@ -19,19 +19,19 @@ using SDL_GameController = struct _SDL_GameController;
using SDL_Joystick = struct _SDL_Joystick; using SDL_Joystick = struct _SDL_Joystick;
using SDL_JoystickID = s32; using SDL_JoystickID = s32;
namespace InputCommon {
class SDLJoystick;
using ButtonBindings = using ButtonBindings =
std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerButton>, 17>; std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerButton>, 17>;
using ZButtonBindings = using ZButtonBindings =
std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerAxis>, 2>; std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerAxis>, 2>;
namespace InputCommon { class SDLDriver : public InputEngine {
class SDLJoystick;
class SDLDriver : public InputCommon::InputEngine {
public: public:
/// Initializes and registers SDL device factories /// Initializes and registers SDL device factories
SDLDriver(const std::string& input_engine_); explicit SDLDriver(std::string input_engine_);
/// Unregisters SDL device factories and shut them down. /// Unregisters SDL device factories and shut them down.
~SDLDriver() override; ~SDLDriver() override;
@ -59,7 +59,7 @@ public:
u8 GetHatButtonId(const std::string& direction_name) const override; u8 GetHatButtonId(const std::string& direction_name) const override;
Common::Input::VibrationError SetRumble( Common::Input::VibrationError SetRumble(
const PadIdentifier& identifier, const Common::Input::VibrationStatus vibration) override; const PadIdentifier& identifier, const Common::Input::VibrationStatus& vibration) override;
private: private:
void InitJoystick(int joystick_index); void InitJoystick(int joystick_index);

89
src/input_common/drivers/tas_input.cpp
View file

@ -3,7 +3,6 @@
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include <cstring> #include <cstring>
#include <regex>
#include <fmt/format.h> #include <fmt/format.h>
#include "common/fs/file.h" #include "common/fs/file.h"
@ -15,7 +14,7 @@
namespace InputCommon::TasInput { namespace InputCommon::TasInput {
enum TasAxes : u8 { enum class Tas::TasAxis : u8 {
StickX, StickX,
StickY, StickY,
SubstickX, SubstickX,
@ -47,7 +46,7 @@ constexpr std::array<std::pair<std::string_view, TasButton>, 20> text_to_tas_but
{"KEY_ZR", TasButton::TRIGGER_ZR}, {"KEY_ZR", TasButton::TRIGGER_ZR},
}; };
Tas::Tas(const std::string& input_engine_) : InputCommon::InputEngine(input_engine_) { Tas::Tas(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
for (size_t player_index = 0; player_index < PLAYER_NUMBER; player_index++) { for (size_t player_index = 0; player_index < PLAYER_NUMBER; player_index++) {
PadIdentifier identifier{ PadIdentifier identifier{
.guid = Common::UUID{}, .guid = Common::UUID{},
@ -66,7 +65,7 @@ Tas::Tas(const std::string& input_engine_) : InputCommon::InputEngine(input_engi
Tas::~Tas() { Tas::~Tas() {
Stop(); Stop();
}; }
void Tas::LoadTasFiles() { void Tas::LoadTasFiles() {
script_length = 0; script_length = 0;
@ -79,43 +78,43 @@ void Tas::LoadTasFiles() {
} }
void Tas::LoadTasFile(size_t player_index, size_t file_index) { void Tas::LoadTasFile(size_t player_index, size_t file_index) {
if (!commands[player_index].empty()) {
commands[player_index].clear(); commands[player_index].clear();
}
std::string file = Common::FS::ReadStringFromFile( std::string file = Common::FS::ReadStringFromFile(
Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) / Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) /
fmt::format("script{}-{}.txt", file_index, player_index + 1), fmt::format("script{}-{}.txt", file_index, player_index + 1),
Common::FS::FileType::BinaryFile); Common::FS::FileType::BinaryFile);
std::stringstream command_line(file); std::istringstream command_line(file);
std::string line; std::string line;
int frame_no = 0; int frame_no = 0;
while (std::getline(command_line, line, '\n')) { while (std::getline(command_line, line, '\n')) {
if (line.empty()) { if (line.empty()) {
continue; continue;
} }
std::smatch m;
std::stringstream linestream(line); std::vector<std::string> seg_list;
{
std::istringstream line_stream(line);
std::string segment; std::string segment;
std::vector<std::string> seglist; while (std::getline(line_stream, segment, ' ')) {
seg_list.push_back(std::move(segment));
while (std::getline(linestream, segment, ' ')) { }
seglist.push_back(segment);
} }
if (seglist.size() < 4) { if (seg_list.size() < 4) {
continue; continue;
} }
while (frame_no < std::stoi(seglist.at(0))) { const auto num_frames = std::stoi(seg_list[0]);
commands[player_index].push_back({}); while (frame_no < num_frames) {
commands[player_index].emplace_back();
frame_no++; frame_no++;
} }
TASCommand command = { TASCommand command = {
.buttons = ReadCommandButtons(seglist.at(1)), .buttons = ReadCommandButtons(seg_list[1]),
.l_axis = ReadCommandAxis(seglist.at(2)), .l_axis = ReadCommandAxis(seg_list[2]),
.r_axis = ReadCommandAxis(seglist.at(3)), .r_axis = ReadCommandAxis(seg_list[3]),
}; };
commands[player_index].push_back(command); commands[player_index].push_back(command);
frame_no++; frame_no++;
@ -123,16 +122,17 @@ void Tas::LoadTasFile(size_t player_index, size_t file_index) {
LOG_INFO(Input, "TAS file loaded! {} frames", frame_no); LOG_INFO(Input, "TAS file loaded! {} frames", frame_no);
} }
void Tas::WriteTasFile(std::u8string file_name) { void Tas::WriteTasFile(std::u8string_view file_name) {
std::string output_text; std::string output_text;
for (size_t frame = 0; frame < record_commands.size(); frame++) { for (size_t frame = 0; frame < record_commands.size(); frame++) {
const TASCommand& line = record_commands[frame]; const TASCommand& line = record_commands[frame];
output_text += fmt::format("{} {} {} {}\n", frame, WriteCommandButtons(line.buttons), output_text += fmt::format("{} {} {} {}\n", frame, WriteCommandButtons(line.buttons),
WriteCommandAxis(line.l_axis), WriteCommandAxis(line.r_axis)); WriteCommandAxis(line.l_axis), WriteCommandAxis(line.r_axis));
} }
const auto bytes_written = Common::FS::WriteStringToFile(
Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) / file_name, const auto tas_file_name = Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) / file_name;
Common::FS::FileType::TextFile, output_text); const auto bytes_written =
Common::FS::WriteStringToFile(tas_file_name, Common::FS::FileType::TextFile, output_text);
if (bytes_written == output_text.size()) { if (bytes_written == output_text.size()) {
LOG_INFO(Input, "TAS file written to file!"); LOG_INFO(Input, "TAS file written to file!");
} else { } else {
@ -205,10 +205,10 @@ void Tas::UpdateThread() {
const int button = static_cast<int>(i); const int button = static_cast<int>(i);
SetButton(identifier, button, button_status); SetButton(identifier, button, button_status);
} }
SetAxis(identifier, TasAxes::StickX, command.l_axis.x); SetTasAxis(identifier, TasAxis::StickX, command.l_axis.x);
SetAxis(identifier, TasAxes::StickY, command.l_axis.y); SetTasAxis(identifier, TasAxis::StickY, command.l_axis.y);
SetAxis(identifier, TasAxes::SubstickX, command.r_axis.x); SetTasAxis(identifier, TasAxis::SubstickX, command.r_axis.x);
SetAxis(identifier, TasAxes::SubstickY, command.r_axis.y); SetTasAxis(identifier, TasAxis::SubstickY, command.r_axis.y);
} }
} else { } else {
is_running = Settings::values.tas_loop.GetValue(); is_running = Settings::values.tas_loop.GetValue();
@ -224,27 +224,28 @@ void Tas::ClearInput() {
} }
TasAnalog Tas::ReadCommandAxis(const std::string& line) const { TasAnalog Tas::ReadCommandAxis(const std::string& line) const {
std::stringstream linestream(line); std::vector<std::string> seg_list;
{
std::istringstream line_stream(line);
std::string segment; std::string segment;
std::vector<std::string> seglist; while (std::getline(line_stream, segment, ';')) {
seg_list.push_back(std::move(segment));
while (std::getline(linestream, segment, ';')) { }
seglist.push_back(segment);
} }
const float x = std::stof(seglist.at(0)) / 32767.0f; const float x = std::stof(seg_list.at(0)) / 32767.0f;
const float y = std::stof(seglist.at(1)) / 32767.0f; const float y = std::stof(seg_list.at(1)) / 32767.0f;
return {x, y}; return {x, y};
} }
u64 Tas::ReadCommandButtons(const std::string& data) const { u64 Tas::ReadCommandButtons(const std::string& line) const {
std::stringstream button_text(data); std::istringstream button_text(line);
std::string line; std::string button_line;
u64 buttons = 0; u64 buttons = 0;
while (std::getline(button_text, line, ';')) { while (std::getline(button_text, button_line, ';')) {
for (auto [text, tas_button] : text_to_tas_button) { for (const auto& [text, tas_button] : text_to_tas_button) {
if (text == line) { if (text == button_line) {
buttons |= static_cast<u64>(tas_button); buttons |= static_cast<u64>(tas_button);
break; break;
} }
@ -254,8 +255,8 @@ u64 Tas::ReadCommandButtons(const std::string& data) const {
} }
std::string Tas::WriteCommandButtons(u64 buttons) const { std::string Tas::WriteCommandButtons(u64 buttons) const {
std::string returns = ""; std::string returns;
for (auto [text_button, tas_button] : text_to_tas_button) { for (const auto& [text_button, tas_button] : text_to_tas_button) {
if ((buttons & static_cast<u64>(tas_button)) != 0) { if ((buttons & static_cast<u64>(tas_button)) != 0) {
returns += fmt::format("{};", text_button); returns += fmt::format("{};", text_button);
} }
@ -267,6 +268,10 @@ std::string Tas::WriteCommandAxis(TasAnalog analog) const {
return fmt::format("{};{}", analog.x * 32767, analog.y * 32767); return fmt::format("{};{}", analog.x * 32767, analog.y * 32767);
} }
void Tas::SetTasAxis(const PadIdentifier& identifier, TasAxis axis, f32 value) {
SetAxis(identifier, static_cast<int>(axis), value);
}
void Tas::StartStop() { void Tas::StartStop() {
if (!Settings::values.tas_enable) { if (!Settings::values.tas_enable) {
return; return;

63
src/input_common/drivers/tas_input.h
View file

@ -5,11 +5,11 @@
#pragma once #pragma once
#include <array> #include <array>
#include <string>
#include <vector>
#include "common/common_types.h" #include "common/common_types.h"
#include "common/settings_input.h"
#include "input_common/input_engine.h" #include "input_common/input_engine.h"
#include "input_common/main.h"
/* /*
To play back TAS scripts on Yuzu, select the folder with scripts in the configuration menu below To play back TAS scripts on Yuzu, select the folder with scripts in the configuration menu below
@ -81,46 +81,46 @@ enum class TasState {
Stopped, Stopped,
}; };
class Tas final : public InputCommon::InputEngine { class Tas final : public InputEngine {
public: public:
explicit Tas(const std::string& input_engine_); explicit Tas(std::string input_engine_);
~Tas(); ~Tas() override;
/** /**
* Changes the input status that will be stored in each frame * Changes the input status that will be stored in each frame
* @param buttons: bitfield with the status of the buttons * @param buttons Bitfield with the status of the buttons
* @param left_axis: value of the left axis * @param left_axis Value of the left axis
* @param right_axis: value of the right axis * @param right_axis Value of the right axis
*/ */
void RecordInput(u64 buttons, TasAnalog left_axis, TasAnalog right_axis); void RecordInput(u64 buttons, TasAnalog left_axis, TasAnalog right_axis);
// Main loop that records or executes input // Main loop that records or executes input
void UpdateThread(); void UpdateThread();
// Sets the flag to start or stop the TAS command excecution and swaps controllers profiles // Sets the flag to start or stop the TAS command execution and swaps controllers profiles
void StartStop(); void StartStop();
// Stop the TAS and reverts any controller profile // Stop the TAS and reverts any controller profile
void Stop(); void Stop();
// Sets the flag to reload the file and start from the begining in the next update // Sets the flag to reload the file and start from the beginning in the next update
void Reset(); void Reset();
/** /**
* Sets the flag to enable or disable recording of inputs * Sets the flag to enable or disable recording of inputs
* @return Returns true if the current recording status is enabled * @returns true if the current recording status is enabled
*/ */
bool Record(); bool Record();
/** /**
* Saves contents of record_commands on a file * Saves contents of record_commands on a file
* @param overwrite_file: Indicates if player 1 should be overwritten * @param overwrite_file Indicates if player 1 should be overwritten
*/ */
void SaveRecording(bool overwrite_file); void SaveRecording(bool overwrite_file);
/** /**
* Returns the current status values of TAS playback/recording * Returns the current status values of TAS playback/recording
* @return Tuple of * @returns A Tuple of
* TasState indicating the current state out of Running ; * TasState indicating the current state out of Running ;
* Current playback progress ; * Current playback progress ;
* Total length of script file currently loaded or being recorded * Total length of script file currently loaded or being recorded
@ -128,6 +128,8 @@ public:
std::tuple<TasState, size_t, size_t> GetStatus() const; std::tuple<TasState, size_t, size_t> GetStatus() const;
private: private:
enum class TasAxis : u8;
struct TASCommand { struct TASCommand {
u64 buttons{}; u64 buttons{};
TasAnalog l_axis{}; TasAnalog l_axis{};
@ -137,29 +139,31 @@ private:
/// Loads TAS files from all players /// Loads TAS files from all players
void LoadTasFiles(); void LoadTasFiles();
/** Loads TAS file from the specified player /**
* @param player_index: player number to save the script * Loads TAS file from the specified player
* @param file_index: script number of the file * @param player_index Player number to save the script
* @param file_index Script number of the file
*/ */
void LoadTasFile(size_t player_index, size_t file_index); void LoadTasFile(size_t player_index, size_t file_index);
/** Writes a TAS file from the recorded commands /**
* @param file_name: name of the file to be written * Writes a TAS file from the recorded commands
* @param file_name Name of the file to be written
*/ */
void WriteTasFile(std::u8string file_name); void WriteTasFile(std::u8string_view file_name);
/** /**
* Parses a string containing the axis values. X and Y have a range from -32767 to 32767 * Parses a string containing the axis values. X and Y have a range from -32767 to 32767
* @param line: string containing axis values with the following format "x;y" * @param line String containing axis values with the following format "x;y"
* @return Returns a TAS analog object with axis values with range from -1.0 to 1.0 * @returns A TAS analog object with axis values with range from -1.0 to 1.0
*/ */
TasAnalog ReadCommandAxis(const std::string& line) const; TasAnalog ReadCommandAxis(const std::string& line) const;
/** /**
* Parses a string containing the button values. Each button is represented by it's text format * Parses a string containing the button values. Each button is represented by it's text format
* specified in text_to_tas_button array * specified in text_to_tas_button array
* @param line: string containing button name with the following format "a;b;c;d..." * @param line string containing button name with the following format "a;b;c;d..."
* @return Returns a u64 with each bit representing the status of a button * @returns A u64 with each bit representing the status of a button
*/ */
u64 ReadCommandButtons(const std::string& line) const; u64 ReadCommandButtons(const std::string& line) const;
@ -170,17 +174,20 @@ private:
/** /**
* Converts an u64 containing the button status into the text equivalent * Converts an u64 containing the button status into the text equivalent
* @param buttons: bitfield with the status of the buttons * @param buttons Bitfield with the status of the buttons
* @return Returns a string with the name of the buttons to be written to the file * @returns A string with the name of the buttons to be written to the file
*/ */
std::string WriteCommandButtons(u64 buttons) const; std::string WriteCommandButtons(u64 buttons) const;
/** /**
* Converts an TAS analog object containing the axis status into the text equivalent * Converts an TAS analog object containing the axis status into the text equivalent
* @param data: value of the axis * @param analog Value of the axis
* @return A string with the value of the axis to be written to the file * @returns A string with the value of the axis to be written to the file
*/ */
std::string WriteCommandAxis(TasAnalog data) const; std::string WriteCommandAxis(TasAnalog analog) const;
/// Sets an axis for a particular pad to the given value.
void SetTasAxis(const PadIdentifier& identifier, TasAxis axis, f32 value);
size_t script_length{0}; size_t script_length{0};
bool is_recording{false}; bool is_recording{false};

2
src/input_common/drivers/touch_screen.cpp
View file

@ -13,7 +13,7 @@ constexpr PadIdentifier identifier = {
.pad = 0, .pad = 0,
}; };
TouchScreen::TouchScreen(const std::string& input_engine_) : InputEngine(input_engine_) { TouchScreen::TouchScreen(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
PreSetController(identifier); PreSetController(identifier);
} }

4
src/input_common/drivers/touch_screen.h
View file

@ -12,9 +12,9 @@ namespace InputCommon {
* A button device factory representing a keyboard. It receives keyboard events and forward them * A button device factory representing a keyboard. It receives keyboard events and forward them
* to all button devices it created. * to all button devices it created.
*/ */
class TouchScreen final : public InputCommon::InputEngine { class TouchScreen final : public InputEngine {
public: public:
explicit TouchScreen(const std::string& input_engine_); explicit TouchScreen(std::string input_engine_);
/** /**
* Signals that mouse has moved. * Signals that mouse has moved.

2
src/input_common/drivers/udp_client.cpp
View file

@ -136,7 +136,7 @@ static void SocketLoop(Socket* socket) {
socket->Loop(); socket->Loop();
} }
UDPClient::UDPClient(const std::string& input_engine_) : InputEngine(input_engine_) { UDPClient::UDPClient(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
LOG_INFO(Input, "Udp Initialization started"); LOG_INFO(Input, "Udp Initialization started");
ReloadSockets(); ReloadSockets();
} }

6
src/input_common/drivers/udp_client.h
View file

@ -49,10 +49,10 @@ struct DeviceStatus {
* A button device factory representing a keyboard. It receives keyboard events and forward them * A button device factory representing a keyboard. It receives keyboard events and forward them
* to all button devices it created. * to all button devices it created.
*/ */
class UDPClient final : public InputCommon::InputEngine { class UDPClient final : public InputEngine {
public: public:
explicit UDPClient(const std::string& input_engine_); explicit UDPClient(std::string input_engine_);
~UDPClient(); ~UDPClient() override;
void ReloadSockets(); void ReloadSockets();

73
src/input_common/helpers/stick_from_buttons.cpp
View file

@ -19,23 +19,36 @@ public:
: up(std::move(up_)), down(std::move(down_)), left(std::move(left_)), : up(std::move(up_)), down(std::move(down_)), left(std::move(left_)),
right(std::move(right_)), modifier(std::move(modifier_)), modifier_scale(modifier_scale_), right(std::move(right_)), modifier(std::move(modifier_)), modifier_scale(modifier_scale_),
modifier_angle(modifier_angle_) { modifier_angle(modifier_angle_) {
Common::Input::InputCallback button_up_callback{ up->SetCallback({
[this](Common::Input::CallbackStatus callback_) { UpdateUpButtonStatus(callback_); }}; .on_change =
Common::Input::InputCallback button_down_callback{ [this](const Common::Input::CallbackStatus& callback_) {
[this](Common::Input::CallbackStatus callback_) { UpdateDownButtonStatus(callback_); }}; UpdateUpButtonStatus(callback_);
Common::Input::InputCallback button_left_callback{ },
[this](Common::Input::CallbackStatus callback_) { UpdateLeftButtonStatus(callback_); }}; });
Common::Input::InputCallback button_right_callback{ down->SetCallback({
[this](Common::Input::CallbackStatus callback_) { .on_change =
[this](const Common::Input::CallbackStatus& callback_) {
UpdateDownButtonStatus(callback_);
},
});
left->SetCallback({
.on_change =
[this](const Common::Input::CallbackStatus& callback_) {
UpdateLeftButtonStatus(callback_);
},
});
right->SetCallback({
.on_change =
[this](const Common::Input::CallbackStatus& callback_) {
UpdateRightButtonStatus(callback_); UpdateRightButtonStatus(callback_);
}}; },
Common::Input::InputCallback button_modifier_callback{ });
[this](Common::Input::CallbackStatus callback_) { UpdateModButtonStatus(callback_); }}; modifier->SetCallback({
up->SetCallback(button_up_callback); .on_change =
down->SetCallback(button_down_callback); [this](const Common::Input::CallbackStatus& callback_) {
left->SetCallback(button_left_callback); UpdateModButtonStatus(callback_);
right->SetCallback(button_right_callback); },
modifier->SetCallback(button_modifier_callback); });
last_x_axis_value = 0.0f; last_x_axis_value = 0.0f;
last_y_axis_value = 0.0f; last_y_axis_value = 0.0f;
} }
@ -133,27 +146,27 @@ public:
} }
} }
void UpdateUpButtonStatus(Common::Input::CallbackStatus button_callback) { void UpdateUpButtonStatus(const Common::Input::CallbackStatus& button_callback) {
up_status = button_callback.button_status.value; up_status = button_callback.button_status.value;
UpdateStatus(); UpdateStatus();
} }
void UpdateDownButtonStatus(Common::Input::CallbackStatus button_callback) { void UpdateDownButtonStatus(const Common::Input::CallbackStatus& button_callback) {
down_status = button_callback.button_status.value; down_status = button_callback.button_status.value;
UpdateStatus(); UpdateStatus();
} }
void UpdateLeftButtonStatus(Common::Input::CallbackStatus button_callback) { void UpdateLeftButtonStatus(const Common::Input::CallbackStatus& button_callback) {
left_status = button_callback.button_status.value; left_status = button_callback.button_status.value;
UpdateStatus(); UpdateStatus();
} }
void UpdateRightButtonStatus(Common::Input::CallbackStatus button_callback) { void UpdateRightButtonStatus(const Common::Input::CallbackStatus& button_callback) {
right_status = button_callback.button_status.value; right_status = button_callback.button_status.value;
UpdateStatus(); UpdateStatus();
} }
void UpdateModButtonStatus(Common::Input::CallbackStatus button_callback) { void UpdateModButtonStatus(const Common::Input::CallbackStatus& button_callback) {
modifier_status = button_callback.button_status.value; modifier_status = button_callback.button_status.value;
UpdateStatus(); UpdateStatus();
} }
@ -265,18 +278,18 @@ private:
Button left; Button left;
Button right; Button right;
Button modifier; Button modifier;
float modifier_scale; float modifier_scale{};
float modifier_angle; float modifier_angle{};
float angle{}; float angle{};
float goal_angle{}; float goal_angle{};
float amplitude{}; float amplitude{};
bool up_status; bool up_status{};
bool down_status; bool down_status{};
bool left_status; bool left_status{};
bool right_status; bool right_status{};
bool modifier_status; bool modifier_status{};
float last_x_axis_value; float last_x_axis_value{};
float last_y_axis_value; float last_y_axis_value{};
const Common::Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false}; const Common::Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
std::chrono::time_point<std::chrono::steady_clock> last_update; std::chrono::time_point<std::chrono::steady_clock> last_update;
}; };

11
src/input_common/helpers/touch_from_buttons.cpp
View file

@ -14,10 +14,13 @@ public:
using Button = std::unique_ptr<Common::Input::InputDevice>; using Button = std::unique_ptr<Common::Input::InputDevice>;
TouchFromButtonDevice(Button button_, int touch_id_, float x_, float y_) TouchFromButtonDevice(Button button_, int touch_id_, float x_, float y_)
: button(std::move(button_)), touch_id(touch_id_), x(x_), y(y_) { : button(std::move(button_)), touch_id(touch_id_), x(x_), y(y_) {
Common::Input::InputCallback button_up_callback{
[this](Common::Input::CallbackStatus callback_) { UpdateButtonStatus(callback_); }};
last_button_value = false; last_button_value = false;
button->SetCallback(button_up_callback); button->SetCallback({
.on_change =
[this](const Common::Input::CallbackStatus& callback_) {
UpdateButtonStatus(callback_);
},
});
button->ForceUpdate(); button->ForceUpdate();
} }
@ -47,7 +50,7 @@ public:
return status; return status;
} }
void UpdateButtonStatus(Common::Input::CallbackStatus button_callback) { void UpdateButtonStatus(const Common::Input::CallbackStatus& button_callback) {
const Common::Input::CallbackStatus status{ const Common::Input::CallbackStatus status{
.type = Common::Input::InputType::Touch, .type = Common::Input::InputType::Touch,
.touch_status = GetStatus(button_callback.button_status.value), .touch_status = GetStatus(button_callback.button_status.value),

86
src/input_common/input_engine.cpp
View file

@ -10,41 +10,31 @@ namespace InputCommon {
void InputEngine::PreSetController(const PadIdentifier& identifier) { void InputEngine::PreSetController(const PadIdentifier& identifier) {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
if (!controller_list.contains(identifier)) { controller_list.try_emplace(identifier);
controller_list.insert_or_assign(identifier, ControllerData{});
}
} }
void InputEngine::PreSetButton(const PadIdentifier& identifier, int button) { void InputEngine::PreSetButton(const PadIdentifier& identifier, int button) {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
ControllerData& controller = controller_list.at(identifier); ControllerData& controller = controller_list.at(identifier);
if (!controller.buttons.contains(button)) { controller.buttons.try_emplace(button, false);
controller.buttons.insert_or_assign(button, false);
}
} }
void InputEngine::PreSetHatButton(const PadIdentifier& identifier, int button) { void InputEngine::PreSetHatButton(const PadIdentifier& identifier, int button) {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
ControllerData& controller = controller_list.at(identifier); ControllerData& controller = controller_list.at(identifier);
if (!controller.hat_buttons.contains(button)) { controller.hat_buttons.try_emplace(button, u8{0});
controller.hat_buttons.insert_or_assign(button, u8{0});
}
} }
void InputEngine::PreSetAxis(const PadIdentifier& identifier, int axis) { void InputEngine::PreSetAxis(const PadIdentifier& identifier, int axis) {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
ControllerData& controller = controller_list.at(identifier); ControllerData& controller = controller_list.at(identifier);
if (!controller.axes.contains(axis)) { controller.axes.try_emplace(axis, 0.0f);
controller.axes.insert_or_assign(axis, 0.0f);
}
} }
void InputEngine::PreSetMotion(const PadIdentifier& identifier, int motion) { void InputEngine::PreSetMotion(const PadIdentifier& identifier, int motion) {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
ControllerData& controller = controller_list.at(identifier); ControllerData& controller = controller_list.at(identifier);
if (!controller.motions.contains(motion)) { controller.motions.try_emplace(motion);
controller.motions.insert_or_assign(motion, BasicMotion{});
}
} }
void InputEngine::SetButton(const PadIdentifier& identifier, int button, bool value) { void InputEngine::SetButton(const PadIdentifier& identifier, int button, bool value) {
@ -91,7 +81,7 @@ void InputEngine::SetBattery(const PadIdentifier& identifier, BatteryLevel value
TriggerOnBatteryChange(identifier, value); TriggerOnBatteryChange(identifier, value);
} }
void InputEngine::SetMotion(const PadIdentifier& identifier, int motion, BasicMotion value) { void InputEngine::SetMotion(const PadIdentifier& identifier, int motion, const BasicMotion& value) {
{ {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
ControllerData& controller = controller_list.at(identifier); ControllerData& controller = controller_list.at(identifier);
@ -104,85 +94,93 @@ void InputEngine::SetMotion(const PadIdentifier& identifier, int motion, BasicMo
bool InputEngine::GetButton(const PadIdentifier& identifier, int button) const { bool InputEngine::GetButton(const PadIdentifier& identifier, int button) const {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
if (!controller_list.contains(identifier)) { const auto controller_iter = controller_list.find(identifier);
if (controller_iter == controller_list.cend()) {
LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(), LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
identifier.pad, identifier.port); identifier.pad, identifier.port);
return false; return false;
} }
ControllerData controller = controller_list.at(identifier); const ControllerData& controller = controller_iter->second;
if (!controller.buttons.contains(button)) { const auto button_iter = controller.buttons.find(button);
if (button_iter == controller.buttons.cend()) {
LOG_ERROR(Input, "Invalid button {}", button); LOG_ERROR(Input, "Invalid button {}", button);
return false; return false;
} }
return controller.buttons.at(button); return button_iter->second;
} }
bool InputEngine::GetHatButton(const PadIdentifier& identifier, int button, u8 direction) const { bool InputEngine::GetHatButton(const PadIdentifier& identifier, int button, u8 direction) const {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
if (!controller_list.contains(identifier)) { const auto controller_iter = controller_list.find(identifier);
if (controller_iter == controller_list.cend()) {
LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(), LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
identifier.pad, identifier.port); identifier.pad, identifier.port);
return false; return false;
} }
ControllerData controller = controller_list.at(identifier); const ControllerData& controller = controller_iter->second;
if (!controller.hat_buttons.contains(button)) { const auto hat_iter = controller.hat_buttons.find(button);
if (hat_iter == controller.hat_buttons.cend()) {
LOG_ERROR(Input, "Invalid hat button {}", button); LOG_ERROR(Input, "Invalid hat button {}", button);
return false; return false;
} }
return (controller.hat_buttons.at(button) & direction) != 0; return (hat_iter->second & direction) != 0;
} }
f32 InputEngine::GetAxis(const PadIdentifier& identifier, int axis) const { f32 InputEngine::GetAxis(const PadIdentifier& identifier, int axis) const {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
if (!controller_list.contains(identifier)) { const auto controller_iter = controller_list.find(identifier);
if (controller_iter == controller_list.cend()) {
LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(), LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
identifier.pad, identifier.port); identifier.pad, identifier.port);
return 0.0f; return 0.0f;
} }
ControllerData controller = controller_list.at(identifier); const ControllerData& controller = controller_iter->second;
if (!controller.axes.contains(axis)) { const auto axis_iter = controller.axes.find(axis);
if (axis_iter == controller.axes.cend()) {
LOG_ERROR(Input, "Invalid axis {}", axis); LOG_ERROR(Input, "Invalid axis {}", axis);
return 0.0f; return 0.0f;
} }
return controller.axes.at(axis); return axis_iter->second;
} }
BatteryLevel InputEngine::GetBattery(const PadIdentifier& identifier) const { BatteryLevel InputEngine::GetBattery(const PadIdentifier& identifier) const {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
if (!controller_list.contains(identifier)) { const auto controller_iter = controller_list.find(identifier);
if (controller_iter == controller_list.cend()) {
LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(), LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
identifier.pad, identifier.port); identifier.pad, identifier.port);
return BatteryLevel::Charging; return BatteryLevel::Charging;
} }
ControllerData controller = controller_list.at(identifier); const ControllerData& controller = controller_iter->second;
return controller.battery; return controller.battery;
} }
BasicMotion InputEngine::GetMotion(const PadIdentifier& identifier, int motion) const { BasicMotion InputEngine::GetMotion(const PadIdentifier& identifier, int motion) const {
std::lock_guard lock{mutex}; std::lock_guard lock{mutex};
if (!controller_list.contains(identifier)) { const auto controller_iter = controller_list.find(identifier);
if (controller_iter == controller_list.cend()) {
LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(), LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
identifier.pad, identifier.port); identifier.pad, identifier.port);
return {}; return {};
} }
ControllerData controller = controller_list.at(identifier); const ControllerData& controller = controller_iter->second;
return controller.motions.at(motion); return controller.motions.at(motion);
} }
void InputEngine::ResetButtonState() { void InputEngine::ResetButtonState() {
for (std::pair<PadIdentifier, ControllerData> controller : controller_list) { for (const auto& controller : controller_list) {
for (std::pair<int, bool> button : controller.second.buttons) { for (const auto& button : controller.second.buttons) {
SetButton(controller.first, button.first, false); SetButton(controller.first, button.first, false);
} }
for (std::pair<int, bool> button : controller.second.hat_buttons) { for (const auto& button : controller.second.hat_buttons) {
SetHatButton(controller.first, button.first, false); SetHatButton(controller.first, button.first, false);
} }
} }
} }
void InputEngine::ResetAnalogState() { void InputEngine::ResetAnalogState() {
for (std::pair<PadIdentifier, ControllerData> controller : controller_list) { for (const auto& controller : controller_list) {
for (std::pair<int, float> axis : controller.second.axes) { for (const auto& axis : controller.second.axes) {
SetAxis(controller.first, axis.first, 0.0); SetAxis(controller.first, axis.first, 0.0);
} }
} }
@ -190,7 +188,7 @@ void InputEngine::ResetAnalogState() {
void InputEngine::TriggerOnButtonChange(const PadIdentifier& identifier, int button, bool value) { void InputEngine::TriggerOnButtonChange(const PadIdentifier& identifier, int button, bool value) {
std::lock_guard lock{mutex_callback}; std::lock_guard lock{mutex_callback};
for (const std::pair<int, InputIdentifier> poller_pair : callback_list) { for (const auto& poller_pair : callback_list) {
const InputIdentifier& poller = poller_pair.second; const InputIdentifier& poller = poller_pair.second;
if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Button, button)) { if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Button, button)) {
continue; continue;
@ -218,7 +216,7 @@ void InputEngine::TriggerOnButtonChange(const PadIdentifier& identifier, int but
void InputEngine::TriggerOnHatButtonChange(const PadIdentifier& identifier, int button, u8 value) { void InputEngine::TriggerOnHatButtonChange(const PadIdentifier& identifier, int button, u8 value) {
std::lock_guard lock{mutex_callback}; std::lock_guard lock{mutex_callback};
for (const std::pair<int, InputIdentifier> poller_pair : callback_list) { for (const auto& poller_pair : callback_list) {
const InputIdentifier& poller = poller_pair.second; const InputIdentifier& poller = poller_pair.second;
if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::HatButton, button)) { if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::HatButton, button)) {
continue; continue;
@ -247,7 +245,7 @@ void InputEngine::TriggerOnHatButtonChange(const PadIdentifier& identifier, int
void InputEngine::TriggerOnAxisChange(const PadIdentifier& identifier, int axis, f32 value) { void InputEngine::TriggerOnAxisChange(const PadIdentifier& identifier, int axis, f32 value) {
std::lock_guard lock{mutex_callback}; std::lock_guard lock{mutex_callback};
for (const std::pair<int, InputIdentifier> poller_pair : callback_list) { for (const auto& poller_pair : callback_list) {
const InputIdentifier& poller = poller_pair.second; const InputIdentifier& poller = poller_pair.second;
if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Analog, axis)) { if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Analog, axis)) {
continue; continue;
@ -274,7 +272,7 @@ void InputEngine::TriggerOnAxisChange(const PadIdentifier& identifier, int axis,
void InputEngine::TriggerOnBatteryChange(const PadIdentifier& identifier, void InputEngine::TriggerOnBatteryChange(const PadIdentifier& identifier,
[[maybe_unused]] BatteryLevel value) { [[maybe_unused]] BatteryLevel value) {
std::lock_guard lock{mutex_callback}; std::lock_guard lock{mutex_callback};
for (const std::pair<int, InputIdentifier> poller_pair : callback_list) { for (const auto& poller_pair : callback_list) {
const InputIdentifier& poller = poller_pair.second; const InputIdentifier& poller = poller_pair.second;
if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Battery, 0)) { if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Battery, 0)) {
continue; continue;
@ -286,9 +284,9 @@ void InputEngine::TriggerOnBatteryChange(const PadIdentifier& identifier,
} }
void InputEngine::TriggerOnMotionChange(const PadIdentifier& identifier, int motion, void InputEngine::TriggerOnMotionChange(const PadIdentifier& identifier, int motion,
BasicMotion value) { const BasicMotion& value) {
std::lock_guard lock{mutex_callback}; std::lock_guard lock{mutex_callback};
for (const std::pair<int, InputIdentifier> poller_pair : callback_list) { for (const auto& poller_pair : callback_list) {
const InputIdentifier& poller = poller_pair.second; const InputIdentifier& poller = poller_pair.second;
if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Motion, motion)) { if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Motion, motion)) {
continue; continue;
@ -342,7 +340,7 @@ const std::string& InputEngine::GetEngineName() const {
int InputEngine::SetCallback(InputIdentifier input_identifier) { int InputEngine::SetCallback(InputIdentifier input_identifier) {
std::lock_guard lock{mutex_callback}; std::lock_guard lock{mutex_callback};
callback_list.insert_or_assign(last_callback_key, input_identifier); callback_list.insert_or_assign(last_callback_key, std::move(input_identifier));
return last_callback_key++; return last_callback_key++;
} }

53
src/input_common/input_engine.h
View file

@ -23,15 +23,15 @@ struct PadIdentifier {
friend constexpr bool operator==(const PadIdentifier&, const PadIdentifier&) = default; friend constexpr bool operator==(const PadIdentifier&, const PadIdentifier&) = default;
}; };
// Basic motion data containing data from the sensors and a timestamp in microsecons // Basic motion data containing data from the sensors and a timestamp in microseconds
struct BasicMotion { struct BasicMotion {
float gyro_x; float gyro_x{};
float gyro_y; float gyro_y{};
float gyro_z; float gyro_z{};
float accel_x; float accel_x{};
float accel_y; float accel_y{};
float accel_z; float accel_z{};
u64 delta_timestamp; u64 delta_timestamp{};
}; };
// Stages of a battery charge // Stages of a battery charge
@ -102,9 +102,7 @@ struct InputIdentifier {
class InputEngine { class InputEngine {
public: public:
explicit InputEngine(const std::string& input_engine_) : input_engine(input_engine_) { explicit InputEngine(std::string input_engine_) : input_engine{std::move(input_engine_)} {}
callback_list.clear();
}
virtual ~InputEngine() = default; virtual ~InputEngine() = default;
@ -116,14 +114,12 @@ public:
// Sets a led pattern for a controller // Sets a led pattern for a controller
virtual void SetLeds([[maybe_unused]] const PadIdentifier& identifier, virtual void SetLeds([[maybe_unused]] const PadIdentifier& identifier,
[[maybe_unused]] const Common::Input::LedStatus led_status) { [[maybe_unused]] const Common::Input::LedStatus& led_status) {}
return;
}
// Sets rumble to a controller // Sets rumble to a controller
virtual Common::Input::VibrationError SetRumble( virtual Common::Input::VibrationError SetRumble(
[[maybe_unused]] const PadIdentifier& identifier, [[maybe_unused]] const PadIdentifier& identifier,
[[maybe_unused]] const Common::Input::VibrationStatus vibration) { [[maybe_unused]] const Common::Input::VibrationStatus& vibration) {
return Common::Input::VibrationError::NotSupported; return Common::Input::VibrationError::NotSupported;
} }
@ -140,36 +136,36 @@ public:
/// Used for automapping features /// Used for automapping features
virtual std::vector<Common::ParamPackage> GetInputDevices() const { virtual std::vector<Common::ParamPackage> GetInputDevices() const {
return {}; return {};
}; }
/// Retrieves the button mappings for the given device /// Retrieves the button mappings for the given device
virtual InputCommon::ButtonMapping GetButtonMappingForDevice( virtual ButtonMapping GetButtonMappingForDevice(
[[maybe_unused]] const Common::ParamPackage& params) { [[maybe_unused]] const Common::ParamPackage& params) {
return {}; return {};
}; }
/// Retrieves the analog mappings for the given device /// Retrieves the analog mappings for the given device
virtual InputCommon::AnalogMapping GetAnalogMappingForDevice( virtual AnalogMapping GetAnalogMappingForDevice(
[[maybe_unused]] const Common::ParamPackage& params) { [[maybe_unused]] const Common::ParamPackage& params) {
return {}; return {};
}; }
/// Retrieves the motion mappings for the given device /// Retrieves the motion mappings for the given device
virtual InputCommon::MotionMapping GetMotionMappingForDevice( virtual MotionMapping GetMotionMappingForDevice(
[[maybe_unused]] const Common::ParamPackage& params) { [[maybe_unused]] const Common::ParamPackage& params) {
return {}; return {};
}; }
/// Retrieves the name of the given input. /// Retrieves the name of the given input.
virtual Common::Input::ButtonNames GetUIName( virtual Common::Input::ButtonNames GetUIName(
[[maybe_unused]] const Common::ParamPackage& params) const { [[maybe_unused]] const Common::ParamPackage& params) const {
return Common::Input::ButtonNames::Engine; return Common::Input::ButtonNames::Engine;
}; }
/// Retrieves the index number of the given hat button direction /// Retrieves the index number of the given hat button direction
virtual u8 GetHatButtonId([[maybe_unused]] const std::string& direction_name) const { virtual u8 GetHatButtonId([[maybe_unused]] const std::string& direction_name) const {
return 0; return 0;
}; }
void PreSetController(const PadIdentifier& identifier); void PreSetController(const PadIdentifier& identifier);
void PreSetButton(const PadIdentifier& identifier, int button); void PreSetButton(const PadIdentifier& identifier, int button);
@ -194,7 +190,7 @@ protected:
void SetHatButton(const PadIdentifier& identifier, int button, u8 value); void SetHatButton(const PadIdentifier& identifier, int button, u8 value);
void SetAxis(const PadIdentifier& identifier, int axis, f32 value); void SetAxis(const PadIdentifier& identifier, int axis, f32 value);
void SetBattery(const PadIdentifier& identifier, BatteryLevel value); void SetBattery(const PadIdentifier& identifier, BatteryLevel value);
void SetMotion(const PadIdentifier& identifier, int motion, BasicMotion value); void SetMotion(const PadIdentifier& identifier, int motion, const BasicMotion& value);
virtual std::string GetHatButtonName([[maybe_unused]] u8 direction_value) const { virtual std::string GetHatButtonName([[maybe_unused]] u8 direction_value) const {
return "Unknown"; return "Unknown";
@ -206,14 +202,15 @@ private:
std::unordered_map<int, u8> hat_buttons; std::unordered_map<int, u8> hat_buttons;
std::unordered_map<int, float> axes; std::unordered_map<int, float> axes;
std::unordered_map<int, BasicMotion> motions; std::unordered_map<int, BasicMotion> motions;
BatteryLevel battery; BatteryLevel battery{};
}; };
void TriggerOnButtonChange(const PadIdentifier& identifier, int button, bool value); void TriggerOnButtonChange(const PadIdentifier& identifier, int button, bool value);
void TriggerOnHatButtonChange(const PadIdentifier& identifier, int button, u8 value); void TriggerOnHatButtonChange(const PadIdentifier& identifier, int button, u8 value);
void TriggerOnAxisChange(const PadIdentifier& identifier, int button, f32 value); void TriggerOnAxisChange(const PadIdentifier& identifier, int axis, f32 value);
void TriggerOnBatteryChange(const PadIdentifier& identifier, BatteryLevel value); void TriggerOnBatteryChange(const PadIdentifier& identifier, BatteryLevel value);
void TriggerOnMotionChange(const PadIdentifier& identifier, int motion, BasicMotion value); void TriggerOnMotionChange(const PadIdentifier& identifier, int motion,
const BasicMotion& value);
bool IsInputIdentifierEqual(const InputIdentifier& input_identifier, bool IsInputIdentifierEqual(const InputIdentifier& input_identifier,
const PadIdentifier& identifier, EngineInputType type, const PadIdentifier& identifier, EngineInputType type,

20
src/input_common/input_mapping.h
View file

@ -14,8 +14,8 @@ public:
MappingFactory(); MappingFactory();
/** /**
* Resets all varables to beggin the mapping process * Resets all variables to begin the mapping process
* @param "type": type of input desired to be returned * @param type type of input desired to be returned
*/ */
void BeginMapping(Polling::InputType type); void BeginMapping(Polling::InputType type);
@ -24,7 +24,7 @@ public:
/** /**
* Registers mapping input data from the driver * Registers mapping input data from the driver
* @param "data": An struct containing all the information needed to create a proper * @param data A struct containing all the information needed to create a proper
* ParamPackage * ParamPackage
*/ */
void RegisterInput(const MappingData& data); void RegisterInput(const MappingData& data);
@ -34,41 +34,41 @@ public:
private: private:
/** /**
* If provided data satisfies the requeriments it will push an element to the input_queue * If provided data satisfies the requirements it will push an element to the input_queue
* Supported input: * Supported input:
* - Button: Creates a basic button ParamPackage * - Button: Creates a basic button ParamPackage
* - HatButton: Creates a basic hat button ParamPackage * - HatButton: Creates a basic hat button ParamPackage
* - Analog: Creates a basic analog ParamPackage * - Analog: Creates a basic analog ParamPackage
* @param "data": An struct containing all the information needed to create a proper * @param data A struct containing all the information needed to create a proper
* ParamPackage * ParamPackage
*/ */
void RegisterButton(const MappingData& data); void RegisterButton(const MappingData& data);
/** /**
* If provided data satisfies the requeriments it will push an element to the input_queue * If provided data satisfies the requirements it will push an element to the input_queue
* Supported input: * Supported input:
* - Button, HatButton: Pass the data to RegisterButton * - Button, HatButton: Pass the data to RegisterButton
* - Analog: Stores the first axis and on the second axis creates a basic stick ParamPackage * - Analog: Stores the first axis and on the second axis creates a basic stick ParamPackage
* @param "data": An struct containing all the information needed to create a proper * @param data A struct containing all the information needed to create a proper
* ParamPackage * ParamPackage
*/ */
void RegisterStick(const MappingData& data); void RegisterStick(const MappingData& data);
/** /**
* If provided data satisfies the requeriments it will push an element to the input_queue * If provided data satisfies the requirements it will push an element to the input_queue
* Supported input: * Supported input:
* - Button, HatButton: Pass the data to RegisterButton * - Button, HatButton: Pass the data to RegisterButton
* - Analog: Stores the first two axis and on the third axis creates a basic Motion * - Analog: Stores the first two axis and on the third axis creates a basic Motion
* ParamPackage * ParamPackage
* - Motion: Creates a basic Motion ParamPackage * - Motion: Creates a basic Motion ParamPackage
* @param "data": An struct containing all the information needed to create a proper * @param data A struct containing all the information needed to create a proper
* ParamPackage * ParamPackage
*/ */
void RegisterMotion(const MappingData& data); void RegisterMotion(const MappingData& data);
/** /**
* Returns true if driver can be mapped * Returns true if driver can be mapped
* @param "data": An struct containing all the information needed to create a proper * @param data A struct containing all the information needed to create a proper
* ParamPackage * ParamPackage
*/ */
bool IsDriverValid(const MappingData& data) const; bool IsDriverValid(const MappingData& data) const;

39
src/input_common/input_poller.cpp
View file

@ -12,8 +12,7 @@ namespace InputCommon {
class DummyInput final : public Common::Input::InputDevice { class DummyInput final : public Common::Input::InputDevice {
public: public:
explicit DummyInput() {} explicit DummyInput() = default;
~DummyInput() {}
}; };
class InputFromButton final : public Common::Input::InputDevice { class InputFromButton final : public Common::Input::InputDevice {
@ -33,7 +32,7 @@ public:
callback_key = input_engine->SetCallback(input_identifier); callback_key = input_engine->SetCallback(input_identifier);
} }
~InputFromButton() { ~InputFromButton() override {
input_engine->DeleteCallback(callback_key); input_engine->DeleteCallback(callback_key);
} }
@ -45,7 +44,7 @@ public:
}; };
} }
void ForceUpdate() { void ForceUpdate() override {
const Common::Input::CallbackStatus status{ const Common::Input::CallbackStatus status{
.type = Common::Input::InputType::Button, .type = Common::Input::InputType::Button,
.button_status = GetStatus(), .button_status = GetStatus(),
@ -94,7 +93,7 @@ public:
callback_key = input_engine->SetCallback(input_identifier); callback_key = input_engine->SetCallback(input_identifier);
} }
~InputFromHatButton() { ~InputFromHatButton() override {
input_engine->DeleteCallback(callback_key); input_engine->DeleteCallback(callback_key);
} }
@ -106,7 +105,7 @@ public:
}; };
} }
void ForceUpdate() { void ForceUpdate() override {
const Common::Input::CallbackStatus status{ const Common::Input::CallbackStatus status{
.type = Common::Input::InputType::Button, .type = Common::Input::InputType::Button,
.button_status = GetStatus(), .button_status = GetStatus(),
@ -167,7 +166,7 @@ public:
callback_key_y = input_engine->SetCallback(y_input_identifier); callback_key_y = input_engine->SetCallback(y_input_identifier);
} }
~InputFromStick() { ~InputFromStick() override {
input_engine->DeleteCallback(callback_key_x); input_engine->DeleteCallback(callback_key_x);
input_engine->DeleteCallback(callback_key_y); input_engine->DeleteCallback(callback_key_y);
} }
@ -190,7 +189,7 @@ public:
return status; return status;
} }
void ForceUpdate() { void ForceUpdate() override {
const Common::Input::CallbackStatus status{ const Common::Input::CallbackStatus status{
.type = Common::Input::InputType::Stick, .type = Common::Input::InputType::Stick,
.stick_status = GetStatus(), .stick_status = GetStatus(),
@ -266,7 +265,7 @@ public:
callback_key_y = input_engine->SetCallback(y_input_identifier); callback_key_y = input_engine->SetCallback(y_input_identifier);
} }
~InputFromTouch() { ~InputFromTouch() override {
input_engine->DeleteCallback(callback_key_button); input_engine->DeleteCallback(callback_key_button);
input_engine->DeleteCallback(callback_key_x); input_engine->DeleteCallback(callback_key_x);
input_engine->DeleteCallback(callback_key_y); input_engine->DeleteCallback(callback_key_y);
@ -352,7 +351,7 @@ public:
axis_callback_key = input_engine->SetCallback(axis_input_identifier); axis_callback_key = input_engine->SetCallback(axis_input_identifier);
} }
~InputFromTrigger() { ~InputFromTrigger() override {
input_engine->DeleteCallback(callback_key_button); input_engine->DeleteCallback(callback_key_button);
input_engine->DeleteCallback(axis_callback_key); input_engine->DeleteCallback(axis_callback_key);
} }
@ -419,7 +418,7 @@ public:
callback_key = input_engine->SetCallback(input_identifier); callback_key = input_engine->SetCallback(input_identifier);
} }
~InputFromAnalog() { ~InputFromAnalog() override {
input_engine->DeleteCallback(callback_key); input_engine->DeleteCallback(callback_key);
} }
@ -466,7 +465,7 @@ public:
callback_key = input_engine->SetCallback(input_identifier); callback_key = input_engine->SetCallback(input_identifier);
} }
~InputFromBattery() { ~InputFromBattery() override {
input_engine->DeleteCallback(callback_key); input_engine->DeleteCallback(callback_key);
} }
@ -474,7 +473,7 @@ public:
return static_cast<Common::Input::BatteryLevel>(input_engine->GetBattery(identifier)); return static_cast<Common::Input::BatteryLevel>(input_engine->GetBattery(identifier));
} }
void ForceUpdate() { void ForceUpdate() override {
const Common::Input::CallbackStatus status{ const Common::Input::CallbackStatus status{
.type = Common::Input::InputType::Battery, .type = Common::Input::InputType::Battery,
.battery_status = GetStatus(), .battery_status = GetStatus(),
@ -518,7 +517,7 @@ public:
callback_key = input_engine->SetCallback(input_identifier); callback_key = input_engine->SetCallback(input_identifier);
} }
~InputFromMotion() { ~InputFromMotion() override {
input_engine->DeleteCallback(callback_key); input_engine->DeleteCallback(callback_key);
} }
@ -593,7 +592,7 @@ public:
callback_key_z = input_engine->SetCallback(z_input_identifier); callback_key_z = input_engine->SetCallback(z_input_identifier);
} }
~InputFromAxisMotion() { ~InputFromAxisMotion() override {
input_engine->DeleteCallback(callback_key_x); input_engine->DeleteCallback(callback_key_x);
input_engine->DeleteCallback(callback_key_y); input_engine->DeleteCallback(callback_key_y);
input_engine->DeleteCallback(callback_key_z); input_engine->DeleteCallback(callback_key_z);
@ -618,7 +617,7 @@ public:
return status; return status;
} }
void ForceUpdate() { void ForceUpdate() override {
const Common::Input::CallbackStatus status{ const Common::Input::CallbackStatus status{
.type = Common::Input::InputType::Motion, .type = Common::Input::InputType::Motion,
.motion_status = GetStatus(), .motion_status = GetStatus(),
@ -668,16 +667,16 @@ public:
explicit OutputFromIdentifier(PadIdentifier identifier_, InputEngine* input_engine_) explicit OutputFromIdentifier(PadIdentifier identifier_, InputEngine* input_engine_)
: identifier(identifier_), input_engine(input_engine_) {} : identifier(identifier_), input_engine(input_engine_) {}
virtual void SetLED(Common::Input::LedStatus led_status) { void SetLED(const Common::Input::LedStatus& led_status) override {
input_engine->SetLeds(identifier, led_status); input_engine->SetLeds(identifier, led_status);
} }
virtual Common::Input::VibrationError SetVibration( Common::Input::VibrationError SetVibration(
Common::Input::VibrationStatus vibration_status) { const Common::Input::VibrationStatus& vibration_status) override {
return input_engine->SetRumble(identifier, vibration_status); return input_engine->SetRumble(identifier, vibration_status);
} }
virtual Common::Input::PollingError SetPollingMode(Common::Input::PollingMode polling_mode) { Common::Input::PollingError SetPollingMode(Common::Input::PollingMode polling_mode) override {
return input_engine->SetPollingMode(identifier, polling_mode); return input_engine->SetPollingMode(identifier, polling_mode);
} }

212
src/input_common/input_poller.h
View file

@ -13,9 +13,6 @@ class Factory;
namespace InputCommon { namespace InputCommon {
class InputEngine; class InputEngine;
/**
* An Input factory. It receives input events and forward them to all input devices it created.
*/
class OutputFactory final : public Common::Input::Factory<Common::Input::OutputDevice> { class OutputFactory final : public Common::Input::Factory<Common::Input::OutputDevice> {
public: public:
@ -24,10 +21,10 @@ public:
/** /**
* Creates an output device from the parameters given. * Creates an output device from the parameters given.
* @param params contains parameters for creating the device: * @param params contains parameters for creating the device:
* @param - "guid": text string for identifing controllers * - "guid" text string for identifying controllers
* @param - "port": port of the connected device * - "port": port of the connected device
* @param - "pad": slot of the connected controller * - "pad": slot of the connected controller
* @return an unique ouput device with the parameters specified * @returns a unique output device with the parameters specified
*/ */
std::unique_ptr<Common::Input::OutputDevice> Create( std::unique_ptr<Common::Input::OutputDevice> Create(
const Common::ParamPackage& params) override; const Common::ParamPackage& params) override;
@ -36,6 +33,9 @@ private:
std::shared_ptr<InputEngine> input_engine; std::shared_ptr<InputEngine> input_engine;
}; };
/**
* An Input factory. It receives input events and forward them to all input devices it created.
*/
class InputFactory final : public Common::Input::Factory<Common::Input::InputDevice> { class InputFactory final : public Common::Input::Factory<Common::Input::InputDevice> {
public: public:
explicit InputFactory(std::shared_ptr<InputEngine> input_engine_); explicit InputFactory(std::shared_ptr<InputEngine> input_engine_);
@ -54,16 +54,16 @@ public:
* - battery: Contains "battery" * - battery: Contains "battery"
* - output: Contains "output" * - output: Contains "output"
* @param params contains parameters for creating the device: * @param params contains parameters for creating the device:
* @param - "code": the code of the keyboard key to bind with the input * - "code": the code of the keyboard key to bind with the input
* @param - "button": same as "code" but for controller buttons * - "button": same as "code" but for controller buttons
* @param - "hat": similar as "button" but it's a group of hat buttons from SDL * - "hat": similar as "button" but it's a group of hat buttons from SDL
* @param - "axis": the axis number of the axis to bind with the input * - "axis": the axis number of the axis to bind with the input
* @param - "motion": the motion number of the motion to bind with the input * - "motion": the motion number of the motion to bind with the input
* @param - "axis_x": same as axis but specifing horizontal direction * - "axis_x": same as axis but specifying horizontal direction
* @param - "axis_y": same as axis but specifing vertical direction * - "axis_y": same as axis but specifying vertical direction
* @param - "axis_z": same as axis but specifing forward direction * - "axis_z": same as axis but specifying forward direction
* @param - "battery": Only used as a placeholder to set the input type * - "battery": Only used as a placeholder to set the input type
* @return an unique input device with the parameters specified * @returns a unique input device with the parameters specified
*/ */
std::unique_ptr<Common::Input::InputDevice> Create(const Common::ParamPackage& params) override; std::unique_ptr<Common::Input::InputDevice> Create(const Common::ParamPackage& params) override;
@ -71,14 +71,14 @@ private:
/** /**
* Creates a button device from the parameters given. * Creates a button device from the parameters given.
* @param params contains parameters for creating the device: * @param params contains parameters for creating the device:
* @param - "code": the code of the keyboard key to bind with the input * - "code": the code of the keyboard key to bind with the input
* @param - "button": same as "code" but for controller buttons * - "button": same as "code" but for controller buttons
* @param - "toggle": press once to enable, press again to disable * - "toggle": press once to enable, press again to disable
* @param - "inverted": inverts the output of the button * - "inverted": inverts the output of the button
* @param - "guid": text string for identifing controllers * - "guid": text string for identifying controllers
* @param - "port": port of the connected device * - "port": port of the connected device
* @param - "pad": slot of the connected controller * - "pad": slot of the connected controller
* @return an unique input device with the parameters specified * @returns a unique input device with the parameters specified
*/ */
std::unique_ptr<Common::Input::InputDevice> CreateButtonDevice( std::unique_ptr<Common::Input::InputDevice> CreateButtonDevice(
const Common::ParamPackage& params); const Common::ParamPackage& params);
@ -86,14 +86,14 @@ private:
/** /**
* Creates a hat button device from the parameters given. * Creates a hat button device from the parameters given.
* @param params contains parameters for creating the device: * @param params contains parameters for creating the device:
* @param - "button": the controller hat id to bind with the input * - "button": the controller hat id to bind with the input
* @param - "direction": the direction id to be detected * - "direction": the direction id to be detected
* @param - "toggle": press once to enable, press again to disable * - "toggle": press once to enable, press again to disable
* @param - "inverted": inverts the output of the button * - "inverted": inverts the output of the button
* @param - "guid": text string for identifing controllers * - "guid": text string for identifying controllers
* @param - "port": port of the connected device * - "port": port of the connected device
* @param - "pad": slot of the connected controller * - "pad": slot of the connected controller
* @return an unique input device with the parameters specified * @returns a unique input device with the parameters specified
*/ */
std::unique_ptr<Common::Input::InputDevice> CreateHatButtonDevice( std::unique_ptr<Common::Input::InputDevice> CreateHatButtonDevice(
const Common::ParamPackage& params); const Common::ParamPackage& params);
@ -101,19 +101,19 @@ private:
/** /**
* Creates a stick device from the parameters given. * Creates a stick device from the parameters given.
* @param params contains parameters for creating the device: * @param params contains parameters for creating the device:
* @param - "axis_x": the controller horizontal axis id to bind with the input * - "axis_x": the controller horizontal axis id to bind with the input
* @param - "axis_y": the controller vertical axis id to bind with the input * - "axis_y": the controller vertical axis id to bind with the input
* @param - "deadzone": the mimimum required value to be detected * - "deadzone": the minimum required value to be detected
* @param - "range": the maximum value required to reach 100% * - "range": the maximum value required to reach 100%
* @param - "threshold": the mimimum required value to considered pressed * - "threshold": the minimum required value to considered pressed
* @param - "offset_x": the amount of offset in the x axis * - "offset_x": the amount of offset in the x axis
* @param - "offset_y": the amount of offset in the y axis * - "offset_y": the amount of offset in the y axis
* @param - "invert_x": inverts the sign of the horizontal axis * - "invert_x": inverts the sign of the horizontal axis
* @param - "invert_y": inverts the sign of the vertical axis * - "invert_y": inverts the sign of the vertical axis
* @param - "guid": text string for identifing controllers * - "guid": text string for identifying controllers
* @param - "port": port of the connected device * - "port": port of the connected device
* @param - "pad": slot of the connected controller * - "pad": slot of the connected controller
* @return an unique input device with the parameters specified * @returns a unique input device with the parameters specified
*/ */
std::unique_ptr<Common::Input::InputDevice> CreateStickDevice( std::unique_ptr<Common::Input::InputDevice> CreateStickDevice(
const Common::ParamPackage& params); const Common::ParamPackage& params);
@ -121,16 +121,16 @@ private:
/** /**
* Creates an analog device from the parameters given. * Creates an analog device from the parameters given.
* @param params contains parameters for creating the device: * @param params contains parameters for creating the device:
* @param - "axis": the controller axis id to bind with the input * - "axis": the controller axis id to bind with the input
* @param - "deadzone": the mimimum required value to be detected * - "deadzone": the minimum required value to be detected
* @param - "range": the maximum value required to reach 100% * - "range": the maximum value required to reach 100%
* @param - "threshold": the mimimum required value to considered pressed * - "threshold": the minimum required value to considered pressed
* @param - "offset": the amount of offset in the axis * - "offset": the amount of offset in the axis
* @param - "invert": inverts the sign of the axis * - "invert": inverts the sign of the axis
* @param - "guid": text string for identifing controllers * - "guid": text string for identifying controllers
* @param - "port": port of the connected device * - "port": port of the connected device
* @param - "pad": slot of the connected controller * - "pad": slot of the connected controller
* @return an unique input device with the parameters specified * @returns a unique input device with the parameters specified
*/ */
std::unique_ptr<Common::Input::InputDevice> CreateAnalogDevice( std::unique_ptr<Common::Input::InputDevice> CreateAnalogDevice(
const Common::ParamPackage& params); const Common::ParamPackage& params);
@ -138,20 +138,20 @@ private:
/** /**
* Creates a trigger device from the parameters given. * Creates a trigger device from the parameters given.
* @param params contains parameters for creating the device: * @param params contains parameters for creating the device:
* @param - "button": the controller hat id to bind with the input * - "button": the controller hat id to bind with the input
* @param - "direction": the direction id to be detected * - "direction": the direction id to be detected
* @param - "toggle": press once to enable, press again to disable * - "toggle": press once to enable, press again to disable
* @param - "inverted": inverts the output of the button * - "inverted": inverts the output of the button
* @param - "axis": the controller axis id to bind with the input * - "axis": the controller axis id to bind with the input
* @param - "deadzone": the mimimum required value to be detected * - "deadzone": the minimum required value to be detected
* @param - "range": the maximum value required to reach 100% * - "range": the maximum value required to reach 100%
* @param - "threshold": the mimimum required value to considered pressed * - "threshold": the minimum required value to considered pressed
* @param - "offset": the amount of offset in the axis * - "offset": the amount of offset in the axis
* @param - "invert": inverts the sign of the axis * - "invert": inverts the sign of the axis
* @param - "guid": text string for identifing controllers * - "guid": text string for identifying controllers
* @param - "port": port of the connected device * - "port": port of the connected device
* @param - "pad": slot of the connected controller * - "pad": slot of the connected controller
* @return an unique input device with the parameters specified * @returns a unique input device with the parameters specified
*/ */
std::unique_ptr<Common::Input::InputDevice> CreateTriggerDevice( std::unique_ptr<Common::Input::InputDevice> CreateTriggerDevice(
const Common::ParamPackage& params); const Common::ParamPackage& params);
@ -159,23 +159,23 @@ private:
/** /**
* Creates a touch device from the parameters given. * Creates a touch device from the parameters given.
* @param params contains parameters for creating the device: * @param params contains parameters for creating the device:
* @param - "button": the controller hat id to bind with the input * - "button": the controller hat id to bind with the input
* @param - "direction": the direction id to be detected * - "direction": the direction id to be detected
* @param - "toggle": press once to enable, press again to disable * - "toggle": press once to enable, press again to disable
* @param - "inverted": inverts the output of the button * - "inverted": inverts the output of the button
* @param - "axis_x": the controller horizontal axis id to bind with the input * - "axis_x": the controller horizontal axis id to bind with the input
* @param - "axis_y": the controller vertical axis id to bind with the input * - "axis_y": the controller vertical axis id to bind with the input
* @param - "deadzone": the mimimum required value to be detected * - "deadzone": the minimum required value to be detected
* @param - "range": the maximum value required to reach 100% * - "range": the maximum value required to reach 100%
* @param - "threshold": the mimimum required value to considered pressed * - "threshold": the minimum required value to considered pressed
* @param - "offset_x": the amount of offset in the x axis * - "offset_x": the amount of offset in the x axis
* @param - "offset_y": the amount of offset in the y axis * - "offset_y": the amount of offset in the y axis
* @param - "invert_x": inverts the sign of the horizontal axis * - "invert_x": inverts the sign of the horizontal axis
* @param - "invert_y": inverts the sign of the vertical axis * - "invert_y": inverts the sign of the vertical axis
* @param - "guid": text string for identifing controllers * - "guid": text string for identifying controllers
* @param - "port": port of the connected device * - "port": port of the connected device
* @param - "pad": slot of the connected controller * - "pad": slot of the connected controller
* @return an unique input device with the parameters specified * @returns a unique input device with the parameters specified
*/ */
std::unique_ptr<Common::Input::InputDevice> CreateTouchDevice( std::unique_ptr<Common::Input::InputDevice> CreateTouchDevice(
const Common::ParamPackage& params); const Common::ParamPackage& params);
@ -183,10 +183,10 @@ private:
/** /**
* Creates a battery device from the parameters given. * Creates a battery device from the parameters given.
* @param params contains parameters for creating the device: * @param params contains parameters for creating the device:
* @param - "guid": text string for identifing controllers * - "guid": text string for identifying controllers
* @param - "port": port of the connected device * - "port": port of the connected device
* @param - "pad": slot of the connected controller * - "pad": slot of the connected controller
* @return an unique input device with the parameters specified * @returns a unique input device with the parameters specified
*/ */
std::unique_ptr<Common::Input::InputDevice> CreateBatteryDevice( std::unique_ptr<Common::Input::InputDevice> CreateBatteryDevice(
const Common::ParamPackage& params); const Common::ParamPackage& params);
@ -194,21 +194,21 @@ private:
/** /**
* Creates a motion device from the parameters given. * Creates a motion device from the parameters given.
* @param params contains parameters for creating the device: * @param params contains parameters for creating the device:
* @param - "axis_x": the controller horizontal axis id to bind with the input * - "axis_x": the controller horizontal axis id to bind with the input
* @param - "axis_y": the controller vertical axis id to bind with the input * - "axis_y": the controller vertical axis id to bind with the input
* @param - "axis_z": the controller fordward axis id to bind with the input * - "axis_z": the controller forward axis id to bind with the input
* @param - "deadzone": the mimimum required value to be detected * - "deadzone": the minimum required value to be detected
* @param - "range": the maximum value required to reach 100% * - "range": the maximum value required to reach 100%
* @param - "offset_x": the amount of offset in the x axis * - "offset_x": the amount of offset in the x axis
* @param - "offset_y": the amount of offset in the y axis * - "offset_y": the amount of offset in the y axis
* @param - "offset_z": the amount of offset in the z axis * - "offset_z": the amount of offset in the z axis
* @param - "invert_x": inverts the sign of the horizontal axis * - "invert_x": inverts the sign of the horizontal axis
* @param - "invert_y": inverts the sign of the vertical axis * - "invert_y": inverts the sign of the vertical axis
* @param - "invert_z": inverts the sign of the fordward axis * - "invert_z": inverts the sign of the forward axis
* @param - "guid": text string for identifing controllers * - "guid": text string for identifying controllers
* @param - "port": port of the connected device * - "port": port of the connected device
* @param - "pad": slot of the connected controller * - "pad": slot of the connected controller
* @return an unique input device with the parameters specified * @returns a unique input device with the parameters specified
*/ */
std::unique_ptr<Common::Input::InputDevice> CreateMotionDevice(Common::ParamPackage params); std::unique_ptr<Common::Input::InputDevice> CreateMotionDevice(Common::ParamPackage params);

17
src/yuzu/applets/qt_software_keyboard.cpp
View file

@ -475,11 +475,26 @@ void QtSoftwareKeyboardDialog::open() {
row = 0; row = 0;
column = 0; column = 0;
switch (bottom_osk_index) {
case BottomOSKIndex::LowerCase:
case BottomOSKIndex::UpperCase: {
const auto* const curr_button = const auto* const curr_button =
keyboard_buttons[static_cast<int>(bottom_osk_index)][row][column]; keyboard_buttons[static_cast<std::size_t>(bottom_osk_index)][row][column];
// This is a workaround for setFocus() randomly not showing focus in the UI // This is a workaround for setFocus() randomly not showing focus in the UI
QCursor::setPos(curr_button->mapToGlobal(curr_button->rect().center())); QCursor::setPos(curr_button->mapToGlobal(curr_button->rect().center()));
break;
}
case BottomOSKIndex::NumberPad: {
const auto* const curr_button = numberpad_buttons[row][column];
// This is a workaround for setFocus() randomly not showing focus in the UI
QCursor::setPos(curr_button->mapToGlobal(curr_button->rect().center()));
break;
}
default:
break;
}
StartInputThread(); StartInputThread();
} }