octocar
4c5aaf7f13
Some checks failed
eden-license / license-header (pull_request) Failing after 1m9s
1115 lines
No EOL
41 KiB
C++
1115 lines
No EOL
41 KiB
C++
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
// SPDX-FileCopyrightText: 2018 Citra Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include "common/logging/log.h"
|
|
#include "common/math_util.h"
|
|
#include "common/param_package.h"
|
|
#include "common/settings.h"
|
|
#include "common/thread.h"
|
|
#include "input_common/drivers/sdl_driver.h"
|
|
|
|
namespace InputCommon {
|
|
|
|
namespace {
|
|
Common::UUID GetGUID(SDL_Joystick* joystick) {
|
|
const SDL_GUID guid = SDL_GetJoystickGUID(joystick);
|
|
std::array<u8, 16> data{};
|
|
std::memcpy(data.data(), guid.data, sizeof(data));
|
|
std::memset(data.data() + 2, 0, sizeof(u16));
|
|
return Common::UUID{data};
|
|
}
|
|
} // Anonymous namespace
|
|
|
|
static bool SDLEventWatcher(void* user_data, SDL_Event* event) {
|
|
auto* const sdl_state = static_cast<SDLDriver*>(user_data);
|
|
sdl_state->HandleGameControllerEvent(*event);
|
|
return false;
|
|
}
|
|
|
|
class SDLJoystick {
|
|
public:
|
|
SDLJoystick(Common::UUID guid_, int port_, SDL_Joystick* joystick, SDL_Gamepad* gamepad)
|
|
: guid{guid_}, port{port_}, sdl_joystick{joystick, &SDL_CloseJoystick},
|
|
sdl_gamepad{gamepad, &SDL_CloseGamepad} {
|
|
EnableMotion();
|
|
}
|
|
|
|
void EnableMotion() {
|
|
if (!sdl_gamepad) {
|
|
return;
|
|
}
|
|
SDL_Gamepad* gamepad = sdl_gamepad.get();
|
|
if (HasMotion()) {
|
|
SDL_SetGamepadSensorEnabled(gamepad, SDL_SENSOR_ACCEL, false);
|
|
SDL_SetGamepadSensorEnabled(gamepad, SDL_SENSOR_GYRO, false);
|
|
}
|
|
has_accel = SDL_GamepadHasSensor(gamepad, SDL_SENSOR_ACCEL);
|
|
has_gyro = SDL_GamepadHasSensor(gamepad, SDL_SENSOR_GYRO);
|
|
if (has_accel) {
|
|
SDL_SetGamepadSensorEnabled(gamepad, SDL_SENSOR_ACCEL, true);
|
|
}
|
|
if (has_gyro) {
|
|
SDL_SetGamepadSensorEnabled(gamepad, SDL_SENSOR_GYRO, true);
|
|
}
|
|
}
|
|
|
|
bool HasMotion() const {
|
|
return has_gyro || has_accel;
|
|
}
|
|
|
|
bool UpdateMotion(SDL_GamepadSensorEvent event) {
|
|
constexpr float gravity_constant = 9.80665f;
|
|
std::scoped_lock lock{mutex};
|
|
const u64 time_difference = event.timestamp - last_motion_update;
|
|
last_motion_update = event.timestamp;
|
|
switch (event.sensor) {
|
|
case SDL_SENSOR_ACCEL: {
|
|
motion.accel_x = -event.data[0] / gravity_constant;
|
|
motion.accel_y = event.data[2] / gravity_constant;
|
|
motion.accel_z = -event.data[1] / gravity_constant;
|
|
break;
|
|
}
|
|
case SDL_SENSOR_GYRO: {
|
|
motion.gyro_x = event.data[0] / (Common::PI * 2);
|
|
motion.gyro_y = -event.data[2] / (Common::PI * 2);
|
|
motion.gyro_z = event.data[1] / (Common::PI * 2);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (time_difference == 0) {
|
|
return false;
|
|
}
|
|
|
|
if (motion.accel_x == 0 && motion.gyro_x == 0 && motion.accel_y == 0 &&
|
|
motion.gyro_y == 0 && motion.accel_z == 0 && motion.gyro_z == 0) {
|
|
if (motion_error_count++ < 200) {
|
|
return false;
|
|
}
|
|
motion_error_count = 0;
|
|
EnableMotion();
|
|
return false;
|
|
}
|
|
|
|
motion_error_count = 0;
|
|
motion.delta_timestamp = time_difference;
|
|
return true;
|
|
}
|
|
|
|
const BasicMotion& GetMotion() const {
|
|
return motion;
|
|
}
|
|
|
|
bool RumblePlay(const Common::Input::VibrationStatus vibration) {
|
|
constexpr u32 rumble_max_duration_ms = 2000;
|
|
constexpr f32 low_start_sensitivity_limit = 140.0f;
|
|
constexpr f32 low_width_sensitivity_limit = 400.0f;
|
|
constexpr f32 high_start_sensitivity_limit = 200.0f;
|
|
constexpr f32 high_width_sensitivity_limit = 700.0f;
|
|
|
|
f32 low_frequency_scale = 1.0f;
|
|
if (vibration.low_frequency > low_start_sensitivity_limit) {
|
|
low_frequency_scale =
|
|
(std::max)(1.0f - (vibration.low_frequency - low_start_sensitivity_limit) /
|
|
low_width_sensitivity_limit,
|
|
0.3f);
|
|
}
|
|
f32 low_amplitude = vibration.low_amplitude * low_frequency_scale;
|
|
|
|
f32 high_frequency_scale = 1.0f;
|
|
if (vibration.high_frequency > high_start_sensitivity_limit) {
|
|
high_frequency_scale =
|
|
(std::max)(1.0f - (vibration.high_frequency - high_start_sensitivity_limit) /
|
|
high_width_sensitivity_limit,
|
|
0.3f);
|
|
}
|
|
f32 high_amplitude = vibration.high_amplitude * high_frequency_scale;
|
|
|
|
if (sdl_gamepad) {
|
|
return SDL_RumbleGamepad(sdl_gamepad.get(), static_cast<u16>(low_amplitude),
|
|
static_cast<u16>(high_amplitude), rumble_max_duration_ms);
|
|
} else if (sdl_joystick) {
|
|
return SDL_RumbleJoystick(sdl_joystick.get(), static_cast<u16>(low_amplitude),
|
|
static_cast<u16>(high_amplitude), rumble_max_duration_ms);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool HasHDRumble() const {
|
|
if (sdl_gamepad) {
|
|
const auto type = SDL_GetGamepadType(sdl_gamepad.get());
|
|
return (type == SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_PRO) ||
|
|
(type == SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_LEFT) ||
|
|
(type == SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_RIGHT) ||
|
|
(type == SDL_GAMEPAD_TYPE_PS5);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void EnableVibration(bool is_enabled) {
|
|
has_vibration = is_enabled;
|
|
is_vibration_tested = true;
|
|
}
|
|
|
|
bool HasVibration() const {
|
|
return has_vibration;
|
|
}
|
|
|
|
bool IsVibrationTested() const {
|
|
return is_vibration_tested;
|
|
}
|
|
|
|
const PadIdentifier GetPadIdentifier() const {
|
|
return {
|
|
.guid = guid,
|
|
.port = static_cast<std::size_t>(port),
|
|
.pad = 0,
|
|
};
|
|
}
|
|
|
|
const Common::UUID& GetGUID() const {
|
|
return guid;
|
|
}
|
|
|
|
int GetPort() const {
|
|
return port;
|
|
}
|
|
|
|
SDL_Joystick* GetSDLJoystick() const {
|
|
return sdl_joystick.get();
|
|
}
|
|
|
|
SDL_Gamepad* GetSDLGamepad() const {
|
|
return sdl_gamepad.get();
|
|
}
|
|
|
|
void SetSDLJoystick(SDL_Joystick* joystick, SDL_Gamepad* gamepad) {
|
|
sdl_joystick.reset(joystick);
|
|
sdl_gamepad.reset(gamepad);
|
|
}
|
|
|
|
bool IsJoyconLeft() const {
|
|
const std::string controller_name = GetControllerName();
|
|
if (std::strstr(controller_name.c_str(), "Joy-Con Left") != nullptr) {
|
|
return true;
|
|
}
|
|
if (std::strstr(controller_name.c_str(), "Joy-Con (L)") != nullptr) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool IsJoyconRight() const {
|
|
const std::string controller_name = GetControllerName();
|
|
if (std::strstr(controller_name.c_str(), "Joy-Con Right") != nullptr) {
|
|
return true;
|
|
}
|
|
if (std::strstr(controller_name.c_str(), "Joy-Con (R)") != nullptr) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Common::Input::BatteryLevel GetBatteryLevel(SDL_PowerState battery_level) {
|
|
switch (battery_level) {
|
|
case SDL_POWERSTATE_ERROR:
|
|
case SDL_POWERSTATE_UNKNOWN:
|
|
return Common::Input::BatteryLevel::None;
|
|
case SDL_POWERSTATE_ON_BATTERY:
|
|
return Common::Input::BatteryLevel::Low;
|
|
case SDL_POWERSTATE_NO_BATTERY:
|
|
return Common::Input::BatteryLevel::None;
|
|
case SDL_POWERSTATE_CHARGING:
|
|
return Common::Input::BatteryLevel::Charging;
|
|
case SDL_POWERSTATE_CHARGED:
|
|
return Common::Input::BatteryLevel::Full;
|
|
default:
|
|
return Common::Input::BatteryLevel::None;
|
|
}
|
|
}
|
|
|
|
std::string GetControllerName() const {
|
|
if (sdl_gamepad) {
|
|
switch (SDL_GetGamepadType(sdl_gamepad.get())) {
|
|
case SDL_GAMEPAD_TYPE_XBOX360:
|
|
return "Xbox 360 Controller";
|
|
case SDL_GAMEPAD_TYPE_XBOXONE:
|
|
return "Xbox One Controller";
|
|
case SDL_GAMEPAD_TYPE_PS3:
|
|
return "DualShock 3 Controller";
|
|
case SDL_GAMEPAD_TYPE_PS4:
|
|
return "DualShock 4 Controller";
|
|
case SDL_GAMEPAD_TYPE_PS5:
|
|
return "DualSense Controller";
|
|
default:
|
|
break;
|
|
}
|
|
const auto name = SDL_GetGamepadName(sdl_gamepad.get());
|
|
if (name) {
|
|
return name;
|
|
}
|
|
}
|
|
|
|
if (sdl_joystick) {
|
|
const auto name = SDL_GetJoystickName(sdl_joystick.get());
|
|
if (name) {
|
|
return name;
|
|
}
|
|
}
|
|
|
|
return "Unknown";
|
|
}
|
|
|
|
private:
|
|
Common::UUID guid;
|
|
int port;
|
|
std::unique_ptr<SDL_Joystick, decltype(&SDL_CloseJoystick)> sdl_joystick;
|
|
std::unique_ptr<SDL_Gamepad, decltype(&SDL_CloseGamepad)> sdl_gamepad;
|
|
mutable std::mutex mutex;
|
|
|
|
u64 last_motion_update{};
|
|
std::size_t motion_error_count{};
|
|
bool has_gyro{false};
|
|
bool has_accel{false};
|
|
bool has_vibration{false};
|
|
bool is_vibration_tested{false};
|
|
BasicMotion motion;
|
|
};
|
|
|
|
std::shared_ptr<SDLJoystick> SDLDriver::GetSDLJoystickByGUID(const Common::UUID& guid, int port) {
|
|
std::scoped_lock lock{joystick_map_mutex};
|
|
const auto it = joystick_map.find(guid);
|
|
|
|
if (it != joystick_map.end()) {
|
|
while (it->second.size() <= static_cast<std::size_t>(port)) {
|
|
auto joystick = std::make_shared<SDLJoystick>(guid, static_cast<int>(it->second.size()),
|
|
nullptr, nullptr);
|
|
it->second.emplace_back(std::move(joystick));
|
|
}
|
|
|
|
return it->second[static_cast<std::size_t>(port)];
|
|
}
|
|
|
|
auto joystick = std::make_shared<SDLJoystick>(guid, 0, nullptr, nullptr);
|
|
|
|
return joystick_map[guid].emplace_back(std::move(joystick));
|
|
}
|
|
|
|
std::shared_ptr<SDLJoystick> SDLDriver::GetSDLJoystickByGUID(const std::string& guid, int port) {
|
|
return GetSDLJoystickByGUID(Common::UUID{guid}, port);
|
|
}
|
|
|
|
std::shared_ptr<SDLJoystick> SDLDriver::GetSDLJoystickBySDLID(SDL_JoystickID sdl_id) {
|
|
auto sdl_joystick = SDL_GetJoystickFromID(sdl_id);
|
|
const auto guid = GetGUID(sdl_joystick);
|
|
|
|
std::scoped_lock lock{joystick_map_mutex};
|
|
const auto map_it = joystick_map.find(guid);
|
|
|
|
if (map_it == joystick_map.end()) {
|
|
return nullptr;
|
|
}
|
|
|
|
const auto vec_it = std::find_if(map_it->second.begin(), map_it->second.end(),
|
|
[&sdl_joystick](const auto& joystick) {
|
|
return joystick->GetSDLJoystick() == sdl_joystick;
|
|
});
|
|
|
|
if (vec_it == map_it->second.end()) {
|
|
return nullptr;
|
|
}
|
|
|
|
return *vec_it;
|
|
}
|
|
|
|
void SDLDriver::InitJoystick(SDL_JoystickID joystick_id) {
|
|
SDL_Joystick* sdl_joystick = SDL_OpenJoystick(joystick_id);
|
|
SDL_Gamepad* sdl_gamepad = nullptr;
|
|
|
|
if (SDL_IsGamepad(joystick_id)) {
|
|
sdl_gamepad = SDL_OpenGamepad(joystick_id);
|
|
}
|
|
|
|
if (!sdl_joystick) {
|
|
LOG_ERROR(Input, "Failed to open joystick {}", joystick_id);
|
|
return;
|
|
}
|
|
|
|
const auto guid = GetGUID(sdl_joystick);
|
|
|
|
if (Settings::values.enable_joycon_driver) {
|
|
if (guid.uuid[5] == 0x05 && guid.uuid[4] == 0x7e &&
|
|
(guid.uuid[8] == 0x06 || guid.uuid[8] == 0x07)) {
|
|
LOG_WARNING(Input, "Preferring joycon driver for device ID {}", joystick_id);
|
|
SDL_CloseJoystick(sdl_joystick);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (Settings::values.enable_procon_driver) {
|
|
if (guid.uuid[5] == 0x05 && guid.uuid[4] == 0x7e && guid.uuid[8] == 0x09) {
|
|
LOG_WARNING(Input, "Preferring joycon driver for device ID {}", joystick_id);
|
|
SDL_CloseJoystick(sdl_joystick);
|
|
return;
|
|
}
|
|
}
|
|
|
|
std::scoped_lock lock{joystick_map_mutex};
|
|
if (joystick_map.find(guid) == joystick_map.end()) {
|
|
auto joystick = std::make_shared<SDLJoystick>(guid, 0, sdl_joystick, sdl_gamepad);
|
|
PreSetController(joystick->GetPadIdentifier());
|
|
joystick->EnableMotion();
|
|
joystick_map[guid].emplace_back(std::move(joystick));
|
|
return;
|
|
}
|
|
|
|
auto& joystick_guid_list = joystick_map[guid];
|
|
const auto joystick_it =
|
|
std::find_if(joystick_guid_list.begin(), joystick_guid_list.end(),
|
|
[](const auto& joystick) { return !joystick->GetSDLJoystick(); });
|
|
|
|
if (joystick_it != joystick_guid_list.end()) {
|
|
(*joystick_it)->SetSDLJoystick(sdl_joystick, sdl_gamepad);
|
|
(*joystick_it)->EnableMotion();
|
|
return;
|
|
}
|
|
|
|
const int port = static_cast<int>(joystick_guid_list.size());
|
|
auto joystick = std::make_shared<SDLJoystick>(guid, port, sdl_joystick, sdl_gamepad);
|
|
PreSetController(joystick->GetPadIdentifier());
|
|
joystick->EnableMotion();
|
|
joystick_guid_list.emplace_back(std::move(joystick));
|
|
}
|
|
|
|
void SDLDriver::CloseJoystick(SDL_Joystick* sdl_joystick) {
|
|
const auto guid = GetGUID(sdl_joystick);
|
|
|
|
std::scoped_lock lock{joystick_map_mutex};
|
|
const auto& joystick_guid_list = joystick_map[guid];
|
|
const auto joystick_it = std::find_if(joystick_guid_list.begin(), joystick_guid_list.end(),
|
|
[&sdl_joystick](const auto& joystick) {
|
|
return joystick->GetSDLJoystick() == sdl_joystick;
|
|
});
|
|
|
|
if (joystick_it != joystick_guid_list.end()) {
|
|
(*joystick_it)->SetSDLJoystick(nullptr, nullptr);
|
|
}
|
|
}
|
|
|
|
void SDLDriver::PumpEvents() const {
|
|
if (initialized) {
|
|
SDL_PumpEvents();
|
|
}
|
|
}
|
|
|
|
void SDLDriver::HandleGameControllerEvent(const SDL_Event& event) {
|
|
switch (event.type) {
|
|
case SDL_EVENT_JOYSTICK_BUTTON_UP: {
|
|
if (const auto joystick = GetSDLJoystickBySDLID(event.jbutton.which)) {
|
|
const PadIdentifier identifier = joystick->GetPadIdentifier();
|
|
SetButton(identifier, event.jbutton.button, false);
|
|
}
|
|
break;
|
|
}
|
|
case SDL_EVENT_JOYSTICK_BUTTON_DOWN: {
|
|
if (const auto joystick = GetSDLJoystickBySDLID(event.jbutton.which)) {
|
|
const PadIdentifier identifier = joystick->GetPadIdentifier();
|
|
SetButton(identifier, event.jbutton.button, true);
|
|
}
|
|
break;
|
|
}
|
|
case SDL_EVENT_JOYSTICK_HAT_MOTION: {
|
|
if (const auto joystick = GetSDLJoystickBySDLID(event.jhat.which)) {
|
|
const PadIdentifier identifier = joystick->GetPadIdentifier();
|
|
SetHatButton(identifier, event.jhat.hat, event.jhat.value);
|
|
}
|
|
break;
|
|
}
|
|
case SDL_EVENT_JOYSTICK_AXIS_MOTION: {
|
|
if (const auto joystick = GetSDLJoystickBySDLID(event.jaxis.which)) {
|
|
const PadIdentifier identifier = joystick->GetPadIdentifier();
|
|
SetAxis(identifier, event.jaxis.axis, event.jaxis.value / 32767.0f);
|
|
}
|
|
break;
|
|
}
|
|
case SDL_EVENT_GAMEPAD_SENSOR_UPDATE: {
|
|
if (auto joystick = GetSDLJoystickBySDLID(event.gsensor.which)) {
|
|
if (joystick->UpdateMotion(event.gsensor)) {
|
|
const PadIdentifier identifier = joystick->GetPadIdentifier();
|
|
SetMotion(identifier, 0, joystick->GetMotion());
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case SDL_EVENT_JOYSTICK_BATTERY_UPDATED: {
|
|
if (auto joystick = GetSDLJoystickBySDLID(event.jbattery.which)) {
|
|
const PadIdentifier identifier = joystick->GetPadIdentifier();
|
|
SetBattery(identifier, joystick->GetBatteryLevel(event.jbattery.state));
|
|
}
|
|
break;
|
|
}
|
|
case SDL_EVENT_JOYSTICK_REMOVED:
|
|
LOG_DEBUG(Input, "Controller removed with Instance_ID {}", event.jdevice.which);
|
|
CloseJoystick(SDL_GetJoystickFromID(event.jdevice.which));
|
|
break;
|
|
case SDL_EVENT_JOYSTICK_ADDED:
|
|
LOG_DEBUG(Input, "Controller connected with device ID {}", event.jdevice.which);
|
|
InitJoystick(event.jdevice.which);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void SDLDriver::CloseJoysticks() {
|
|
std::scoped_lock lock{joystick_map_mutex};
|
|
joystick_map.clear();
|
|
}
|
|
|
|
SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
|
|
SDL_SetHint(SDL_HINT_APP_NAME, "Eden");
|
|
|
|
if (!Settings::values.enable_raw_input) {
|
|
SDL_SetHint(SDL_HINT_JOYSTICK_RAWINPUT, "0");
|
|
}
|
|
|
|
// SDL_HINT_ACCELEROMETER_AS_JOYSTICK was removed in SDL3
|
|
// SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE and SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE were removed in
|
|
// SDL3 These are now handled by SDL_HINT_JOYSTICK_ENHANCED_REPORTS
|
|
SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1");
|
|
|
|
if (Settings::values.enable_joycon_driver) {
|
|
SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, "0");
|
|
} else {
|
|
SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, "1");
|
|
SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_JOYCON_HOME_LED, "0");
|
|
SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_COMBINE_JOY_CONS, "0");
|
|
SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_VERTICAL_JOY_CONS, "1");
|
|
}
|
|
|
|
if (Settings::values.enable_procon_driver) {
|
|
SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_SWITCH, "0");
|
|
} else {
|
|
SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_SWITCH, "1");
|
|
SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED, "0");
|
|
}
|
|
|
|
SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_SWITCH_PLAYER_LED, "1");
|
|
// SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS was removed in SDL3
|
|
SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_XBOX, "0");
|
|
|
|
start_thread = !SDL_WasInit(SDL_INIT_JOYSTICK | SDL_INIT_GAMEPAD);
|
|
if (start_thread && !SDL_Init(SDL_INIT_JOYSTICK | SDL_INIT_GAMEPAD)) {
|
|
LOG_CRITICAL(Input, "SDL_Init failed with: {}", SDL_GetError());
|
|
return;
|
|
}
|
|
|
|
SDL_AddEventWatch(&SDLEventWatcher, this);
|
|
|
|
initialized = true;
|
|
if (start_thread) {
|
|
vibration_thread = std::thread([this] {
|
|
Common::SetCurrentThreadName("SDL_Vibration");
|
|
using namespace std::chrono_literals;
|
|
while (initialized) {
|
|
SendVibrations();
|
|
std::this_thread::sleep_for(10ms);
|
|
}
|
|
});
|
|
}
|
|
|
|
int num_joysticks;
|
|
SDL_JoystickID* joysticks = SDL_GetJoysticks(&num_joysticks);
|
|
if (joysticks) {
|
|
for (int i = 0; i < num_joysticks; ++i) {
|
|
InitJoystick(joysticks[i]);
|
|
}
|
|
SDL_free(joysticks);
|
|
}
|
|
}
|
|
|
|
SDLDriver::~SDLDriver() {
|
|
CloseJoysticks();
|
|
SDL_RemoveEventWatch(&SDLEventWatcher, this);
|
|
|
|
initialized = false;
|
|
if (start_thread) {
|
|
vibration_thread.join();
|
|
SDL_QuitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_GAMEPAD);
|
|
}
|
|
}
|
|
|
|
std::vector<Common::ParamPackage> SDLDriver::GetInputDevices() const {
|
|
std::vector<Common::ParamPackage> devices;
|
|
std::unordered_map<int, std::shared_ptr<SDLJoystick>> joycon_pairs;
|
|
for (const auto& [key, value] : joystick_map) {
|
|
for (const auto& joystick : value) {
|
|
if (!joystick->GetSDLJoystick()) {
|
|
continue;
|
|
}
|
|
const std::string name =
|
|
fmt::format("{} {}", joystick->GetControllerName(), joystick->GetPort());
|
|
devices.emplace_back(Common::ParamPackage{
|
|
{"engine", GetEngineName()},
|
|
{"display", std::move(name)},
|
|
{"guid", joystick->GetGUID().RawString()},
|
|
{"port", std::to_string(joystick->GetPort())},
|
|
});
|
|
if (joystick->IsJoyconLeft()) {
|
|
joycon_pairs.insert_or_assign(joystick->GetPort(), joystick);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const auto& [key, value] : joystick_map) {
|
|
for (const auto& joystick : value) {
|
|
if (joystick->IsJoyconRight()) {
|
|
if (!joycon_pairs.contains(joystick->GetPort())) {
|
|
continue;
|
|
}
|
|
const auto joystick2 = joycon_pairs.at(joystick->GetPort());
|
|
|
|
const std::string name =
|
|
fmt::format("{} {}", "Nintendo Dual Joy-Con", joystick->GetPort());
|
|
devices.emplace_back(Common::ParamPackage{
|
|
{"engine", GetEngineName()},
|
|
{"display", std::move(name)},
|
|
{"guid", joystick->GetGUID().RawString()},
|
|
{"guid2", joystick2->GetGUID().RawString()},
|
|
{"port", std::to_string(joystick->GetPort())},
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return devices;
|
|
}
|
|
|
|
Common::Input::DriverResult SDLDriver::SetVibration(
|
|
const PadIdentifier& identifier, const Common::Input::VibrationStatus& vibration) {
|
|
const auto joystick =
|
|
GetSDLJoystickByGUID(identifier.guid.RawString(), static_cast<int>(identifier.port));
|
|
const auto process_amplitude_exp = [](f32 amplitude, f32 factor) {
|
|
return (amplitude + std::pow(amplitude, factor)) * 0.5f * 0xFFFF;
|
|
};
|
|
|
|
f32 factor = 0.35f;
|
|
|
|
if (vibration.type == Common::Input::VibrationAmplificationType::Linear) {
|
|
factor = 0.5f;
|
|
}
|
|
|
|
if (joystick->HasHDRumble()) {
|
|
factor = 1.0f;
|
|
}
|
|
|
|
const Common::Input::VibrationStatus new_vibration{
|
|
.low_amplitude = process_amplitude_exp(vibration.low_amplitude, factor),
|
|
.low_frequency = vibration.low_frequency,
|
|
.high_amplitude = process_amplitude_exp(vibration.high_amplitude, factor),
|
|
.high_frequency = vibration.high_frequency,
|
|
.type = Common::Input::VibrationAmplificationType::Exponential,
|
|
};
|
|
|
|
vibration_queue.Push(VibrationRequest{
|
|
.identifier = identifier,
|
|
.vibration = new_vibration,
|
|
});
|
|
|
|
return Common::Input::DriverResult::Success;
|
|
}
|
|
|
|
bool SDLDriver::IsVibrationEnabled(const PadIdentifier& identifier) {
|
|
const auto joystick =
|
|
GetSDLJoystickByGUID(identifier.guid.RawString(), static_cast<int>(identifier.port));
|
|
|
|
static constexpr Common::Input::VibrationStatus test_vibration{
|
|
.low_amplitude = 1,
|
|
.low_frequency = 160.0f,
|
|
.high_amplitude = 1,
|
|
.high_frequency = 320.0f,
|
|
.type = Common::Input::VibrationAmplificationType::Exponential,
|
|
};
|
|
|
|
static constexpr Common::Input::VibrationStatus zero_vibration{
|
|
.low_amplitude = 0,
|
|
.low_frequency = 160.0f,
|
|
.high_amplitude = 0,
|
|
.high_frequency = 320.0f,
|
|
.type = Common::Input::VibrationAmplificationType::Exponential,
|
|
};
|
|
|
|
if (joystick->IsVibrationTested()) {
|
|
return joystick->HasVibration();
|
|
}
|
|
|
|
joystick->RumblePlay(test_vibration);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(15));
|
|
|
|
if (!joystick->RumblePlay(zero_vibration)) {
|
|
joystick->EnableVibration(false);
|
|
return false;
|
|
}
|
|
|
|
joystick->EnableVibration(true);
|
|
return true;
|
|
}
|
|
|
|
void SDLDriver::SendVibrations() {
|
|
std::vector<VibrationRequest> filtered_vibrations{};
|
|
while (!vibration_queue.Empty()) {
|
|
VibrationRequest request;
|
|
vibration_queue.Pop(request);
|
|
const auto joystick = GetSDLJoystickByGUID(request.identifier.guid.RawString(),
|
|
static_cast<int>(request.identifier.port));
|
|
const auto it = std::find_if(filtered_vibrations.begin(), filtered_vibrations.end(),
|
|
[request](VibrationRequest vibration) {
|
|
return vibration.identifier == request.identifier;
|
|
});
|
|
if (it == filtered_vibrations.end()) {
|
|
filtered_vibrations.push_back(std::move(request));
|
|
continue;
|
|
}
|
|
*it = request;
|
|
}
|
|
|
|
for (const auto& vibration : filtered_vibrations) {
|
|
const auto joystick = GetSDLJoystickByGUID(vibration.identifier.guid.RawString(),
|
|
static_cast<int>(vibration.identifier.port));
|
|
joystick->RumblePlay(vibration.vibration);
|
|
}
|
|
}
|
|
|
|
Common::ParamPackage SDLDriver::BuildAnalogParamPackageForButton(int port, const Common::UUID& guid,
|
|
s32 axis, float value) const {
|
|
Common::ParamPackage params{};
|
|
params.Set("engine", GetEngineName());
|
|
params.Set("port", port);
|
|
params.Set("guid", guid.RawString());
|
|
params.Set("axis", axis);
|
|
params.Set("threshold", "0.5");
|
|
params.Set("invert", value < 0 ? "-" : "+");
|
|
return params;
|
|
}
|
|
|
|
Common::ParamPackage SDLDriver::BuildButtonParamPackageForButton(int port, const Common::UUID& guid,
|
|
s32 button) const {
|
|
Common::ParamPackage params{};
|
|
params.Set("engine", GetEngineName());
|
|
params.Set("port", port);
|
|
params.Set("guid", guid.RawString());
|
|
params.Set("button", button);
|
|
return params;
|
|
}
|
|
|
|
Common::ParamPackage SDLDriver::BuildHatParamPackageForButton(int port, const Common::UUID& guid,
|
|
s32 hat, u8 value) const {
|
|
Common::ParamPackage params{};
|
|
params.Set("engine", GetEngineName());
|
|
params.Set("port", port);
|
|
params.Set("guid", guid.RawString());
|
|
params.Set("hat", hat);
|
|
params.Set("direction", GetHatButtonName(value));
|
|
return params;
|
|
}
|
|
|
|
Common::ParamPackage SDLDriver::BuildMotionParam(int port, const Common::UUID& guid) const {
|
|
Common::ParamPackage params{};
|
|
params.Set("engine", GetEngineName());
|
|
params.Set("motion", 0);
|
|
params.Set("port", port);
|
|
params.Set("guid", guid.RawString());
|
|
return params;
|
|
}
|
|
|
|
Common::ParamPackage SDLDriver::BuildParamPackageForBinding(
|
|
int port, const Common::UUID& guid, const SDL_GamepadBinding& binding) const {
|
|
switch (binding.input_type) {
|
|
case SDL_GAMEPAD_BINDTYPE_NONE:
|
|
break;
|
|
case SDL_GAMEPAD_BINDTYPE_AXIS:
|
|
return BuildAnalogParamPackageForButton(port, guid, binding.input.axis.axis);
|
|
case SDL_GAMEPAD_BINDTYPE_BUTTON:
|
|
return BuildButtonParamPackageForButton(port, guid, binding.input.button);
|
|
case SDL_GAMEPAD_BINDTYPE_HAT:
|
|
return BuildHatParamPackageForButton(port, guid, binding.input.hat.hat,
|
|
static_cast<u8>(binding.input.hat.hat_mask));
|
|
}
|
|
return {};
|
|
}
|
|
|
|
Common::ParamPackage SDLDriver::BuildParamPackageForAnalog(PadIdentifier identifier, int axis_x,
|
|
int axis_y, float offset_x,
|
|
float offset_y) const {
|
|
Common::ParamPackage params;
|
|
params.Set("engine", GetEngineName());
|
|
params.Set("port", static_cast<int>(identifier.port));
|
|
params.Set("guid", identifier.guid.RawString());
|
|
params.Set("axis_x", axis_x);
|
|
params.Set("axis_y", axis_y);
|
|
params.Set("offset_x", offset_x);
|
|
params.Set("offset_y", offset_y);
|
|
params.Set("invert_x", "+");
|
|
params.Set("invert_y", "+");
|
|
return params;
|
|
}
|
|
|
|
ButtonMapping SDLDriver::GetButtonMappingForDevice(const Common::ParamPackage& params) {
|
|
if (!params.Has("guid") || !params.Has("port")) {
|
|
return {};
|
|
}
|
|
const auto joystick = GetSDLJoystickByGUID(params.Get("guid", ""), params.Get("port", 0));
|
|
|
|
auto* gamepad = joystick->GetSDLGamepad();
|
|
if (gamepad == nullptr) {
|
|
return {};
|
|
}
|
|
|
|
ButtonBindings switch_to_sdl_button;
|
|
switch_to_sdl_button = GetDefaultButtonBinding(joystick);
|
|
|
|
static constexpr ZButtonBindings switch_to_sdl_axis{{
|
|
{Settings::NativeButton::ZL, SDL_GAMEPAD_AXIS_LEFT_TRIGGER},
|
|
{Settings::NativeButton::ZR, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER},
|
|
}};
|
|
|
|
if (params.Has("guid2")) {
|
|
const auto joystick2 = GetSDLJoystickByGUID(params.Get("guid2", ""), params.Get("port", 0));
|
|
|
|
if (joystick2->GetSDLGamepad() != nullptr) {
|
|
return GetDualControllerMapping(joystick, joystick2, switch_to_sdl_button,
|
|
switch_to_sdl_axis);
|
|
}
|
|
}
|
|
|
|
return GetSingleControllerMapping(joystick, switch_to_sdl_button, switch_to_sdl_axis);
|
|
}
|
|
|
|
ButtonBindings SDLDriver::GetDefaultButtonBinding(
|
|
const std::shared_ptr<SDLJoystick>& joystick) const {
|
|
auto sll_button = SDL_GAMEPAD_BUTTON_LEFT_SHOULDER;
|
|
auto srl_button = SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER;
|
|
auto slr_button = SDL_GAMEPAD_BUTTON_LEFT_SHOULDER;
|
|
auto srr_button = SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER;
|
|
|
|
if (joystick->IsJoyconLeft()) {
|
|
sll_button = SDL_GAMEPAD_BUTTON_LEFT_PADDLE1;
|
|
srl_button = SDL_GAMEPAD_BUTTON_LEFT_PADDLE2;
|
|
}
|
|
if (joystick->IsJoyconRight()) {
|
|
slr_button = SDL_GAMEPAD_BUTTON_RIGHT_PADDLE2;
|
|
srr_button = SDL_GAMEPAD_BUTTON_RIGHT_PADDLE1;
|
|
}
|
|
|
|
return {
|
|
std::pair{Settings::NativeButton::A, SDL_GAMEPAD_BUTTON_EAST},
|
|
{Settings::NativeButton::B, SDL_GAMEPAD_BUTTON_SOUTH},
|
|
{Settings::NativeButton::X, SDL_GAMEPAD_BUTTON_NORTH},
|
|
{Settings::NativeButton::Y, SDL_GAMEPAD_BUTTON_WEST},
|
|
{Settings::NativeButton::LStick, SDL_GAMEPAD_BUTTON_LEFT_STICK},
|
|
{Settings::NativeButton::RStick, SDL_GAMEPAD_BUTTON_RIGHT_STICK},
|
|
{Settings::NativeButton::L, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER},
|
|
{Settings::NativeButton::R, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER},
|
|
{Settings::NativeButton::Plus, SDL_GAMEPAD_BUTTON_START},
|
|
{Settings::NativeButton::Minus, SDL_GAMEPAD_BUTTON_BACK},
|
|
{Settings::NativeButton::DLeft, SDL_GAMEPAD_BUTTON_DPAD_LEFT},
|
|
{Settings::NativeButton::DUp, SDL_GAMEPAD_BUTTON_DPAD_UP},
|
|
{Settings::NativeButton::DRight, SDL_GAMEPAD_BUTTON_DPAD_RIGHT},
|
|
{Settings::NativeButton::DDown, SDL_GAMEPAD_BUTTON_DPAD_DOWN},
|
|
{Settings::NativeButton::SLLeft, sll_button},
|
|
{Settings::NativeButton::SRLeft, srl_button},
|
|
{Settings::NativeButton::SLRight, slr_button},
|
|
{Settings::NativeButton::SRRight, srr_button},
|
|
{Settings::NativeButton::Home, SDL_GAMEPAD_BUTTON_GUIDE},
|
|
{Settings::NativeButton::Screenshot, SDL_GAMEPAD_BUTTON_MISC1},
|
|
};
|
|
}
|
|
|
|
ButtonMapping SDLDriver::GetSingleControllerMapping(
|
|
const std::shared_ptr<SDLJoystick>& joystick, const ButtonBindings& switch_to_sdl_button,
|
|
const ZButtonBindings& switch_to_sdl_axis) const {
|
|
ButtonMapping mapping;
|
|
mapping.reserve(switch_to_sdl_button.size() + switch_to_sdl_axis.size());
|
|
|
|
for (const auto& [switch_button, sdl_button] : switch_to_sdl_button) {
|
|
// SDL_GetGamepadBindForButton was removed in SDL3
|
|
// We need to use SDL_GetGamepadStringForButton or work with joystick directly
|
|
// For now, create a dummy binding
|
|
SDL_GamepadBinding binding{};
|
|
binding.input_type = SDL_GAMEPAD_BINDTYPE_BUTTON;
|
|
binding.input.button = sdl_button;
|
|
mapping.insert_or_assign(
|
|
switch_button,
|
|
BuildParamPackageForBinding(joystick->GetPort(), joystick->GetGUID(), binding));
|
|
}
|
|
for (const auto& [switch_button, sdl_axis] : switch_to_sdl_axis) {
|
|
// SDL_GetGamepadBindForAxis was removed in SDL3
|
|
// We need to use SDL_GetGamepadStringForAxis or work with joystick directly
|
|
// For now, create a dummy binding
|
|
SDL_GamepadBinding binding{};
|
|
binding.input_type = SDL_GAMEPAD_BINDTYPE_AXIS;
|
|
binding.input.axis.axis = sdl_axis;
|
|
mapping.insert_or_assign(
|
|
switch_button,
|
|
BuildParamPackageForBinding(joystick->GetPort(), joystick->GetGUID(), binding));
|
|
}
|
|
|
|
return mapping;
|
|
}
|
|
|
|
ButtonMapping SDLDriver::GetDualControllerMapping(const std::shared_ptr<SDLJoystick>& joystick,
|
|
const std::shared_ptr<SDLJoystick>& joystick2,
|
|
const ButtonBindings& switch_to_sdl_button,
|
|
const ZButtonBindings& switch_to_sdl_axis) const {
|
|
ButtonMapping mapping;
|
|
mapping.reserve(switch_to_sdl_button.size() + switch_to_sdl_axis.size());
|
|
|
|
for (const auto& [switch_button, sdl_button] : switch_to_sdl_button) {
|
|
if (IsButtonOnLeftSide(switch_button)) {
|
|
// SDL_GetGamepadBindForButton was removed in SDL3
|
|
SDL_GamepadBinding binding{};
|
|
binding.input_type = SDL_GAMEPAD_BINDTYPE_BUTTON;
|
|
binding.input.button = sdl_button;
|
|
mapping.insert_or_assign(
|
|
switch_button,
|
|
BuildParamPackageForBinding(joystick2->GetPort(), joystick2->GetGUID(), binding));
|
|
continue;
|
|
}
|
|
// SDL_GetGamepadBindForButton was removed in SDL3
|
|
SDL_GamepadBinding binding{};
|
|
binding.input_type = SDL_GAMEPAD_BINDTYPE_BUTTON;
|
|
binding.input.button = sdl_button;
|
|
mapping.insert_or_assign(
|
|
switch_button,
|
|
BuildParamPackageForBinding(joystick->GetPort(), joystick->GetGUID(), binding));
|
|
}
|
|
for (const auto& [switch_button, sdl_axis] : switch_to_sdl_axis) {
|
|
if (IsButtonOnLeftSide(switch_button)) {
|
|
// SDL_GetGamepadBindForAxis was removed in SDL3
|
|
SDL_GamepadBinding binding{};
|
|
binding.input_type = SDL_GAMEPAD_BINDTYPE_AXIS;
|
|
binding.input.axis.axis = sdl_axis;
|
|
mapping.insert_or_assign(
|
|
switch_button,
|
|
BuildParamPackageForBinding(joystick2->GetPort(), joystick2->GetGUID(), binding));
|
|
continue;
|
|
}
|
|
// SDL_GetGamepadBindForAxis was removed in SDL3
|
|
SDL_GamepadBinding binding{};
|
|
binding.input_type = SDL_GAMEPAD_BINDTYPE_AXIS;
|
|
binding.input.axis.axis = sdl_axis;
|
|
mapping.insert_or_assign(
|
|
switch_button,
|
|
BuildParamPackageForBinding(joystick->GetPort(), joystick->GetGUID(), binding));
|
|
}
|
|
|
|
return mapping;
|
|
}
|
|
|
|
bool SDLDriver::IsButtonOnLeftSide(Settings::NativeButton::Values button) const {
|
|
switch (button) {
|
|
case Settings::NativeButton::DDown:
|
|
case Settings::NativeButton::DLeft:
|
|
case Settings::NativeButton::DRight:
|
|
case Settings::NativeButton::DUp:
|
|
case Settings::NativeButton::L:
|
|
case Settings::NativeButton::LStick:
|
|
case Settings::NativeButton::Minus:
|
|
case Settings::NativeButton::Screenshot:
|
|
case Settings::NativeButton::ZL:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
AnalogMapping SDLDriver::GetAnalogMappingForDevice(const Common::ParamPackage& params) {
|
|
if (!params.Has("guid") || !params.Has("port")) {
|
|
return {};
|
|
}
|
|
const auto joystick = GetSDLJoystickByGUID(params.Get("guid", ""), params.Get("port", 0));
|
|
const auto joystick2 = GetSDLJoystickByGUID(params.Get("guid2", ""), params.Get("port", 0));
|
|
auto* gamepad = joystick->GetSDLGamepad();
|
|
if (gamepad == nullptr) {
|
|
return {};
|
|
}
|
|
|
|
AnalogMapping mapping = {};
|
|
// SDL_GetGamepadBindForAxis was removed in SDL3
|
|
// We need to work with the underlying joystick directly
|
|
SDL_Joystick* sdl_joystick = SDL_GetGamepadJoystick(gamepad);
|
|
if (!sdl_joystick) {
|
|
return {};
|
|
}
|
|
|
|
// For now, use hardcoded axis mappings
|
|
SDL_GamepadBinding binding_left_x{};
|
|
binding_left_x.input_type = SDL_GAMEPAD_BINDTYPE_AXIS;
|
|
binding_left_x.input.axis.axis = 0; // Left stick X
|
|
|
|
SDL_GamepadBinding binding_left_y{};
|
|
binding_left_y.input_type = SDL_GAMEPAD_BINDTYPE_AXIS;
|
|
binding_left_y.input.axis.axis = 1; // Left stick Y
|
|
|
|
if (params.Has("guid2")) {
|
|
const auto identifier = joystick2->GetPadIdentifier();
|
|
PreSetController(identifier);
|
|
PreSetAxis(identifier, binding_left_x.input.axis.axis);
|
|
PreSetAxis(identifier, binding_left_y.input.axis.axis);
|
|
const auto left_offset_x = -GetAxis(identifier, binding_left_x.input.axis.axis);
|
|
const auto left_offset_y = GetAxis(identifier, binding_left_y.input.axis.axis);
|
|
mapping.insert_or_assign(Settings::NativeAnalog::LStick,
|
|
BuildParamPackageForAnalog(
|
|
identifier, binding_left_x.input.axis.axis,
|
|
binding_left_y.input.axis.axis, left_offset_x, left_offset_y));
|
|
} else {
|
|
const auto identifier = joystick->GetPadIdentifier();
|
|
PreSetController(identifier);
|
|
PreSetAxis(identifier, binding_left_x.input.axis.axis);
|
|
PreSetAxis(identifier, binding_left_y.input.axis.axis);
|
|
const auto left_offset_x = -GetAxis(identifier, binding_left_x.input.axis.axis);
|
|
const auto left_offset_y = GetAxis(identifier, binding_left_y.input.axis.axis);
|
|
mapping.insert_or_assign(Settings::NativeAnalog::LStick,
|
|
BuildParamPackageForAnalog(
|
|
identifier, binding_left_x.input.axis.axis,
|
|
binding_left_y.input.axis.axis, left_offset_x, left_offset_y));
|
|
}
|
|
|
|
// For right stick
|
|
SDL_GamepadBinding binding_right_x{};
|
|
binding_right_x.input_type = SDL_GAMEPAD_BINDTYPE_AXIS;
|
|
binding_right_x.input.axis.axis = 2; // Right stick X
|
|
|
|
SDL_GamepadBinding binding_right_y{};
|
|
binding_right_y.input_type = SDL_GAMEPAD_BINDTYPE_AXIS;
|
|
binding_right_y.input.axis.axis = 3; // Right stick Y
|
|
const auto identifier = joystick->GetPadIdentifier();
|
|
PreSetController(identifier);
|
|
PreSetAxis(identifier, binding_right_x.input.axis.axis);
|
|
PreSetAxis(identifier, binding_right_y.input.axis.axis);
|
|
const auto right_offset_x = -GetAxis(identifier, binding_right_x.input.axis.axis);
|
|
const auto right_offset_y = GetAxis(identifier, binding_right_y.input.axis.axis);
|
|
mapping.insert_or_assign(Settings::NativeAnalog::RStick,
|
|
BuildParamPackageForAnalog(identifier, binding_right_x.input.axis.axis,
|
|
binding_right_y.input.axis.axis,
|
|
right_offset_x, right_offset_y));
|
|
return mapping;
|
|
}
|
|
|
|
MotionMapping SDLDriver::GetMotionMappingForDevice(const Common::ParamPackage& params) {
|
|
if (!params.Has("guid") || !params.Has("port")) {
|
|
return {};
|
|
}
|
|
const auto joystick = GetSDLJoystickByGUID(params.Get("guid", ""), params.Get("port", 0));
|
|
const auto joystick2 = GetSDLJoystickByGUID(params.Get("guid2", ""), params.Get("port", 0));
|
|
auto* gamepad = joystick->GetSDLGamepad();
|
|
if (gamepad == nullptr) {
|
|
return {};
|
|
}
|
|
|
|
MotionMapping mapping = {};
|
|
joystick->EnableMotion();
|
|
|
|
if (joystick->HasMotion()) {
|
|
mapping.insert_or_assign(Settings::NativeMotion::MotionRight,
|
|
BuildMotionParam(joystick->GetPort(), joystick->GetGUID()));
|
|
}
|
|
if (params.Has("guid2")) {
|
|
joystick2->EnableMotion();
|
|
if (joystick2->HasMotion()) {
|
|
mapping.insert_or_assign(Settings::NativeMotion::MotionLeft,
|
|
BuildMotionParam(joystick2->GetPort(), joystick2->GetGUID()));
|
|
}
|
|
} else {
|
|
if (joystick->HasMotion()) {
|
|
mapping.insert_or_assign(Settings::NativeMotion::MotionLeft,
|
|
BuildMotionParam(joystick->GetPort(), joystick->GetGUID()));
|
|
}
|
|
}
|
|
|
|
return mapping;
|
|
}
|
|
|
|
Common::Input::ButtonNames SDLDriver::GetUIName(const Common::ParamPackage& params) const {
|
|
if (params.Has("button")) {
|
|
return Common::Input::ButtonNames::Value;
|
|
}
|
|
if (params.Has("hat")) {
|
|
return Common::Input::ButtonNames::Value;
|
|
}
|
|
if (params.Has("axis")) {
|
|
return Common::Input::ButtonNames::Value;
|
|
}
|
|
if (params.Has("axis_x") && params.Has("axis_y") && params.Has("axis_z")) {
|
|
return Common::Input::ButtonNames::Value;
|
|
}
|
|
if (params.Has("motion")) {
|
|
return Common::Input::ButtonNames::Engine;
|
|
}
|
|
|
|
return Common::Input::ButtonNames::Invalid;
|
|
}
|
|
|
|
std::string SDLDriver::GetHatButtonName(u8 direction_value) const {
|
|
switch (direction_value) {
|
|
case SDL_HAT_UP:
|
|
return "up";
|
|
case SDL_HAT_DOWN:
|
|
return "down";
|
|
case SDL_HAT_LEFT:
|
|
return "left";
|
|
case SDL_HAT_RIGHT:
|
|
return "right";
|
|
default:
|
|
return {};
|
|
}
|
|
}
|
|
|
|
u8 SDLDriver::GetHatButtonId(const std::string& direction_name) const {
|
|
Uint8 direction;
|
|
if (direction_name == "up") {
|
|
direction = SDL_HAT_UP;
|
|
} else if (direction_name == "down") {
|
|
direction = SDL_HAT_DOWN;
|
|
} else if (direction_name == "left") {
|
|
direction = SDL_HAT_LEFT;
|
|
} else if (direction_name == "right") {
|
|
direction = SDL_HAT_RIGHT;
|
|
} else {
|
|
direction = 0;
|
|
}
|
|
return direction;
|
|
}
|
|
|
|
bool SDLDriver::IsStickInverted(const Common::ParamPackage& params) {
|
|
if (!params.Has("guid") || !params.Has("port")) {
|
|
return false;
|
|
}
|
|
const auto joystick = GetSDLJoystickByGUID(params.Get("guid", ""), params.Get("port", 0));
|
|
if (joystick == nullptr) {
|
|
return false;
|
|
}
|
|
auto* gamepad = joystick->GetSDLGamepad();
|
|
if (gamepad == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
const auto& axis_x = params.Get("axis_x", 0);
|
|
const auto& axis_y = params.Get("axis_y", 0);
|
|
// SDL_GetGamepadBindForAxis was removed in SDL3
|
|
// Use hardcoded axis mappings for now
|
|
const int binding_left_x = 0; // Left stick X
|
|
const int binding_right_x = 2; // Right stick X
|
|
const int binding_left_y = 1; // Left stick Y
|
|
const int binding_right_y = 3; // Right stick Y
|
|
|
|
if (axis_x != binding_left_y && axis_x != binding_right_y) {
|
|
return false;
|
|
}
|
|
if (axis_y != binding_left_x && axis_y != binding_right_x) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
} // namespace InputCommon
|