piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-07-23 14:19:46 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #13775 from jordan-woyak/sdl-gamepad-rename

Browse Source 
InputCommon: Rename SDL input backend GameController to Gamepad.
This commit is contained in:
Jordan Woyak
2025-07-12 16:50:04 -05:00
committed by GitHub
parent d92f7f194c 609d91156a
commit 633fd5df70
3 changed files with 76 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -251,9 +251,9 @@ void InputBackend::OpenAndAddDevice(SDL_JoystickID instance_id)
// SDL tries parsing these as Joysticks // SDL tries parsing these as Joysticks
return; return;
} }
auto gamecontroller = std::make_shared<GameController>(gc, js); auto gamepad = std::make_shared<Gamepad>(gc, js);
if (!gamecontroller->Inputs().empty() || !gamecontroller->Outputs().empty()) if (!gamepad->Inputs().empty() || !gamepad->Outputs().empty())
GetControllerInterface().AddDevice(std::move(gamecontroller)); GetControllerInterface().AddDevice(std::move(gamepad));
} }
} }
@ -267,7 +267,7 @@ bool InputBackend::HandleEventAndContinue(const SDL_Event& e)
{ {
GetControllerInterface().RemoveDevice([&e](const auto* device) { GetControllerInterface().RemoveDevice([&e](const auto* device) {
return device->GetSource() == "SDL" && return device->GetSource() == "SDL" &&
static_cast<const GameController*>(device)->GetSDLInstanceID() == e.jdevice.which; static_cast<const Gamepad*>(device)->GetSDLInstanceID() == e.jdevice.which;
}); });
} }
else if (e.type == m_populate_event_type) else if (e.type == m_populate_event_type)

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

