Nikilite/suyu
1
1
Fork 0
forked from suyu/suyu
Code Pull requests Activity

input_common: Allow keyboard to be backwards compatible

Browse source
This commit is contained in:
german77 2021-11-14 10:45:07 -06:00 committed by Narr the Reg
parent b673857d7d
commit bca299e8e0
10 changed files with 115 additions and 48 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/common/settings.h
View file

@ -572,8 +572,6 @@ struct Values {
BasicSetting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
BasicSetting<bool> keyboard_enabled{false, "keyboard_enabled"};
KeyboardKeysRaw keyboard_keys;
KeyboardModsRaw keyboard_mods;
BasicSetting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
ButtonsRaw debug_pad_buttons;

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

@ -29,13 +29,29 @@ void EmulatedDevices::ReloadInput() {
mouse_button_devices.begin(),
Common::Input::CreateDevice<Common::Input::InputDevice>);
std::transform(Settings::values.keyboard_keys.begin(), Settings::values.keyboard_keys.end(),
keyboard_devices.begin(),
Common::Input::CreateDeviceFromString<Common::Input::InputDevice>);
std::size_t key_index = 0;
for (auto& keyboard_device : keyboard_devices) {
// Keyboard keys are only mapped on port 1, pad 0
Common::ParamPackage keyboard_params;
keyboard_params.Set("engine", "keyboard");
keyboard_params.Set("button", static_cast<int>(key_index));
keyboard_params.Set("port", 1);
keyboard_params.Set("pad", 0);
keyboard_device = Common::Input::CreateDevice<Common::Input::InputDevice>(keyboard_params);
key_index++;
}
std::transform(Settings::values.keyboard_mods.begin(), Settings::values.keyboard_mods.end(),
keyboard_modifier_devices.begin(),
Common::Input::CreateDeviceFromString<Common::Input::InputDevice>);
key_index = 0;
for (auto& keyboard_device : keyboard_modifier_devices) {
// Keyboard moddifiers are only mapped on port 1, pad 1
Common::ParamPackage keyboard_params;
keyboard_params.Set("engine", "keyboard");
keyboard_params.Set("button", static_cast<int>(key_index));
keyboard_params.Set("port", 1);
keyboard_params.Set("pad", 1);
keyboard_device = Common::Input::CreateDevice<Common::Input::InputDevice>(keyboard_params);
key_index++;
}
for (std::size_t index = 0; index < mouse_button_devices.size(); ++index) {
if (!mouse_button_devices[index]) {

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

@ -13,15 +13,26 @@ constexpr PadIdentifier key_identifier = {
.port = 0,
.pad = 0,
};
constexpr PadIdentifier modifier_identifier = {
constexpr PadIdentifier keyboard_key_identifier = {
.guid = Common::UUID{Common::INVALID_UUID},
.port = 0,
.port = 1,
.pad = 0,
};
constexpr PadIdentifier keyboard_modifier_identifier = {
.guid = Common::UUID{Common::INVALID_UUID},
.port = 1,
.pad = 1,
};
Keyboard::Keyboard(const std::string& input_engine_) : InputEngine(input_engine_) {
// Keyboard is broken into 3 diferent sets:
// key: Unfiltered intended for controllers.
// keyboard_key: Allows only Settings::NativeKeyboard::Keys intended for keyboard emulation.
// keyboard_modifier: Allows only Settings::NativeKeyboard::Modifiers intended for keyboard
// emulation.
PreSetController(key_identifier);
PreSetController(modifier_identifier);
PreSetController(keyboard_key_identifier);
PreSetController(keyboard_modifier_identifier);
}
void Keyboard::PressKey(int key_code) {
@ -32,35 +43,50 @@ void Keyboard::ReleaseKey(int key_code) {
SetButton(key_identifier, key_code, false);
}
void Keyboard::SetModifiers(int key_modifiers) {
void Keyboard::PressKeyboardKey(int key_index) {
if (key_index == Settings::NativeKeyboard::None) {
return;
}
SetButton(keyboard_key_identifier, key_index, true);
}
void Keyboard::ReleaseKeyboardKey(int key_index) {
if (key_index == Settings::NativeKeyboard::None) {
return;
}
SetButton(keyboard_key_identifier, key_index, false);
}
void Keyboard::SetKeyboardModifiers(int key_modifiers) {
for (int i = 0; i < 32; ++i) {
bool key_value = ((key_modifiers >> i) & 0x1) != 0;
SetButton(modifier_identifier, i, key_value);
SetButton(keyboard_modifier_identifier, i, key_value);
// Use the modifier to press the key button equivalent
switch (i) {
case Settings::NativeKeyboard::LeftControl:
SetButton(key_identifier, Settings::NativeKeyboard::LeftControlKey, key_value);
SetButton(keyboard_key_identifier, Settings::NativeKeyboard::LeftControlKey, key_value);
break;
case Settings::NativeKeyboard::LeftShift:
SetButton(key_identifier, Settings::NativeKeyboard::LeftShiftKey, key_value);
SetButton(keyboard_key_identifier, Settings::NativeKeyboard::LeftShiftKey, key_value);
break;
case Settings::NativeKeyboard::LeftAlt:
SetButton(key_identifier, Settings::NativeKeyboard::LeftAltKey, key_value);
SetButton(keyboard_key_identifier, Settings::NativeKeyboard::LeftAltKey, key_value);
break;
case Settings::NativeKeyboard::LeftMeta:
SetButton(key_identifier, Settings::NativeKeyboard::LeftMetaKey, key_value);
SetButton(keyboard_key_identifier, Settings::NativeKeyboard::LeftMetaKey, key_value);
break;
case Settings::NativeKeyboard::RightControl:
SetButton(key_identifier, Settings::NativeKeyboard::RightControlKey, key_value);
SetButton(keyboard_key_identifier, Settings::NativeKeyboard::RightControlKey,
key_value);
break;
case Settings::NativeKeyboard::RightShift:
SetButton(key_identifier, Settings::NativeKeyboard::RightShiftKey, key_value);
SetButton(keyboard_key_identifier, Settings::NativeKeyboard::RightShiftKey, key_value);
break;
case Settings::NativeKeyboard::RightAlt:
SetButton(key_identifier, Settings::NativeKeyboard::RightAltKey, key_value);
SetButton(keyboard_key_identifier, Settings::NativeKeyboard::RightAltKey, key_value);
break;
case Settings::NativeKeyboard::RightMeta:
SetButton(key_identifier, Settings::NativeKeyboard::RightMetaKey, key_value);
SetButton(keyboard_key_identifier, Settings::NativeKeyboard::RightMetaKey, key_value);
break;
default:
// Other modifier keys should be pressed with PressKey since they stay enabled until

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

@ -28,11 +28,23 @@ public:
*/
void ReleaseKey(int key_code);
/**
* Sets the status of the keyboard key to pressed
* @param key_index index of the key to press
*/
void PressKeyboardKey(int key_index);
/**
* Sets the status of the keyboard key to released
* @param key_index index of the key to release
*/
void ReleaseKeyboardKey(int key_index);
/**
* Sets the status of all keyboard modifier keys
* @param key_modifiers the code of the key to release
*/
void SetModifiers(int key_modifiers);
void SetKeyboardModifiers(int key_modifiers);
/// Sets all keys to the non pressed state
void ReleaseAllKeys();

25
src/input_common/input_mapping.cpp
View file

@ -28,6 +28,10 @@ void MappingFactory::RegisterInput(const MappingData& data) {
if (!is_enabled) {
return;
}
if (!IsDriverValid(data)) {
return;
}
switch (input_type) {
case Polling::InputType::Button:
RegisterButton(data);
@ -168,4 +172,25 @@ void MappingFactory::RegisterMotion(const MappingData& data) {
input_queue.Push(new_input);
}
bool MappingFactory::IsDriverValid(const MappingData& data) const {
// Only port 0 can be mapped on the keyboard
if (data.engine == "keyboard" && data.pad.port != 0) {
return false;
}
// The following drivers don't need to be mapped
if (data.engine == "tas") {
return false;
}
if (data.engine == "touch") {
return false;
}
if (data.engine == "touch_from_button") {
return false;
}
if (data.engine == "analog_from_button") {
return false;
}
return true;
}
} // namespace InputCommon

7
src/input_common/input_mapping.h
View file

@ -66,6 +66,13 @@ private:
*/
void RegisterMotion(const MappingData& data);
/**
* Returns true if driver can be mapped
* @param "data": An struct containing all the information needed to create a proper
* ParamPackage
*/
bool IsDriverValid(const MappingData& data) const;
Common::SPSCQueue<Common::ParamPackage> input_queue;
Polling::InputType input_type{Polling::InputType::None};
bool is_enabled{};

9
src/input_common/main.cpp
View file

@ -402,15 +402,6 @@ std::string GenerateKeyboardParam(int key_code) {
return param.Serialize();
}
std::string GenerateModdifierKeyboardParam(int key_code) {
Common::ParamPackage param;
param.Set("engine", "keyboard");
param.Set("code", key_code);
param.Set("toggle", false);
param.Set("pad", 1);
return param.Serialize();
}
std::string GenerateAnalogParamFromKeys(int key_up, int key_down, int key_left, int key_right,
int key_modifier, float modifier_scale) {
Common::ParamPackage circle_pad_param{

3
src/input_common/main.h
View file

@ -134,9 +134,6 @@ private:
/// Generates a serialized param package for creating a keyboard button device.
std::string GenerateKeyboardParam(int key_code);
/// Generates a serialized param package for creating a moddifier keyboard button device.
std::string GenerateModdifierKeyboardParam(int key_code);
/// Generates a serialized param package for creating an analog device taking input from keyboard.
std::string GenerateAnalogParamFromKeys(int key_up, int key_down, int key_left, int key_right,
int key_modifier, float modifier_scale);

14
src/yuzu/bootmanager.cpp
View file

@ -609,7 +609,7 @@ int GRenderWindow::QtKeyToSwitchKey(Qt::Key qt_key) {
return Settings::NativeKeyboard::ZenkakuHankaku;
// Modifier keys are handled by the modifier property
default:
return 0;
return Settings::NativeKeyboard::None;
}
}
@ -662,8 +662,10 @@ void GRenderWindow::keyPressEvent(QKeyEvent* event) {
// Replace event->key() with event->nativeVirtualKey() since the second one provides raw key
// buttons
const auto key = QtKeyToSwitchKey(Qt::Key(event->key()));
input_subsystem->GetKeyboard()->SetModifiers(moddifier);
input_subsystem->GetKeyboard()->PressKey(key);
input_subsystem->GetKeyboard()->SetKeyboardModifiers(moddifier);
input_subsystem->GetKeyboard()->PressKeyboardKey(key);
// This is used for gamepads
input_subsystem->GetKeyboard()->PressKey(event->key());
}
}
@ -671,8 +673,10 @@ void GRenderWindow::keyReleaseEvent(QKeyEvent* event) {
if (!event->isAutoRepeat()) {
const auto moddifier = QtModifierToSwitchModdifier(event->nativeModifiers());
const auto key = QtKeyToSwitchKey(Qt::Key(event->key()));
input_subsystem->GetKeyboard()->SetModifiers(moddifier);
input_subsystem->GetKeyboard()->ReleaseKey(key);
input_subsystem->GetKeyboard()->SetKeyboardModifiers(moddifier);
input_subsystem->GetKeyboard()->ReleaseKeyboardKey(key);
// This is used for gamepads
input_subsystem->GetKeyboard()->ReleaseKey(event->key());
}
}

9
src/yuzu/configuration/config.cpp
View file

@ -344,15 +344,6 @@ void Config::ReadDebugValues() {
void Config::ReadKeyboardValues() {
ReadBasicSetting(Settings::values.keyboard_enabled);
for (std::size_t i = 0; i < Settings::values.keyboard_keys.size(); ++i) {
Settings::values.keyboard_keys[i] = InputCommon::GenerateKeyboardParam(static_cast<int>(i));
}
for (std::size_t i = 0; i < Settings::values.keyboard_mods.size(); ++i) {
Settings::values.keyboard_mods[i] =
InputCommon::GenerateModdifierKeyboardParam(static_cast<int>(i));
}
}
void Config::ReadMouseValues() {