piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-06-28 09:59:32 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #13694 from jordan-woyak/sdl3

Browse Source 
Update to SDL3
This commit is contained in:
JMC47
2025-06-24 18:59:48 -04:00
committed by GitHub
parent 43c156084b 6da3f5f26a
commit 43aa7e9b96
15 changed files with 426 additions and 399 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
Source/Core/InputCommon/ControllerInterface/SDL/SDL.cpp
View File

@ -3,6 +3,7 @@
#include "InputCommon/ControllerInterface/SDL/SDL.h"
#include <span>
#include <thread>
#include <vector>
@ -10,7 +11,7 @@
#include <Windows.h>
#endif
#include <SDL.h>
#include <SDL3/SDL.h>
#include "Common/Event.h"
#include "Common/Logging/Log.h"
@ -31,7 +32,7 @@ public:
void UpdateInput(std::vector<std::weak_ptr<ciface::Core::Device>>& devices_to_remove) override;
private:
void OpenAndAddDevice(int index);
void OpenAndAddDevice(SDL_JoystickID instance_id);
bool HandleEventAndContinue(const SDL_Event& e);
@ -48,10 +49,10 @@ std::unique_ptr<ciface::InputBackend> CreateInputBackend(ControllerInterface* co
static void EnableSDLLogging()
{
SDL_LogSetAllPriority(SDL_LOG_PRIORITY_VERBOSE);
SDL_LogSetOutputFunction(
SDL_SetLogPriorities(SDL_LOG_PRIORITY_VERBOSE);
SDL_SetLogOutputFunction(
[](void*, int category, SDL_LogPriority priority, const char* message) {
std::string category_name;
std::string_view category_name{};
switch (category)
{
case SDL_LOG_CATEGORY_APPLICATION:
@ -81,8 +82,10 @@ static void EnableSDLLogging()
case SDL_LOG_CATEGORY_TEST:
category_name = "test";
break;
case SDL_LOG_CATEGORY_GPU:
category_name = "gpu";
break;
default:
category_name = fmt::format("unknown({})", category);
break;
}
@ -108,8 +111,16 @@ static void EnableSDLLogging()
break;
}
GENERIC_LOG_FMT(Common::Log::LogType::CONTROLLERINTERFACE, log_level, "{}: {}",
category_name, message);
if (category_name.empty())
{
GENERIC_LOG_FMT(Common::Log::LogType::CONTROLLERINTERFACE, log_level, "unknown({}): {}",
category, message);
}
else
{
GENERIC_LOG_FMT(Common::Log::LogType::CONTROLLERINTERFACE, log_level, "{}: {}",
category_name, message);
}
},
nullptr);
}
@ -122,9 +133,8 @@ InputBackend::InputBackend(ControllerInterface* controller_interface)
// This is required on windows so that SDL's joystick code properly pumps window messages
SDL_SetHint(SDL_HINT_JOYSTICK_THREAD, "1");
SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE, "1");
// We want buttons to come in as positions, not labels
SDL_SetHint(SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS, "0");
SDL_SetHint(SDL_HINT_JOYSTICK_ENHANCED_REPORTS, "1");
// We have our own WGI backend. Enabling SDL's WGI handling creates even more redundant devices.
SDL_SetHint(SDL_HINT_JOYSTICK_WGI, "0");
@ -139,7 +149,7 @@ InputBackend::InputBackend(ControllerInterface* controller_interface)
{
Common::ScopeGuard init_guard([this] { m_init_event.Set(); });
if (SDL_Init(SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMECONTROLLER) != 0)
if (!SDL_Init(SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMEPAD))
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "SDL failed to initialize");
return;
@ -160,7 +170,7 @@ InputBackend::InputBackend(ControllerInterface* controller_interface)
// duplicate devices. Adding devices will actually "fail" here, as the ControllerInterface
// hasn't finished initializing yet.
SDL_Event e;
while (SDL_PollEvent(&e) != 0)
while (SDL_PollEvent(&e))
{
if (!HandleEventAndContinue(e))
return;
@ -179,7 +189,7 @@ InputBackend::InputBackend(ControllerInterface* controller_interface)
#endif
SDL_Event e;
while (SDL_WaitEvent(&e) != 0)
while (SDL_WaitEvent(&e))
{
if (!HandleEventAndContinue(e))
return;
@ -221,20 +231,20 @@ void InputBackend::PopulateDevices()
SDL_PushEvent(&populate_event);
}
void InputBackend::UpdateInput(std::vector<std::weak_ptr<ciface::Core::Device>>& devices_to_remove)
void InputBackend::UpdateInput(std::vector<std::weak_ptr<ciface::Core::Device>>&)
{
SDL_GameControllerUpdate();
SDL_UpdateGamepads();
}
void InputBackend::OpenAndAddDevice(int index)
void InputBackend::OpenAndAddDevice(SDL_JoystickID instance_id)
{
SDL_GameController* gc = SDL_GameControllerOpen(index);
SDL_Joystick* js = SDL_JoystickOpen(index);
SDL_Gamepad* gc = SDL_OpenGamepad(instance_id);
SDL_Joystick* js = SDL_OpenJoystick(instance_id);
if (js)
if (js != nullptr)
{
if (SDL_JoystickNumButtons(js) > 255 || SDL_JoystickNumAxes(js) > 255 ||
SDL_JoystickNumHats(js) > 255 || SDL_JoystickNumBalls(js) > 255)
if (SDL_GetNumJoystickButtons(js) > 255 || SDL_GetNumJoystickAxes(js) > 255 ||
SDL_GetNumJoystickHats(js) > 255 || SDL_GetNumJoystickBalls(js) > 255)
{
// This device is invalid, don't use it
// Some crazy devices (HP webcam 2100) end up as HID devices
@ -249,17 +259,12 @@ void InputBackend::OpenAndAddDevice(int index)
bool InputBackend::HandleEventAndContinue(const SDL_Event& e)
{
if (e.type == SDL_JOYDEVICEADDED)
if (e.type == SDL_EVENT_JOYSTICK_ADDED)
{
// NOTE: SDL_JOYDEVICEADDED's `jdevice.which` is a device index in SDL2.
// It will change to an "instance ID" in SDL3.
// OpenAndAddDevice impl and calls will need refactoring when changing to SDL3.
static_assert(!SDL_VERSION_ATLEAST(3, 0, 0), "Refactoring is needed for SDL3.");
OpenAndAddDevice(e.jdevice.which);
}
else if (e.type == SDL_JOYDEVICEREMOVED)
else if (e.type == SDL_EVENT_JOYSTICK_REMOVED)
{
// NOTE: SDL_JOYDEVICEREMOVED's `jdevice.which` is an "instance ID".
GetControllerInterface().RemoveDevice([&e](const auto* device) {
return device->GetSource() == "SDL" &&
static_cast<const GameController*>(device)->GetSDLInstanceID() == e.jdevice.which;
@ -268,8 +273,12 @@ bool InputBackend::HandleEventAndContinue(const SDL_Event& e)
else if (e.type == m_populate_event_type)
{
GetControllerInterface().PlatformPopulateDevices([this] {
for (int i = 0; i < SDL_NumJoysticks(); ++i)
OpenAndAddDevice(i);
int joystick_count = 0;
auto* const joystick_ids = SDL_GetJoysticks(&joystick_count);
for (auto instance_id : std::span(joystick_ids, joystick_count))
OpenAndAddDevice(instance_id);
SDL_free(joystick_ids);
});
}
else if (e.type == m_stop_event_type)

191
Source/Core/InputCommon/ControllerInterface/SDL/SDLGamepad.cpp
View File

@ -4,9 +4,11 @@
#include "InputCommon/ControllerInterface/SDL/SDLGamepad.h"
#include <array>
#include <span>
#include <unordered_set>
#include "Common/Logging/Log.h"
#include "Common/ScopeGuard.h"
namespace ciface::SDL
{
@ -17,16 +19,12 @@ bool IsTriggerAxis(int index)
return index >= 4;
}
GameController::GameController(SDL_GameController* const gamecontroller,
SDL_Joystick* const joystick)
GameController::GameController(SDL_Gamepad* const gamecontroller, SDL_Joystick* const joystick)
: m_gamecontroller(gamecontroller), m_joystick(joystick)
{
const char* name;
if (gamecontroller)
name = SDL_GameControllerName(gamecontroller);
else
name = SDL_JoystickName(joystick);
m_name = name != nullptr ? name : "Unknown";
const char* const sdl_name = (gamecontroller != nullptr) ? SDL_GetGamepadName(gamecontroller) :
SDL_GetJoystickName(joystick);
m_name = (sdl_name != nullptr) ? sdl_name : "Unknown";
// If a Joystick input has a GameController equivalent button/hat we don't add it.
// "Equivalent" axes are still added as hidden/undetectable inputs to handle
@ -35,17 +33,17 @@ GameController::GameController(SDL_GameController* const gamecontroller,
std::unordered_set<int> registered_buttons;
std::unordered_set<int> registered_hats;
std::unordered_set<int> registered_axes;
const auto register_mapping = [&](const SDL_GameControllerButtonBind& bind) {
switch (bind.bindType)
const auto register_mapping = [&](const SDL_GamepadBinding& bind) {
switch (bind.input_type)
{
case SDL_CONTROLLER_BINDTYPE_BUTTON:
registered_buttons.insert(bind.value.button);
case SDL_GAMEPAD_BINDTYPE_BUTTON:
registered_buttons.insert(bind.input.button);
break;
case SDL_CONTROLLER_BINDTYPE_HAT:
registered_hats.insert(bind.value.hat.hat);
case SDL_GAMEPAD_BINDTYPE_HAT:
registered_hats.insert(bind.input.hat.hat);
break;
case SDL_CONTROLLER_BINDTYPE_AXIS:
registered_axes.insert(bind.value.axis);
case SDL_GAMEPAD_BINDTYPE_AXIS:
registered_axes.insert(bind.input.axis.axis);
break;
default:
break;
@ -55,25 +53,22 @@ GameController::GameController(SDL_GameController* const gamecontroller,
if (gamecontroller != nullptr)
{
// Inputs
int binding_count = 0;
auto** bindings = SDL_GetGamepadBindings(gamecontroller, &binding_count);
Common::ScopeGuard free_bindings([&] { SDL_free(bindings); });
// Buttons
for (u8 i = 0; i != size(s_sdl_button_names); ++i)
for (auto* const binding : std::span(bindings, binding_count))
{
SDL_GameControllerButton button = static_cast<SDL_GameControllerButton>(i);
if (SDL_GameControllerHasButton(m_gamecontroller, button))
{
AddInput(new Button(gamecontroller, button));
register_mapping(*binding);
register_mapping(SDL_GameControllerGetBindForButton(gamecontroller, button));
}
}
// Axes
for (u8 i = 0; i != size(s_sdl_axis_names); ++i)
{
SDL_GameControllerAxis axis = static_cast<SDL_GameControllerAxis>(i);
if (SDL_GameControllerHasAxis(m_gamecontroller, axis))
switch (binding->output_type)
{
case SDL_GAMEPAD_BINDTYPE_BUTTON:
AddInput(new Button(gamecontroller, *binding));
break;
case SDL_GAMEPAD_BINDTYPE_AXIS:
{
const auto axis = binding->output.axis.axis;
if (IsTriggerAxis(axis))
{
AddInput(new Axis(m_gamecontroller, 32767, axis));
@ -84,19 +79,23 @@ GameController::GameController(SDL_GameController* const gamecontroller,
AddInput(new Axis(m_gamecontroller, -32768, axis));
AddInput(new Axis(m_gamecontroller, 32767, axis));
}
register_mapping(SDL_GameControllerGetBindForAxis(gamecontroller, axis));
break;
}
default:
break;
}
}
const auto properties = SDL_GetGamepadProperties(m_gamecontroller);
// Rumble
if (SDL_GameControllerHasRumble(m_gamecontroller))
if (SDL_GetBooleanProperty(properties, SDL_PROP_GAMEPAD_CAP_RUMBLE_BOOLEAN, false))
{
AddOutput(new CombinedMotor(*this, &m_low_freq_rumble, &m_high_freq_rumble));
AddOutput(new Rumble("Motor L", *this, &m_low_freq_rumble, &GameController::UpdateRumble));
AddOutput(new Rumble("Motor R", *this, &m_high_freq_rumble, &GameController::UpdateRumble));
}
if (SDL_GameControllerHasRumbleTriggers(m_gamecontroller))
if (SDL_GetBooleanProperty(properties, SDL_PROP_GAMEPAD_CAP_TRIGGER_RUMBLE_BOOLEAN, false))
{
AddOutput(new Rumble("Trigger L", *this, &m_trigger_l_rumble,
&GameController::UpdateRumbleTriggers));
@ -105,7 +104,7 @@ GameController::GameController(SDL_GameController* const gamecontroller,
}
// Touchpad
if (SDL_GameControllerGetNumTouchpads(m_gamecontroller) > 0)
if (SDL_GetNumGamepadTouchpads(m_gamecontroller) > 0)
{
const char* const name_x = "Touchpad X";
AddInput(new NonDetectableDirectionalInput<-1>(name_x, &m_touchpad_x));
@ -119,7 +118,7 @@ GameController::GameController(SDL_GameController* const gamecontroller,
// Motion
const auto add_sensor = [this](SDL_SensorType type, std::string_view sensor_name,
const SDLMotionAxisList& axes) {
if (SDL_GameControllerSetSensorEnabled(m_gamecontroller, type, SDL_TRUE) == 0)
if (SDL_SetGamepadSensorEnabled(m_gamecontroller, type, true))
{
for (const SDLMotionAxis& axis : axes)
{
@ -140,7 +139,7 @@ GameController::GameController(SDL_GameController* const gamecontroller,
// Legacy inputs
// Buttons
int n_legacy_buttons = SDL_JoystickNumButtons(joystick);
int n_legacy_buttons = SDL_GetNumJoystickButtons(joystick);
if (n_legacy_buttons < 0)
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "Error in SDL_JoystickNumButtons(): {}", SDL_GetError());
@ -155,7 +154,7 @@ GameController::GameController(SDL_GameController* const gamecontroller,
}
// Axes
int n_legacy_axes = SDL_JoystickNumAxes(joystick);
int n_legacy_axes = SDL_GetNumJoystickAxes(joystick);
if (n_legacy_axes < 0)
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "Error in SDL_JoystickNumAxes(): {}", SDL_GetError());
@ -171,7 +170,7 @@ GameController::GameController(SDL_GameController* const gamecontroller,
}
// Hats
int n_legacy_hats = SDL_JoystickNumHats(joystick);
int n_legacy_hats = SDL_GetNumJoystickHats(joystick);
if (n_legacy_hats < 0)
{
ERROR_LOG_FMT(CONTROLLERINTERFACE, "Error in SDL_JoystickNumHats(): {}", SDL_GetError());
@ -188,16 +187,16 @@ GameController::GameController(SDL_GameController* const gamecontroller,
}
// Haptics
if (SDL_JoystickIsHaptic(m_joystick))
if (SDL_IsJoystickHaptic(m_joystick))
{
m_haptic = SDL_HapticOpenFromJoystick(m_joystick);
m_haptic = SDL_OpenHapticFromJoystick(m_joystick);
if (m_haptic)
{
const unsigned int supported_effects = SDL_HapticQuery(m_haptic);
const unsigned int supported_effects = SDL_GetMaxHapticEffects(m_haptic);
// Disable autocenter:
if (supported_effects & SDL_HAPTIC_AUTOCENTER)
SDL_HapticSetAutocenter(m_haptic, 0);
SDL_SetHapticAutocenter(m_haptic, 0);
// Constant
if (supported_effects & SDL_HAPTIC_CONSTANT)
@ -224,16 +223,19 @@ GameController::GameController(SDL_GameController* const gamecontroller,
}
}
// Needed to make the below power level not "UNKNOWN".
SDL_JoystickUpdate();
// Battery
if (SDL_JoystickPowerLevel const power_level = SDL_JoystickCurrentPowerLevel(m_joystick);
power_level != SDL_JOYSTICK_POWER_UNKNOWN)
{
m_battery_value = GetBatteryValueFromSDLPowerLevel(power_level);
if (UpdateBatteryLevel())
AddInput(new BatteryInput{&m_battery_value});
}
}
bool GameController::UpdateBatteryLevel()
{
int battery_percent = 0;
if (SDL_GetJoystickPowerInfo(m_joystick, &battery_percent) == SDL_POWERSTATE_ERROR)
return false;
m_battery_value = std::max(0, battery_percent);
return true;
}
GameController::~GameController()
@ -241,20 +243,18 @@ GameController::~GameController()
if (m_haptic)
{
// stop/destroy all effects
SDL_HapticStopAll(m_haptic);
SDL_StopHapticEffects(m_haptic);
// close haptic before joystick
SDL_HapticClose(m_haptic);
SDL_CloseHaptic(m_haptic);
m_haptic = nullptr;
}
if (m_gamecontroller)
{
// stop all rumble
SDL_GameControllerRumble(m_gamecontroller, 0, 0, 0);
// close game controller
SDL_GameControllerClose(m_gamecontroller);
SDL_RumbleGamepad(m_gamecontroller, 0, 0, 0);
SDL_CloseGamepad(m_gamecontroller);
}
// close joystick
SDL_JoystickClose(m_joystick);
SDL_CloseJoystick(m_joystick);
}
std::string GameController::GetName() const
@ -267,20 +267,28 @@ std::string GameController::GetSource() const
return "SDL";
}
int GameController::GetSDLInstanceID() const
SDL_JoystickID GameController::GetSDLInstanceID() const
{
return SDL_JoystickInstanceID(m_joystick);
return SDL_GetJoystickID(m_joystick);
}
std::string GameController::Button::GetName() const
{
return s_sdl_button_names[m_button];
const auto button = m_binding.output.button;
if (std::size_t(button) >= std::size(s_sdl_button_names))
return GetLegacyButtonName(button);
return s_sdl_button_names[button];
}
std::string GameController::Axis::GetName() const
{
if (std::size_t(m_axis) >= std::size(s_sdl_axis_names))
return GetLegacyAxisName(m_axis, m_range);
if (IsTriggerAxis(m_axis))
return std::string(s_sdl_axis_names[m_axis]);
return s_sdl_axis_names[m_axis];
bool negative = m_range < 0;
@ -293,12 +301,12 @@ std::string GameController::Axis::GetName() const
ControlState GameController::Button::GetState() const
{
return SDL_GameControllerGetButton(m_gc, m_button);
return SDL_GetGamepadButton(m_gc, m_binding.output.button);
}
ControlState GameController::Axis::GetState() const
{
return ControlState(SDL_GameControllerGetAxis(m_gc, m_axis)) / m_range;
return ControlState(SDL_GetGamepadAxis(m_gc, m_axis)) / m_range;
}
bool GameController::Button::IsMatchingName(std::string_view name) const
@ -306,25 +314,26 @@ bool GameController::Button::IsMatchingName(std::string_view name) const
if (GetName() == name)
return true;
// So that SDL can be a superset of XInput
if (name == "Button A")
return GetName() == "Button S";
if (name == "Button B")
return GetName() == "Button E";
if (name == "Button X")
return GetName() == "Button W";
if (name == "Button Y")
return GetName() == "Button N";
// Positionally match XInput button names.
// e.g. Switch Pro controller A-button matches "Button B".
// e.g. PlayStation controller Circle-button matches "Button B".
if (m_binding.output.button == SDL_GAMEPAD_BUTTON_SOUTH && name == "Button A")
return true;
if (m_binding.output.button == SDL_GAMEPAD_BUTTON_EAST && name == "Button B")
return true;
if (m_binding.output.button == SDL_GAMEPAD_BUTTON_WEST && name == "Button X")
return true;
if (m_binding.output.button == SDL_GAMEPAD_BUTTON_NORTH && name == "Button Y")
return true;
// Match legacy names.
const auto bind = SDL_GameControllerGetBindForButton(m_gc, m_button);
switch (bind.bindType)
// Match the old "Button 0"-like names.
switch (m_binding.input_type)
{
case SDL_CONTROLLER_BINDTYPE_BUTTON:
return name == GetLegacyButtonName(bind.value.button);
case SDL_CONTROLLER_BINDTYPE_HAT:
return name == GetLegacyHatName(bind.value.hat.hat,
GetDirectionFromHatMask(u8(bind.value.hat.hat_mask)));
case SDL_GAMEPAD_BINDTYPE_BUTTON:
return name == GetLegacyButtonName(m_binding.input.button);
case SDL_GAMEPAD_BINDTYPE_HAT:
return name == GetLegacyHatName(m_binding.input.hat.hat,
GetDirectionFromHatMask(m_binding.input.hat.hat_mask));
default:
return false;
}
@ -333,24 +342,24 @@ bool GameController::Button::IsMatchingName(std::string_view name) const
ControlState GameController::MotionInput::GetState() const
{
std::array<float, 3> data{};
SDL_GameControllerGetSensorData(m_gc, m_type, data.data(), (int)data.size());
SDL_GetGamepadSensorData(m_gc, m_type, data.data(), (int)data.size());
return m_scale * data[m_index];
}
// Legacy input
ControlState GameController::LegacyButton::GetState() const
{
return SDL_JoystickGetButton(m_js, m_index);
return SDL_GetJoystickButton(m_js, m_index);
}
ControlState GameController::LegacyAxis::GetState() const
{
return ControlState(SDL_JoystickGetAxis(m_js, m_index)) / m_range;
return ControlState(SDL_GetJoystickAxis(m_js, m_index)) / m_range;
}
ControlState GameController::LegacyHat::GetState() const
{
return (SDL_JoystickGetHat(m_js, m_index) & (1 << m_direction)) > 0;
return (SDL_GetJoystickHat(m_js, m_index) & (1 << m_direction)) > 0;
}
void GameController::HapticEffect::UpdateEffect()
@ -360,22 +369,22 @@ void GameController::HapticEffect::UpdateEffect()
if (m_id < 0)
{
// Upload and try to play the effect.
m_id = SDL_HapticNewEffect(m_haptic, &m_effect);
m_id = SDL_CreateHapticEffect(m_haptic, &m_effect);
if (m_id >= 0)
SDL_HapticRunEffect(m_haptic, m_id, 1);
SDL_RunHapticEffect(m_haptic, m_id, 1);
}
else
{
// Effect is already playing. Update parameters.
SDL_HapticUpdateEffect(m_haptic, m_id, &m_effect);
SDL_UpdateHapticEffect(m_haptic, m_id, &m_effect);
}
}
else if (m_id >= 0)
{
// Stop and remove the effect.
SDL_HapticStopEffect(m_haptic, m_id);
SDL_HapticDestroyEffect(m_haptic, m_id);
SDL_StopHapticEffect(m_haptic, m_id);
SDL_DestroyHapticEffect(m_haptic, m_id);
m_id = -1;
}
}

140
Source/Core/InputCommon/ControllerInterface/SDL/SDLGamepad.h
View File

@ -5,8 +5,8 @@
#include <array>
#include <SDL.h>
#include <SDL_haptic.h>
#include <SDL3/SDL_gamepad.h>
#include <SDL3/SDL_haptic.h>
#include "Common/MathUtil.h"
@ -29,7 +29,7 @@ std::string GetLegacyHatName(int index, int direction)
return "Hat " + std::to_string(index) + ' ' + "NESW"[direction];
}
constexpr int GetDirectionFromHatMask(u8 mask)
constexpr int GetDirectionFromHatMask(int mask)
{
return MathUtil::IntLog2(mask);
}
@ -37,38 +37,6 @@ constexpr int GetDirectionFromHatMask(u8 mask)
static_assert(GetDirectionFromHatMask(SDL_HAT_UP) == 0);
static_assert(GetDirectionFromHatMask(SDL_HAT_LEFT) == 3);
ControlState GetBatteryValueFromSDLPowerLevel(SDL_JoystickPowerLevel sdl_power_level)
{
// Values come from comments in SDL_joystick.h
// A proper percentage will be exposed in SDL3.
ControlState result;
switch (sdl_power_level)
{
case SDL_JOYSTICK_POWER_EMPTY:
result = 0.025;
break;
case SDL_JOYSTICK_POWER_LOW:
result = 0.125;
break;
case SDL_JOYSTICK_POWER_MEDIUM:
result = 0.45;
break;
case SDL_JOYSTICK_POWER_FULL:
result = 0.85;
break;
case SDL_JOYSTICK_POWER_WIRED:
case SDL_JOYSTICK_POWER_MAX:
result = 1.0;
break;
case SDL_JOYSTICK_POWER_UNKNOWN:
default:
result = 0.0;
break;
}
return result * ciface::BATTERY_INPUT_MAX_VALUE;
}
} // namespace
namespace ciface::SDL
@ -82,29 +50,29 @@ private:
{
public:
std::string GetName() const override;
Button(SDL_GameController* gc, SDL_GameControllerButton button) : m_gc(gc), m_button(button) {}
Button(SDL_Gamepad* gc, const SDL_GamepadBinding& binding) : m_gc(gc), m_binding(binding) {}
ControlState GetState() const override;
bool IsMatchingName(std::string_view name) const override;
private:
SDL_GameController* const m_gc;
const SDL_GameControllerButton m_button;
SDL_Gamepad* const m_gc;
const SDL_GamepadBinding m_binding;
};
class Axis : public Core::Device::Input
{
public:
std::string GetName() const override;
Axis(SDL_GameController* gc, Sint16 range, SDL_GameControllerAxis axis)
Axis(SDL_Gamepad* gc, Sint16 range, SDL_GamepadAxis axis)
: m_gc(gc), m_range(range), m_axis(axis)
{
}
ControlState GetState() const override;
private:
SDL_GameController* const m_gc;
SDL_Gamepad* const m_gc;
const Sint16 m_range;
const SDL_GameControllerAxis m_axis;
const SDL_GamepadAxis m_axis;
};
// Legacy inputs
@ -180,7 +148,7 @@ private:
std::string GetName() const override { return m_name; }
void SetState(ControlState state) override
{
const auto new_state = state * std::numeric_limits<Uint16>::max();
const auto new_state = std::lround(state * std::numeric_limits<Uint16>::max());
if (m_state == new_state)
return;
@ -205,7 +173,7 @@ private:
std::string GetName() const override { return "Motor"; }
void SetState(ControlState state) override
{
const auto new_state = state * std::numeric_limits<Uint16>::max();
const auto new_state = std::lround(state * std::numeric_limits<Uint16>::max());
if (m_low_state == new_state && m_high_state == new_state)
return;
@ -327,7 +295,7 @@ private:
class MotionInput : public Input
{
public:
MotionInput(std::string name, SDL_GameController* gc, SDL_SensorType type, int index,
MotionInput(std::string name, SDL_Gamepad* gc, SDL_SensorType type, int index,
ControlState scale)
: m_name(std::move(name)), m_gc(gc), m_type(type), m_index(index), m_scale(scale)
{
@ -340,7 +308,7 @@ private:
private:
std::string m_name;
SDL_GameController* const m_gc;
SDL_Gamepad* const m_gc;
SDL_SensorType const m_type;
int const m_index;
@ -348,26 +316,25 @@ private:
};
public:
GameController(SDL_GameController* const gamecontroller, SDL_Joystick* const joystick);
~GameController();
GameController(SDL_Gamepad* gamecontroller, SDL_Joystick* joystick);
~GameController() override;
std::string GetName() const override;
std::string GetSource() const override;
int GetSDLInstanceID() const;
SDL_JoystickID GetSDLInstanceID() const;
Core::DeviceRemoval UpdateInput() override
{
m_battery_value = GetBatteryValueFromSDLPowerLevel(SDL_JoystickCurrentPowerLevel(m_joystick));
UpdateBatteryLevel();
// We only support one touchpad and one finger.
const int touchpad_index = 0;
const int finger_index = 0;
if (SDL_GameControllerGetNumTouchpads(m_gamecontroller) > touchpad_index &&
SDL_GameControllerGetNumTouchpadFingers(m_gamecontroller, touchpad_index) > finger_index)
if (SDL_GetNumGamepadTouchpads(m_gamecontroller) > touchpad_index &&
SDL_GetNumGamepadTouchpadFingers(m_gamecontroller, touchpad_index) > finger_index)
{
Uint8 state = 0;
SDL_GameControllerGetTouchpadFinger(m_gamecontroller, touchpad_index, finger_index, &state,
&m_touchpad_x, &m_touchpad_y, &m_touchpad_pressure);
SDL_GetGamepadTouchpadFinger(m_gamecontroller, touchpad_index, finger_index, nullptr,
&m_touchpad_x, &m_touchpad_y, &m_touchpad_pressure);
m_touchpad_x = m_touchpad_x * 2 - 1;
m_touchpad_y = m_touchpad_y * 2 - 1;
}
@ -378,23 +345,24 @@ public:
private:
void UpdateRumble()
{
SDL_GameControllerRumble(m_gamecontroller, m_low_freq_rumble, m_high_freq_rumble,
RUMBLE_LENGTH_MS);
SDL_RumbleGamepad(m_gamecontroller, m_low_freq_rumble, m_high_freq_rumble, RUMBLE_LENGTH_MS);
}
void UpdateRumbleTriggers()
{
SDL_GameControllerRumbleTriggers(m_gamecontroller, m_trigger_l_rumble, m_trigger_r_rumble,
RUMBLE_LENGTH_MS);
SDL_RumbleGamepadTriggers(m_gamecontroller, m_trigger_l_rumble, m_trigger_r_rumble,
RUMBLE_LENGTH_MS);
}
bool UpdateBatteryLevel();
Uint16 m_low_freq_rumble = 0;
Uint16 m_high_freq_rumble = 0;
Uint16 m_trigger_l_rumble = 0;
Uint16 m_trigger_r_rumble = 0;
SDL_GameController* const m_gamecontroller;
SDL_Gamepad* const m_gamecontroller;
std::string m_name;
SDL_Joystick* const m_joystick;
SDL_Haptic* m_haptic = nullptr;
@ -413,35 +381,35 @@ struct SDLMotionAxis
using SDLMotionAxisList = std::array<SDLMotionAxis, 6>;
static constexpr std::array<const char*, 21> s_sdl_button_names = {
"Button S", // SDL_CONTROLLER_BUTTON_A
"Button E", // SDL_CONTROLLER_BUTTON_B
"Button W", // SDL_CONTROLLER_BUTTON_X
"Button N", // SDL_CONTROLLER_BUTTON_Y
"Back", // SDL_CONTROLLER_BUTTON_BACK
"Guide", // SDL_CONTROLLER_BUTTON_GUIDE
"Start", // SDL_CONTROLLER_BUTTON_START
"Thumb L", // SDL_CONTROLLER_BUTTON_LEFTSTICK
"Thumb R", // SDL_CONTROLLER_BUTTON_RIGHTSTICK
"Shoulder L", // SDL_CONTROLLER_BUTTON_LEFTSHOULDER
"Shoulder R", // SDL_CONTROLLER_BUTTON_RIGHTSHOULDER
"Pad N", // SDL_CONTROLLER_BUTTON_DPAD_UP
"Pad S", // SDL_CONTROLLER_BUTTON_DPAD_DOWN
"Pad W", // SDL_CONTROLLER_BUTTON_DPAD_LEFT
"Pad E", // SDL_CONTROLLER_BUTTON_DPAD_RIGHT
"Misc 1", // SDL_CONTROLLER_BUTTON_MISC1
"Paddle 1", // SDL_CONTROLLER_BUTTON_PADDLE1
"Paddle 2", // SDL_CONTROLLER_BUTTON_PADDLE2
"Paddle 3", // SDL_CONTROLLER_BUTTON_PADDLE3
"Paddle 4", // SDL_CONTROLLER_BUTTON_PADDLE4
"Touchpad", // SDL_CONTROLLER_BUTTON_TOUCHPAD
"Button S", // SDL_GAMEPAD_BUTTON_SOUTH
"Button E", // SDL_GAMEPAD_BUTTON_EAST
"Button W", // SDL_GAMEPAD_BUTTON_WEST
"Button N", // SDL_GAMEPAD_BUTTON_NORTH
"Back", // SDL_GAMEPAD_BUTTON_BACK
"Guide", // SDL_GAMEPAD_BUTTON_GUIDE
"Start", // SDL_GAMEPAD_BUTTON_START
"Thumb L", // SDL_GAMEPAD_BUTTON_LEFT_STICK
"Thumb R", // SDL_GAMEPAD_BUTTON_RIGHT_STICK
"Shoulder L", // SDL_GAMEPAD_BUTTON_LEFT_SHOULDER
"Shoulder R", // SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER
"Pad N", // SDL_GAMEPAD_BUTTON_DPAD_UP
"Pad S", // SDL_GAMEPAD_BUTTON_DPAD_DOWN
"Pad W", // SDL_GAMEPAD_BUTTON_DPAD_LEFT
"Pad E", // SDL_GAMEPAD_BUTTON_DPAD_RIGHT
"Misc 1", // SDL_GAMEPAD_BUTTON_MISC1
"Paddle 1", // SDL_GAMEPAD_BUTTON_RIGHT_PADDLE1
"Paddle 2", // SDL_GAMEPAD_BUTTON_LEFT_PADDLE1
"Paddle 3", // SDL_GAMEPAD_BUTTON_RIGHT_PADDLE2
"Paddle 4", // SDL_GAMEPAD_BUTTON_LEFT_PADDLE2
"Touchpad", // SDL_GAMEPAD_BUTTON_TOUCHPAD
};
static constexpr std::array<const char*, 6> s_sdl_axis_names = {
"Left X", // SDL_CONTROLLER_AXIS_LEFTX
"Left Y", // SDL_CONTROLLER_AXIS_LEFTY
"Right X", // SDL_CONTROLLER_AXIS_RIGHTX
"Right Y", // SDL_CONTROLLER_AXIS_RIGHTY
"Trigger L", // SDL_CONTROLLER_AXIS_TRIGGERLEFT
"Trigger R", // SDL_CONTROLLER_AXIS_TRIGGERRIGHT
"Left X", // SDL_GAMEPAD_AXIS_LEFTX
"Left Y", // SDL_GAMEPAD_AXIS_LEFTY
"Right X", // SDL_GAMEPAD_AXIS_RIGHTX
"Right Y", // SDL_GAMEPAD_AXIS_RIGHTY
"Trigger L", // SDL_GAMEPAD_AXIS_LEFT_TRIGGER
"Trigger R", // SDL_GAMEPAD_AXIS_RIGHT_TRIGGER
};
static constexpr SDLMotionAxisList SDL_AXES_ACCELEROMETER = {{
{"Up", 1, 1},