@ -19,14 +19,14 @@ static bool IsTriggerAxis(int index)
return index >= 4; return index >= 4;
} }
GameController::GameController(SDL_Gamepad* const gamecontroller, SDL_Joystick* const joystick) Gamepad::Gamepad(SDL_Gamepad* const gamepad, SDL_Joystick* const joystick)
: m_gamecontroller(gamecontroller), m_joystick(joystick) : m_gamepad(gamepad), m_joystick(joystick)
{ {
const char* const sdl_name = (gamecontroller != nullptr) ? SDL_GetGamepadName(gamecontroller) : const char* const sdl_name =
SDL_GetJoystickName(joystick); (gamepad != nullptr) ? SDL_GetGamepadName(gamepad) : SDL_GetJoystickName(joystick);
m_name = (sdl_name != nullptr) ? sdl_name : "Unknown"; m_name = (sdl_name != nullptr) ? sdl_name : "Unknown";
// If a Joystick input has a GameController equivalent button/hat we don't add it. // If a Joystick input has a Gamepad equivalent button/hat we don't add it.
// "Equivalent" axes are still added as hidden/undetectable inputs to handle // "Equivalent" axes are still added as hidden/undetectable inputs to handle
// loading of existing configs which may use "full surface" inputs. // loading of existing configs which may use "full surface" inputs.
// Otherwise handling those would require dealing with gamepad specific quirks. // Otherwise handling those would require dealing with gamepad specific quirks.
@ -50,11 +50,11 @@ GameController::GameController(SDL_Gamepad* const gamecontroller, SDL_Joystick*
} }
}; };
if (gamecontroller != nullptr) if (gamepad != nullptr)
{ {
// Inputs // Inputs
int binding_count = 0; int binding_count = 0;
auto** bindings = SDL_GetGamepadBindings(gamecontroller, &binding_count); auto** bindings = SDL_GetGamepadBindings(gamepad, &binding_count);
Common::ScopeGuard free_bindings([&] { SDL_free(bindings); }); Common::ScopeGuard free_bindings([&] { SDL_free(bindings); });
for (auto* const binding : std::span(bindings, binding_count)) for (auto* const binding : std::span(bindings, binding_count))
@ -64,20 +64,20 @@ GameController::GameController(SDL_Gamepad* const gamecontroller, SDL_Joystick*
switch (binding->output_type) switch (binding->output_type)
{ {
case SDL_GAMEPAD_BINDTYPE_BUTTON: case SDL_GAMEPAD_BINDTYPE_BUTTON:
AddInput(new Button(gamecontroller, *binding)); AddInput(new Button(gamepad, *binding));
break; break;
case SDL_GAMEPAD_BINDTYPE_AXIS: case SDL_GAMEPAD_BINDTYPE_AXIS:
{ {
const auto axis = binding->output.axis.axis; const auto axis = binding->output.axis.axis;
if (IsTriggerAxis(axis)) if (IsTriggerAxis(axis))
{ {
AddInput(new Axis(m_gamecontroller, 32767, axis)); AddInput(new Axis(m_gamepad, 32767, axis));
} }
else else
{ {
// Each axis gets a negative and a positive input instance associated with it // Each axis gets a negative and a positive input instance associated with it
AddInput(new Axis(m_gamecontroller, -32768, axis)); AddInput(new Axis(m_gamepad, -32768, axis));
AddInput(new Axis(m_gamecontroller, 32767, axis)); AddInput(new Axis(m_gamepad, 32767, axis));
} }
break; break;
} }
@ -86,25 +86,25 @@ GameController::GameController(SDL_Gamepad* const gamecontroller, SDL_Joystick*
} }
} }
const auto properties = SDL_GetGamepadProperties(m_gamecontroller); const auto properties = SDL_GetGamepadProperties(m_gamepad);
// Rumble // Rumble
if (SDL_GetBooleanProperty(properties, SDL_PROP_GAMEPAD_CAP_RUMBLE_BOOLEAN, false)) 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 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 L", *this, &m_low_freq_rumble, &Gamepad::UpdateRumble));
AddOutput(new Rumble("Motor R", *this, &m_high_freq_rumble, &GameController::UpdateRumble)); AddOutput(new Rumble("Motor R", *this, &m_high_freq_rumble, &Gamepad::UpdateRumble));
} }
if (SDL_GetBooleanProperty(properties, SDL_PROP_GAMEPAD_CAP_TRIGGER_RUMBLE_BOOLEAN, false)) if (SDL_GetBooleanProperty(properties, SDL_PROP_GAMEPAD_CAP_TRIGGER_RUMBLE_BOOLEAN, false))
{ {
AddOutput(new Rumble("Trigger L", *this, &m_trigger_l_rumble, AddOutput(
&GameController::UpdateRumbleTriggers)); new Rumble("Trigger L", *this, &m_trigger_l_rumble, &Gamepad::UpdateRumbleTriggers));
AddOutput(new Rumble("Trigger R", *this, &m_trigger_r_rumble, AddOutput(
&GameController::UpdateRumbleTriggers)); new Rumble("Trigger R", *this, &m_trigger_r_rumble, &Gamepad::UpdateRumbleTriggers));
} }
// Touchpad // Touchpad
if (SDL_GetNumGamepadTouchpads(m_gamecontroller) > 0) if (SDL_GetNumGamepadTouchpads(m_gamepad) > 0)
{ {
const char* const name_x = "Touchpad X"; const char* const name_x = "Touchpad X";
AddInput(new NonDetectableDirectionalInput<-1>(name_x, &m_touchpad_x)); AddInput(new NonDetectableDirectionalInput<-1>(name_x, &m_touchpad_x));
@ -118,12 +118,12 @@ GameController::GameController(SDL_Gamepad* const gamecontroller, SDL_Joystick*
// Motion // Motion
const auto add_sensor = [this](SDL_SensorType type, std::string_view sensor_name, const auto add_sensor = [this](SDL_SensorType type, std::string_view sensor_name,
const SDLMotionAxisList& axes) { const SDLMotionAxisList& axes) {
if (SDL_SetGamepadSensorEnabled(m_gamecontroller, type, true)) if (SDL_SetGamepadSensorEnabled(m_gamepad, type, true))
{ {
for (const SDLMotionAxis& axis : axes) for (const SDLMotionAxis& axis : axes)
{ {
AddInput(new MotionInput(fmt::format("{} {}", sensor_name, axis.name), m_gamecontroller, AddInput(new MotionInput(fmt::format("{} {}", sensor_name, axis.name), m_gamepad, type,
type, axis.index, axis.scale)); axis.index, axis.scale));
} }
} }
}; };
@ -228,7 +228,7 @@ GameController::GameController(SDL_Gamepad* const gamecontroller, SDL_Joystick*
AddInput(new BatteryInput{&m_battery_value}); AddInput(new BatteryInput{&m_battery_value});
} }
bool GameController::UpdateBatteryLevel() bool Gamepad::UpdateBatteryLevel()
{ {
int battery_percent = 0; int battery_percent = 0;
if (SDL_GetJoystickPowerInfo(m_joystick, &battery_percent) == SDL_POWERSTATE_ERROR) if (SDL_GetJoystickPowerInfo(m_joystick, &battery_percent) == SDL_POWERSTATE_ERROR)
@ -238,7 +238,7 @@ bool GameController::UpdateBatteryLevel()
return true; return true;
} }
GameController::~GameController() Gamepad::~Gamepad()
{ {
if (m_haptic) if (m_haptic)
{ {
@ -248,31 +248,31 @@ GameController::~GameController()
SDL_CloseHaptic(m_haptic); SDL_CloseHaptic(m_haptic);
m_haptic = nullptr; m_haptic = nullptr;
} }
if (m_gamecontroller) if (m_gamepad)
{ {
// stop all rumble // stop all rumble
SDL_RumbleGamepad(m_gamecontroller, 0, 0, 0); SDL_RumbleGamepad(m_gamepad, 0, 0, 0);
SDL_CloseGamepad(m_gamecontroller); SDL_CloseGamepad(m_gamepad);
} }
SDL_CloseJoystick(m_joystick); SDL_CloseJoystick(m_joystick);
} }
std::string GameController::GetName() const std::string Gamepad::GetName() const
{ {
return m_name; return m_name;
} }
std::string GameController::GetSource() const std::string Gamepad::GetSource() const
{ {
return "SDL"; return "SDL";
} }
SDL_JoystickID GameController::GetSDLInstanceID() const SDL_JoystickID Gamepad::GetSDLInstanceID() const
{ {
return SDL_GetJoystickID(m_joystick); return SDL_GetJoystickID(m_joystick);
} }
std::string GameController::Button::GetName() const std::string Gamepad::Button::GetName() const
{ {
const auto button = m_binding.output.button; const auto button = m_binding.output.button;
@ -282,7 +282,7 @@ std::string GameController::Button::GetName() const
return s_sdl_button_names[button]; return s_sdl_button_names[button];
} }
std::string GameController::Axis::GetName() const std::string Gamepad::Axis::GetName() const
{ {
if (std::size_t(m_axis) >= std::size(s_sdl_axis_names)) if (std::size_t(m_axis) >= std::size(s_sdl_axis_names))
return GetLegacyAxisName(m_axis, m_range); return GetLegacyAxisName(m_axis, m_range);
@ -299,17 +299,17 @@ std::string GameController::Axis::GetName() const
return std::string(s_sdl_axis_names[m_axis]) + (negative ? '-' : '+'); return std::string(s_sdl_axis_names[m_axis]) + (negative ? '-' : '+');
} }
ControlState GameController::Button::GetState() const ControlState Gamepad::Button::GetState() const
{ {
return SDL_GetGamepadButton(m_gc, m_binding.output.button); return SDL_GetGamepadButton(m_gc, m_binding.output.button);
} }
ControlState GameController::Axis::GetState() const ControlState Gamepad::Axis::GetState() const
{ {
return ControlState(SDL_GetGamepadAxis(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 bool Gamepad::Button::IsMatchingName(std::string_view name) const
{ {
if (GetName() == name) if (GetName() == name)
return true; return true;
@ -339,7 +339,7 @@ bool GameController::Button::IsMatchingName(std::string_view name) const
} }
} }
ControlState GameController::MotionInput::GetState() const ControlState Gamepad::MotionInput::GetState() const
{ {
std::array<float, 3> data{}; std::array<float, 3> data{};
SDL_GetGamepadSensorData(m_gc, m_type, data.data(), (int)data.size()); SDL_GetGamepadSensorData(m_gc, m_type, data.data(), (int)data.size());
@ -347,22 +347,22 @@ ControlState GameController::MotionInput::GetState() const
} }
// Legacy input // Legacy input
ControlState GameController::LegacyButton::GetState() const ControlState Gamepad::LegacyButton::GetState() const
{ {
return SDL_GetJoystickButton(m_js, m_index); return SDL_GetJoystickButton(m_js, m_index);
} }
ControlState GameController::LegacyAxis::GetState() const ControlState Gamepad::LegacyAxis::GetState() const
{ {
return ControlState(SDL_GetJoystickAxis(m_js, m_index)) / m_range; return ControlState(SDL_GetJoystickAxis(m_js, m_index)) / m_range;
} }
ControlState GameController::LegacyHat::GetState() const ControlState Gamepad::LegacyHat::GetState() const
{ {
return (SDL_GetJoystickHat(m_js, m_index) & (1 << m_direction)) > 0; return (SDL_GetJoystickHat(m_js, m_index) & (1 << m_direction)) > 0;
} }
void GameController::HapticEffect::UpdateEffect() void Gamepad::HapticEffect::UpdateEffect()
{ {
if (m_effect.type != DISABLED_EFFECT_TYPE) if (m_effect.type != DISABLED_EFFECT_TYPE)
{ {
@ -389,40 +389,40 @@ void GameController::HapticEffect::UpdateEffect()
} }
} }
GameController::HapticEffect::HapticEffect(SDL_Haptic* haptic) : m_haptic(haptic) Gamepad::HapticEffect::HapticEffect(SDL_Haptic* haptic) : m_haptic(haptic)
{ {
// FYI: type is set within UpdateParameters. // FYI: type is set within UpdateParameters.
m_effect.type = DISABLED_EFFECT_TYPE; m_effect.type = DISABLED_EFFECT_TYPE;
} }
GameController::HapticEffect::~HapticEffect() Gamepad::HapticEffect::~HapticEffect()
{ {
m_effect.type = DISABLED_EFFECT_TYPE; m_effect.type = DISABLED_EFFECT_TYPE;
UpdateEffect(); UpdateEffect();
} }
void GameController::HapticEffect::SetDirection(SDL_HapticDirection* dir) void Gamepad::HapticEffect::SetDirection(SDL_HapticDirection* dir)
{ {
// Left direction (for wheels) // Left direction (for wheels)
dir->type = SDL_HAPTIC_CARTESIAN; dir->type = SDL_HAPTIC_CARTESIAN;
dir->dir[0] = -1; dir->dir[0] = -1;
} }
GameController::ConstantEffect::ConstantEffect(SDL_Haptic* haptic) : HapticEffect(haptic) Gamepad::ConstantEffect::ConstantEffect(SDL_Haptic* haptic) : HapticEffect(haptic)
{ {
m_effect.constant = {}; m_effect.constant = {};
SetDirection(&m_effect.constant.direction); SetDirection(&m_effect.constant.direction);
m_effect.constant.length = RUMBLE_LENGTH_MS; m_effect.constant.length = RUMBLE_LENGTH_MS;
} }
GameController::RampEffect::RampEffect(SDL_Haptic* haptic) : HapticEffect(haptic) Gamepad::RampEffect::RampEffect(SDL_Haptic* haptic) : HapticEffect(haptic)
{ {
m_effect.ramp = {}; m_effect.ramp = {};
SetDirection(&m_effect.ramp.direction); SetDirection(&m_effect.ramp.direction);
m_effect.ramp.length = RUMBLE_LENGTH_MS; m_effect.ramp.length = RUMBLE_LENGTH_MS;
} }
GameController::PeriodicEffect::PeriodicEffect(SDL_Haptic* haptic, u16 waveform) Gamepad::PeriodicEffect::PeriodicEffect(SDL_Haptic* haptic, u16 waveform)
: HapticEffect(haptic), m_waveform(waveform) : HapticEffect(haptic), m_waveform(waveform)
{ {
m_effect.periodic = {}; m_effect.periodic = {};
@ -433,24 +433,24 @@ GameController::PeriodicEffect::PeriodicEffect(SDL_Haptic* haptic, u16 waveform)
m_effect.periodic.phase = 0; m_effect.periodic.phase = 0;
} }
GameController::LeftRightEffect::LeftRightEffect(SDL_Haptic* haptic, Motor motor) Gamepad::LeftRightEffect::LeftRightEffect(SDL_Haptic* haptic, Motor motor)
: HapticEffect(haptic), m_motor(motor) : HapticEffect(haptic), m_motor(motor)
{ {
m_effect.leftright = {}; m_effect.leftright = {};
m_effect.leftright.length = RUMBLE_LENGTH_MS; m_effect.leftright.length = RUMBLE_LENGTH_MS;
} }
std::string GameController::ConstantEffect::GetName() const std::string Gamepad::ConstantEffect::GetName() const
{ {
return "Constant"; return "Constant";
} }
std::string GameController::RampEffect::GetName() const std::string Gamepad::RampEffect::GetName() const
{ {
return "Ramp"; return "Ramp";
} }
std::string GameController::PeriodicEffect::GetName() const std::string Gamepad::PeriodicEffect::GetName() const
{ {
switch (m_waveform) switch (m_waveform)
{ {
@ -467,12 +467,12 @@ std::string GameController::PeriodicEffect::GetName() const
} }
} }
std::string GameController::LeftRightEffect::GetName() const std::string Gamepad::LeftRightEffect::GetName() const
{ {
return (Motor::Strong == m_motor) ? "Strong" : "Weak"; return (Motor::Strong == m_motor) ? "Strong" : "Weak";
} }
void GameController::HapticEffect::SetState(ControlState state) void Gamepad::HapticEffect::SetState(ControlState state)
{ {
// Maximum force value for all SDL effects: // Maximum force value for all SDL effects:
constexpr s16 MAX_FORCE_VALUE = 0x7fff; constexpr s16 MAX_FORCE_VALUE = 0x7fff;
@ -483,7 +483,7 @@ void GameController::HapticEffect::SetState(ControlState state)
} }
} }
bool GameController::ConstantEffect::UpdateParameters(s16 value) bool Gamepad::ConstantEffect::UpdateParameters(s16 value)
{ {
s16& level = m_effect.constant.level; s16& level = m_effect.constant.level;
const s16 old_level = level; const s16 old_level = level;
@ -494,7 +494,7 @@ bool GameController::ConstantEffect::UpdateParameters(s16 value)
return level != old_level; return level != old_level;
} }
bool GameController::RampEffect::UpdateParameters(s16 value) bool Gamepad::RampEffect::UpdateParameters(s16 value)
{ {
s16& level = m_effect.ramp.start; s16& level = m_effect.ramp.start;
const s16 old_level = level; const s16 old_level = level;
@ -508,7 +508,7 @@ bool GameController::RampEffect::UpdateParameters(s16 value)
return level != old_level; return level != old_level;
} }
bool GameController::PeriodicEffect::UpdateParameters(s16 value) bool Gamepad::PeriodicEffect::UpdateParameters(s16 value)
{ {
s16& level = m_effect.periodic.magnitude; s16& level = m_effect.periodic.magnitude;
const s16 old_level = level; const s16 old_level = level;
@ -519,7 +519,7 @@ bool GameController::PeriodicEffect::UpdateParameters(s16 value)
return level != old_level; return level != old_level;
} }
bool GameController::LeftRightEffect::UpdateParameters(s16 value) bool Gamepad::LeftRightEffect::UpdateParameters(s16 value)
{ {
u16& level = (Motor::Strong == m_motor) ? m_effect.leftright.large_magnitude : u16& level = (Motor::Strong == m_motor) ? m_effect.leftright.large_magnitude :
m_effect.leftright.small_magnitude; m_effect.leftright.small_magnitude;

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

@ -42,10 +42,10 @@ static_assert(GetDirectionFromHatMask(SDL_HAT_LEFT) == 3);
namespace ciface::SDL namespace ciface::SDL
{ {
class GameController : public Core::Device class Gamepad : public Core::Device
{ {
private: private:
// GameController inputs // Gamepad inputs
class Button : public Core::Device::Input class Button : public Core::Device::Input
{ {
public: public:
@ -139,9 +139,9 @@ private:
class Rumble : public Output class Rumble : public Output
{ {
public: public:
using UpdateCallback = void (GameController::*)(void); using UpdateCallback = void (Gamepad::*)(void);
Rumble(const char* name, GameController& gc, Uint16* state, UpdateCallback update_callback) Rumble(const char* name, Gamepad& gc, Uint16* state, UpdateCallback update_callback)
: m_name{name}, m_gc{gc}, m_state{*state}, m_update_callback{update_callback} : m_name{name}, m_gc{gc}, m_state{*state}, m_update_callback{update_callback}
{ {
} }
@ -158,7 +158,7 @@ private:
private: private:
const char* const m_name; const char* const m_name;
GameController& m_gc; Gamepad& m_gc;
Uint16& m_state; Uint16& m_state;
UpdateCallback const m_update_callback; UpdateCallback const m_update_callback;
}; };
@ -166,7 +166,7 @@ private:
class CombinedMotor : public Output class CombinedMotor : public Output
{ {
public: public:
CombinedMotor(GameController& gc, Uint16* low_state, Uint16* high_state) CombinedMotor(Gamepad& gc, Uint16* low_state, Uint16* high_state)
: m_gc{gc}, m_low_state{*low_state}, m_high_state{*high_state} : m_gc{gc}, m_low_state{*low_state}, m_high_state{*high_state}
{ {
} }
@ -183,7 +183,7 @@ private:
} }
private: private:
GameController& m_gc; Gamepad& m_gc;
Uint16& m_low_state; Uint16& m_low_state;
Uint16& m_high_state; Uint16& m_high_state;
}; };
@ -316,8 +316,8 @@ private:
}; };
public: public:
GameController(SDL_Gamepad* gamecontroller, SDL_Joystick* joystick); Gamepad(SDL_Gamepad* gamepad, SDL_Joystick* joystick);
~GameController() override; ~Gamepad() override;
std::string GetName() const override; std::string GetName() const override;
std::string GetSource() const override; std::string GetSource() const override;
@ -330,11 +330,11 @@ public:
const int touchpad_index = 0; const int touchpad_index = 0;
const int finger_index = 0; const int finger_index = 0;
if (SDL_GetNumGamepadTouchpads(m_gamecontroller) > touchpad_index && if (SDL_GetNumGamepadTouchpads(m_gamepad) > touchpad_index &&
SDL_GetNumGamepadTouchpadFingers(m_gamecontroller, touchpad_index) > finger_index) SDL_GetNumGamepadTouchpadFingers(m_gamepad, touchpad_index) > finger_index)
{ {
SDL_GetGamepadTouchpadFinger(m_gamecontroller, touchpad_index, finger_index, nullptr, SDL_GetGamepadTouchpadFinger(m_gamepad, touchpad_index, finger_index, nullptr, &m_touchpad_x,
&m_touchpad_x, &m_touchpad_y, &m_touchpad_pressure); &m_touchpad_y, &m_touchpad_pressure);
m_touchpad_x = m_touchpad_x * 2 - 1; m_touchpad_x = m_touchpad_x * 2 - 1;
m_touchpad_y = m_touchpad_y * 2 - 1; m_touchpad_y = m_touchpad_y * 2 - 1;
} }
@ -345,13 +345,12 @@ public:
private: private:
void UpdateRumble() void UpdateRumble()
{ {
SDL_RumbleGamepad(m_gamecontroller, m_low_freq_rumble, m_high_freq_rumble, RUMBLE_LENGTH_MS); SDL_RumbleGamepad(m_gamepad, m_low_freq_rumble, m_high_freq_rumble, RUMBLE_LENGTH_MS);
} }
void UpdateRumbleTriggers() void UpdateRumbleTriggers()
{ {
SDL_RumbleGamepadTriggers(m_gamecontroller, m_trigger_l_rumble, m_trigger_r_rumble, SDL_RumbleGamepadTriggers(m_gamepad, m_trigger_l_rumble, m_trigger_r_rumble, RUMBLE_LENGTH_MS);
RUMBLE_LENGTH_MS);
} }
bool UpdateBatteryLevel(); bool UpdateBatteryLevel();
@ -362,7 +361,7 @@ private:
Uint16 m_trigger_l_rumble = 0; Uint16 m_trigger_l_rumble = 0;
Uint16 m_trigger_r_rumble = 0; Uint16 m_trigger_r_rumble = 0;
SDL_Gamepad* const m_gamecontroller; SDL_Gamepad* const m_gamepad;
std::string m_name; std::string m_name;
SDL_Joystick* const m_joystick; SDL_Joystick* const m_joystick;
SDL_Haptic* m_haptic = nullptr; SDL_Haptic* m_haptic = nullptr;