SDL3pp_gamepad.h

#ifndef SDL3PP_GAMEPAD_H_
#define SDL3PP_GAMEPAD_H_
 
#include <SDL3/SDL_gamepad.h>
#include "SDL3pp_error.h"
#include "SDL3pp_guid.h"
#include "SDL3pp_iostream.h"
#include "SDL3pp_joystick.h"
#include "SDL3pp_power.h"
#include "SDL3pp_properties.h"
#include "SDL3pp_sensor.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {

 
// Forward decl
struct Gamepad;

using GamepadRaw = SDL_Gamepad*;

using GamepadRef = ResourceRef<Gamepad>;

using GamepadType = SDL_GamepadType;
 
constexpr GamepadType GAMEPAD_TYPE_UNKNOWN =
  SDL_GAMEPAD_TYPE_UNKNOWN; 
 
constexpr GamepadType GAMEPAD_TYPE_STANDARD =
  SDL_GAMEPAD_TYPE_STANDARD; 
 
constexpr GamepadType GAMEPAD_TYPE_XBOX360 =
  SDL_GAMEPAD_TYPE_XBOX360; 
 
constexpr GamepadType GAMEPAD_TYPE_XBOXONE =
  SDL_GAMEPAD_TYPE_XBOXONE; 
 
constexpr GamepadType GAMEPAD_TYPE_PS3 =
  SDL_GAMEPAD_TYPE_PS3; 
 
constexpr GamepadType GAMEPAD_TYPE_PS4 =
  SDL_GAMEPAD_TYPE_PS4; 
 
constexpr GamepadType GAMEPAD_TYPE_PS5 =
  SDL_GAMEPAD_TYPE_PS5; 
 
constexpr GamepadType GAMEPAD_TYPE_NINTENDO_SWITCH_PRO =
  SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_PRO; 
 
constexpr GamepadType GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_LEFT =
  SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_LEFT; 
 
constexpr GamepadType GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_RIGHT =
  SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_RIGHT; 
 
constexpr GamepadType GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_PAIR =
  SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_PAIR; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr GamepadType GAMEPAD_TYPE_GAMECUBE =
  SDL_GAMEPAD_TYPE_GAMECUBE; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr GamepadType GAMEPAD_TYPE_COUNT =
  SDL_GAMEPAD_TYPE_COUNT; 

using GamepadButton = SDL_GamepadButton;
 
constexpr GamepadButton GAMEPAD_BUTTON_INVALID =
  SDL_GAMEPAD_BUTTON_INVALID; 
 
constexpr GamepadButton GAMEPAD_BUTTON_SOUTH =
  SDL_GAMEPAD_BUTTON_SOUTH; 
 
constexpr GamepadButton GAMEPAD_BUTTON_EAST =
  SDL_GAMEPAD_BUTTON_EAST; 
 
constexpr GamepadButton GAMEPAD_BUTTON_WEST =
  SDL_GAMEPAD_BUTTON_WEST; 
 
constexpr GamepadButton GAMEPAD_BUTTON_NORTH =
  SDL_GAMEPAD_BUTTON_NORTH; 
 
constexpr GamepadButton GAMEPAD_BUTTON_BACK =
  SDL_GAMEPAD_BUTTON_BACK; 
 
constexpr GamepadButton GAMEPAD_BUTTON_GUIDE =
  SDL_GAMEPAD_BUTTON_GUIDE; 
 
constexpr GamepadButton GAMEPAD_BUTTON_START =
  SDL_GAMEPAD_BUTTON_START; 
 
constexpr GamepadButton GAMEPAD_BUTTON_LEFT_STICK =
  SDL_GAMEPAD_BUTTON_LEFT_STICK; 
 
constexpr GamepadButton GAMEPAD_BUTTON_RIGHT_STICK =
  SDL_GAMEPAD_BUTTON_RIGHT_STICK; 
 
constexpr GamepadButton GAMEPAD_BUTTON_LEFT_SHOULDER =
  SDL_GAMEPAD_BUTTON_LEFT_SHOULDER; 
 
constexpr GamepadButton GAMEPAD_BUTTON_RIGHT_SHOULDER =
  SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER; 
 
constexpr GamepadButton GAMEPAD_BUTTON_DPAD_UP =
  SDL_GAMEPAD_BUTTON_DPAD_UP; 
 
constexpr GamepadButton GAMEPAD_BUTTON_DPAD_DOWN =
  SDL_GAMEPAD_BUTTON_DPAD_DOWN; 
 
constexpr GamepadButton GAMEPAD_BUTTON_DPAD_LEFT =
  SDL_GAMEPAD_BUTTON_DPAD_LEFT; 
 
constexpr GamepadButton GAMEPAD_BUTTON_DPAD_RIGHT =
  SDL_GAMEPAD_BUTTON_DPAD_RIGHT; 

constexpr GamepadButton GAMEPAD_BUTTON_MISC1 = SDL_GAMEPAD_BUTTON_MISC1;

constexpr GamepadButton GAMEPAD_BUTTON_RIGHT_PADDLE1 =
  SDL_GAMEPAD_BUTTON_RIGHT_PADDLE1;

constexpr GamepadButton GAMEPAD_BUTTON_LEFT_PADDLE1 =
  SDL_GAMEPAD_BUTTON_LEFT_PADDLE1;

constexpr GamepadButton GAMEPAD_BUTTON_RIGHT_PADDLE2 =
  SDL_GAMEPAD_BUTTON_RIGHT_PADDLE2;

constexpr GamepadButton GAMEPAD_BUTTON_LEFT_PADDLE2 =
  SDL_GAMEPAD_BUTTON_LEFT_PADDLE2;
 
constexpr GamepadButton GAMEPAD_BUTTON_TOUCHPAD =
  SDL_GAMEPAD_BUTTON_TOUCHPAD; 
 
constexpr GamepadButton GAMEPAD_BUTTON_MISC2 =
  SDL_GAMEPAD_BUTTON_MISC2; 

constexpr GamepadButton GAMEPAD_BUTTON_MISC3 = SDL_GAMEPAD_BUTTON_MISC3;

constexpr GamepadButton GAMEPAD_BUTTON_MISC4 = SDL_GAMEPAD_BUTTON_MISC4;
 
constexpr GamepadButton GAMEPAD_BUTTON_MISC5 =
  SDL_GAMEPAD_BUTTON_MISC5; 
 
constexpr GamepadButton GAMEPAD_BUTTON_MISC6 =
  SDL_GAMEPAD_BUTTON_MISC6; 
 
constexpr GamepadButton GAMEPAD_BUTTON_COUNT =
  SDL_GAMEPAD_BUTTON_COUNT; 

using GamepadButtonLabel = SDL_GamepadButtonLabel;
 
constexpr GamepadButtonLabel GAMEPAD_BUTTON_LABEL_UNKNOWN =
  SDL_GAMEPAD_BUTTON_LABEL_UNKNOWN; 
 
constexpr GamepadButtonLabel GAMEPAD_BUTTON_LABEL_A =
  SDL_GAMEPAD_BUTTON_LABEL_A; 
 
constexpr GamepadButtonLabel GAMEPAD_BUTTON_LABEL_B =
  SDL_GAMEPAD_BUTTON_LABEL_B; 
 
constexpr GamepadButtonLabel GAMEPAD_BUTTON_LABEL_X =
  SDL_GAMEPAD_BUTTON_LABEL_X; 
 
constexpr GamepadButtonLabel GAMEPAD_BUTTON_LABEL_Y =
  SDL_GAMEPAD_BUTTON_LABEL_Y; 
 
constexpr GamepadButtonLabel GAMEPAD_BUTTON_LABEL_CROSS =
  SDL_GAMEPAD_BUTTON_LABEL_CROSS; 
 
constexpr GamepadButtonLabel GAMEPAD_BUTTON_LABEL_CIRCLE =
  SDL_GAMEPAD_BUTTON_LABEL_CIRCLE; 
 
constexpr GamepadButtonLabel GAMEPAD_BUTTON_LABEL_SQUARE =
  SDL_GAMEPAD_BUTTON_LABEL_SQUARE; 
 
constexpr GamepadButtonLabel GAMEPAD_BUTTON_LABEL_TRIANGLE =
  SDL_GAMEPAD_BUTTON_LABEL_TRIANGLE; 

using GamepadAxis = SDL_GamepadAxis;
 
constexpr GamepadAxis GAMEPAD_AXIS_INVALID =
  SDL_GAMEPAD_AXIS_INVALID; 
 
constexpr GamepadAxis GAMEPAD_AXIS_LEFTX =
  SDL_GAMEPAD_AXIS_LEFTX; 
 
constexpr GamepadAxis GAMEPAD_AXIS_LEFTY =
  SDL_GAMEPAD_AXIS_LEFTY; 
 
constexpr GamepadAxis GAMEPAD_AXIS_RIGHTX =
  SDL_GAMEPAD_AXIS_RIGHTX; 
 
constexpr GamepadAxis GAMEPAD_AXIS_RIGHTY =
  SDL_GAMEPAD_AXIS_RIGHTY; 
 
constexpr GamepadAxis GAMEPAD_AXIS_LEFT_TRIGGER =
  SDL_GAMEPAD_AXIS_LEFT_TRIGGER; 
 
constexpr GamepadAxis GAMEPAD_AXIS_RIGHT_TRIGGER =
  SDL_GAMEPAD_AXIS_RIGHT_TRIGGER; 
 
constexpr GamepadAxis GAMEPAD_AXIS_COUNT =
  SDL_GAMEPAD_AXIS_COUNT; 

using GamepadBindingType = SDL_GamepadBindingType;
 
constexpr GamepadBindingType GAMEPAD_BINDTYPE_NONE =
  SDL_GAMEPAD_BINDTYPE_NONE; 
 
constexpr GamepadBindingType GAMEPAD_BINDTYPE_BUTTON =
  SDL_GAMEPAD_BINDTYPE_BUTTON; 
 
constexpr GamepadBindingType GAMEPAD_BINDTYPE_AXIS =
  SDL_GAMEPAD_BINDTYPE_AXIS; 
 
constexpr GamepadBindingType GAMEPAD_BINDTYPE_HAT =
  SDL_GAMEPAD_BINDTYPE_HAT; 

using GamepadBinding = SDL_GamepadBinding;

struct Gamepad : ResourceBase<GamepadRaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit Gamepad(GamepadRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr Gamepad(const Gamepad& other) = delete;

  constexpr Gamepad(Gamepad&& other) noexcept
    : Gamepad(other.release())
  {
  }
 
  constexpr Gamepad(const GamepadRef& other) = delete;
 
  constexpr Gamepad(GamepadRef&& other) = delete;

  Gamepad(JoystickID instance_id);

  ~Gamepad() { SDL_CloseGamepad(get()); }

  constexpr Gamepad& operator=(Gamepad&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }

  Gamepad& operator=(const Gamepad& other) = delete;

  void Close();

  StringResult GetMapping();

  PropertiesRef GetProperties();

  JoystickID GetID();

  const char* GetName();

  const char* GetPath();

  GamepadType GetType();

  GamepadType GetRealType();

  int GetPlayerIndex();

  void SetPlayerIndex(int player_index);

  Uint16 GetVendor();

  Uint16 GetProduct();

  Uint16 GetProductVersion();

  Uint16 GetFirmwareVersion();

  const char* GetSerial();

  Uint64 GetSteamHandle();

  JoystickConnectionState GetConnectionState();

  PowerState GetPowerInfo(int* percent);

  bool Connected();

  JoystickRef GetJoystick();

  OwnArray<GamepadBinding*> GetBindings();

  bool HasAxis(GamepadAxis axis);

  Sint16 GetAxis(GamepadAxis axis);

  bool HasButton(GamepadButton button);

  bool GetButton(GamepadButton button);

  GamepadButtonLabel GetButtonLabel(GamepadButton button);

  int GetNumTouchpads();

  int GetNumTouchpadFingers(int touchpad);

  void GetTouchpadFinger(int touchpad,
                         int finger,
                         bool* down,
                         float* x,
                         float* y,
                         float* pressure);

  bool HasSensor(SensorType type);

  void SetSensorEnabled(SensorType type, bool enabled);

  bool SensorEnabled(SensorType type);

  float GetSensorDataRate(SensorType type);

  void GetSensorData(SensorType type, float* data, int num_values);

  void Rumble(Uint16 low_frequency_rumble,
              Uint16 high_frequency_rumble,
              Uint32 duration_ms);

  void RumbleTriggers(Uint16 left_rumble,
                      Uint16 right_rumble,
                      Uint32 duration_ms);

  void SetLED(Uint8 red, Uint8 green, Uint8 blue);

  void SendEffect(const void* data, int size);

  const char* GetAppleSFSymbolsNameForButton(GamepadButton button);

  const char* GetAppleSFSymbolsNameForAxis(GamepadAxis axis);
};

inline int AddGamepadMapping(StringParam mapping)
{
  return SDL_AddGamepadMapping(mapping);
}

inline int AddGamepadMappingsFromIO(IOStreamRef src, bool closeio)
{
  return SDL_AddGamepadMappingsFromIO(src, closeio);
}

inline int AddGamepadMappingsFromFile(StringParam file)
{
  return SDL_AddGamepadMappingsFromFile(file);
}

inline void ReloadGamepadMappings() { CheckError(SDL_ReloadGamepadMappings()); }

inline OwnArray<char*> GetGamepadMappings()
{
  int count;
  auto data = CheckError(SDL_GetGamepadMappings(&count));
  return OwnArray<char*>(data);
}

inline StringResult GetGamepadMappingForGUID(GUID guid)
{
  return StringResult(SDL_GetGamepadMappingForGUID(guid));
}

inline StringResult GetGamepadMapping(GamepadRef gamepad)
{
  return StringResult(SDL_GetGamepadMapping(gamepad));
}
 
inline StringResult Gamepad::GetMapping()
{
  return SDL::GetGamepadMapping(get());
}

inline void SetGamepadMapping(JoystickID instance_id, StringParam mapping)
{
  CheckError(SDL_SetGamepadMapping(instance_id, mapping));
}

inline bool HasGamepad() { return SDL_HasGamepad(); }

inline OwnArray<JoystickID> GetGamepads()
{
  int count;
  auto r = reinterpret_cast<JoystickID*>(SDL_GetGamepads(&count));
  return OwnArray<JoystickID>(r, count);
}

inline bool IsGamepad(JoystickID instance_id)
{
  return SDL_IsGamepad(instance_id);
}

inline const char* GetGamepadNameForID(JoystickID instance_id)
{
  return SDL_GetGamepadNameForID(instance_id);
}

inline const char* GetGamepadPathForID(JoystickID instance_id)
{
  return SDL_GetGamepadPathForID(instance_id);
}

inline int GetGamepadPlayerIndexForID(JoystickID instance_id)
{
  return SDL_GetGamepadPlayerIndexForID(instance_id);
}

inline GUID GetGamepadGUIDForID(JoystickID instance_id)
{
  return SDL_GetGamepadGUIDForID(instance_id);
}

inline Uint16 GetGamepadVendorForID(JoystickID instance_id)
{
  return SDL_GetGamepadVendorForID(instance_id);
}

inline Uint16 GetGamepadProductForID(JoystickID instance_id)
{
  return SDL_GetGamepadProductForID(instance_id);
}

inline Uint16 GetGamepadProductVersionForID(JoystickID instance_id)
{
  return SDL_GetGamepadProductVersionForID(instance_id);
}

inline GamepadType GetGamepadTypeForID(JoystickID instance_id)
{
  return SDL_GetGamepadTypeForID(instance_id);
}

inline GamepadType GetRealGamepadTypeForID(JoystickID instance_id)
{
  return SDL_GetRealGamepadTypeForID(instance_id);
}

inline char* GetGamepadMappingForID(JoystickID instance_id)
{
  return SDL_GetGamepadMappingForID(instance_id);
}

inline Gamepad OpenGamepad(JoystickID instance_id)
{
  return Gamepad(instance_id);
}
 
inline Gamepad::Gamepad(JoystickID instance_id)
  : Gamepad(SDL_OpenGamepad(instance_id))
{
}

inline GamepadRef GetGamepadFromID(JoystickID instance_id)
{
  return {CheckError(SDL_GetGamepadFromID(instance_id))};
}

inline GamepadRef GetGamepadFromPlayerIndex(int player_index)
{
  return {SDL_GetGamepadFromPlayerIndex(player_index)};
}

inline PropertiesRef GetGamepadProperties(GamepadRef gamepad)
{
  return {CheckError(SDL_GetGamepadProperties(gamepad))};
}
 
inline PropertiesRef Gamepad::GetProperties()
{
  return SDL::GetGamepadProperties(get());
}

namespace prop::GamepadCap {
 
constexpr auto MONO_LED_BOOLEAN =
  SDL_PROP_GAMEPAD_CAP_MONO_LED_BOOLEAN; 
 
constexpr auto RGB_LED_BOOLEAN =
  SDL_PROP_GAMEPAD_CAP_RGB_LED_BOOLEAN; 
 
constexpr auto PLAYER_LED_BOOLEAN =
  SDL_PROP_GAMEPAD_CAP_PLAYER_LED_BOOLEAN; 
 
constexpr auto RUMBLE_BOOLEAN =
  SDL_PROP_GAMEPAD_CAP_RUMBLE_BOOLEAN; 
 
constexpr auto TRIGGER_RUMBLE_BOOLEAN =
  SDL_PROP_GAMEPAD_CAP_TRIGGER_RUMBLE_BOOLEAN; 
 
} // namespace prop::GamepadCap

inline JoystickID GetGamepadID(GamepadRef gamepad)
{
  return CheckError(SDL_GetGamepadID(gamepad));
}
 
inline JoystickID Gamepad::GetID() { return SDL::GetGamepadID(get()); }

inline const char* GetGamepadName(GamepadRef gamepad)
{
  return SDL_GetGamepadName(gamepad);
}
 
inline const char* Gamepad::GetName() { return SDL::GetGamepadName(get()); }

inline const char* GetGamepadPath(GamepadRef gamepad)
{
  return SDL_GetGamepadPath(gamepad);
}
 
inline const char* Gamepad::GetPath() { return SDL::GetGamepadPath(get()); }

inline GamepadType GetGamepadType(GamepadRef gamepad)
{
  return SDL_GetGamepadType(gamepad);
}
 
inline GamepadType Gamepad::GetType() { return SDL::GetGamepadType(get()); }

inline GamepadType GetRealGamepadType(GamepadRef gamepad)
{
  return SDL_GetRealGamepadType(gamepad);
}
 
inline GamepadType Gamepad::GetRealType()
{
  return SDL::GetRealGamepadType(get());
}

inline int GetGamepadPlayerIndex(GamepadRef gamepad)
{
  return SDL_GetGamepadPlayerIndex(gamepad);
}
 
inline int Gamepad::GetPlayerIndex()
{
  return SDL::GetGamepadPlayerIndex(get());
}

inline void SetGamepadPlayerIndex(GamepadRef gamepad, int player_index)
{
  CheckError(SDL_SetGamepadPlayerIndex(gamepad, player_index));
}
 
inline void Gamepad::SetPlayerIndex(int player_index)
{
  SDL::SetGamepadPlayerIndex(get(), player_index);
}

inline Uint16 GetGamepadVendor(GamepadRef gamepad)
{
  return SDL_GetGamepadVendor(gamepad);
}
 
inline Uint16 Gamepad::GetVendor() { return SDL::GetGamepadVendor(get()); }

inline Uint16 GetGamepadProduct(GamepadRef gamepad)
{
  return SDL_GetGamepadProduct(gamepad);
}
 
inline Uint16 Gamepad::GetProduct() { return SDL::GetGamepadProduct(get()); }

inline Uint16 GetGamepadProductVersion(GamepadRef gamepad)
{
  return SDL_GetGamepadProductVersion(gamepad);
}
 
inline Uint16 Gamepad::GetProductVersion()
{
  return SDL::GetGamepadProductVersion(get());
}

inline Uint16 GetGamepadFirmwareVersion(GamepadRef gamepad)
{
  return SDL_GetGamepadFirmwareVersion(gamepad);
}
 
inline Uint16 Gamepad::GetFirmwareVersion()
{
  return SDL::GetGamepadFirmwareVersion(get());
}

inline const char* GetGamepadSerial(GamepadRef gamepad)
{
  return SDL_GetGamepadSerial(gamepad);
}
 
inline const char* Gamepad::GetSerial() { return SDL::GetGamepadSerial(get()); }

inline Uint64 GetGamepadSteamHandle(GamepadRef gamepad)
{
  return SDL_GetGamepadSteamHandle(gamepad);
}
 
inline Uint64 Gamepad::GetSteamHandle()
{
  return SDL::GetGamepadSteamHandle(get());
}

inline JoystickConnectionState GetGamepadConnectionState(GamepadRef gamepad)
{
  return CheckError(SDL_GetGamepadConnectionState(gamepad));
}
 
inline JoystickConnectionState Gamepad::GetConnectionState()
{
  return SDL::GetGamepadConnectionState(get());
}

inline PowerState GetGamepadPowerInfo(GamepadRef gamepad, int* percent)
{
  return SDL_GetGamepadPowerInfo(gamepad, percent);
}
 
inline PowerState Gamepad::GetPowerInfo(int* percent)
{
  return SDL::GetGamepadPowerInfo(get(), percent);
}

inline bool GamepadConnected(GamepadRef gamepad)
{
  return SDL_GamepadConnected(gamepad);
}
 
inline bool Gamepad::Connected() { return SDL::GamepadConnected(get()); }

inline JoystickRef GetGamepadJoystick(GamepadRef gamepad)
{
  return CheckError(SDL_GetGamepadJoystick(gamepad));
}
 
inline JoystickRef Gamepad::GetJoystick()
{
  return SDL::GetGamepadJoystick(get());
}

inline void SetGamepadEventsEnabled(bool enabled)
{
  SDL_SetGamepadEventsEnabled(enabled);
}

inline bool GamepadEventsEnabled() { return SDL_GamepadEventsEnabled(); }

inline OwnArray<GamepadBinding*> GetGamepadBindings(GamepadRef gamepad)
{
  int count;
  auto r = (SDL_GetGamepadBindings(gamepad, &count));
  return OwnArray<GamepadBinding*>(r, count);
}
 
inline OwnArray<GamepadBinding*> Gamepad::GetBindings()
{
  return SDL::GetGamepadBindings(get());
}

inline void UpdateGamepads() { SDL_UpdateGamepads(); }

inline GamepadType GetGamepadTypeFromString(StringParam str)
{
  return SDL_GetGamepadTypeFromString(str);
}

inline const char* GetGamepadStringForType(GamepadType type)
{
  return SDL_GetGamepadStringForType(type);
}

inline GamepadAxis GetGamepadAxisFromString(StringParam str)
{
  return SDL_GetGamepadAxisFromString(str);
}

inline const char* GetGamepadStringForAxis(GamepadAxis axis)
{
  return SDL_GetGamepadStringForAxis(axis);
}

inline bool GamepadHasAxis(GamepadRef gamepad, GamepadAxis axis)
{
  return SDL_GamepadHasAxis(gamepad, axis);
}
 
inline bool Gamepad::HasAxis(GamepadAxis axis)
{
  return SDL::GamepadHasAxis(get(), axis);
}

inline Sint16 GetGamepadAxis(GamepadRef gamepad, GamepadAxis axis)
{
  return SDL_GetGamepadAxis(gamepad, axis);
}
 
inline Sint16 Gamepad::GetAxis(GamepadAxis axis)
{
  return SDL::GetGamepadAxis(get(), axis);
}

inline GamepadButton GetGamepadButtonFromString(StringParam str)
{
  return SDL_GetGamepadButtonFromString(str);
}

inline const char* GetGamepadStringForButton(GamepadButton button)
{
  return SDL_GetGamepadStringForButton(button);
}

inline bool GamepadHasButton(GamepadRef gamepad, GamepadButton button)
{
  return SDL_GamepadHasButton(gamepad, button);
}
 
inline bool Gamepad::HasButton(GamepadButton button)
{
  return SDL::GamepadHasButton(get(), button);
}

inline bool GetGamepadButton(GamepadRef gamepad, GamepadButton button)
{
  return SDL_GetGamepadButton(gamepad, button);
}
 
inline bool Gamepad::GetButton(GamepadButton button)
{
  return SDL::GetGamepadButton(get(), button);
}

inline GamepadButtonLabel GetGamepadButtonLabelForType(GamepadType type,
                                                       GamepadButton button)
{
  return SDL_GetGamepadButtonLabelForType(type, button);
}

inline GamepadButtonLabel GetGamepadButtonLabel(GamepadRef gamepad,
                                                GamepadButton button)
{
  return SDL_GetGamepadButtonLabel(gamepad, button);
}
 
inline GamepadButtonLabel Gamepad::GetButtonLabel(GamepadButton button)
{
  return SDL::GetGamepadButtonLabel(get(), button);
}

inline int GetNumGamepadTouchpads(GamepadRef gamepad)
{
  return SDL_GetNumGamepadTouchpads(gamepad);
}
 
inline int Gamepad::GetNumTouchpads()
{
  return SDL::GetNumGamepadTouchpads(get());
}

inline int GetNumGamepadTouchpadFingers(GamepadRef gamepad, int touchpad)
{
  return SDL_GetNumGamepadTouchpadFingers(gamepad, touchpad);
}
 
inline int Gamepad::GetNumTouchpadFingers(int touchpad)
{
  return SDL::GetNumGamepadTouchpadFingers(get(), touchpad);
}

inline void GetGamepadTouchpadFinger(GamepadRef gamepad,
                                     int touchpad,
                                     int finger,
                                     bool* down,
                                     float* x,
                                     float* y,
                                     float* pressure)
{
  CheckError(SDL_GetGamepadTouchpadFinger(
    gamepad, touchpad, finger, down, x, y, pressure));
}
 
inline void Gamepad::GetTouchpadFinger(int touchpad,
                                       int finger,
                                       bool* down,
                                       float* x,
                                       float* y,
                                       float* pressure)
{
  SDL::GetGamepadTouchpadFinger(get(), touchpad, finger, down, x, y, pressure);
}

inline bool GamepadHasSensor(GamepadRef gamepad, SensorType type)
{
  return SDL_GamepadHasSensor(gamepad, type);
}
 
inline bool Gamepad::HasSensor(SensorType type)
{
  return SDL::GamepadHasSensor(get(), type);
}

inline void SetGamepadSensorEnabled(GamepadRef gamepad,
                                    SensorType type,
                                    bool enabled)
{
  CheckError(SDL_SetGamepadSensorEnabled(gamepad, type, enabled));
}
 
inline void Gamepad::SetSensorEnabled(SensorType type, bool enabled)
{
  SDL::SetGamepadSensorEnabled(get(), type, enabled);
}

inline bool GamepadSensorEnabled(GamepadRef gamepad, SensorType type)
{
  return SDL_GamepadSensorEnabled(gamepad, type);
}
 
inline bool Gamepad::SensorEnabled(SensorType type)
{
  return SDL::GamepadSensorEnabled(get(), type);
}

inline float GetGamepadSensorDataRate(GamepadRef gamepad, SensorType type)
{
  return SDL_GetGamepadSensorDataRate(gamepad, type);
}
 
inline float Gamepad::GetSensorDataRate(SensorType type)
{
  return SDL::GetGamepadSensorDataRate(get(), type);
}

inline void GetGamepadSensorData(GamepadRef gamepad,
                                 SensorType type,
                                 float* data,
                                 int num_values)
{
  CheckError(SDL_GetGamepadSensorData(gamepad, type, data, num_values));
}
 
inline void Gamepad::GetSensorData(SensorType type, float* data, int num_values)
{
  SDL::GetGamepadSensorData(get(), type, data, num_values);
}

inline void RumbleGamepad(GamepadRef gamepad,
                          Uint16 low_frequency_rumble,
                          Uint16 high_frequency_rumble,
                          Uint32 duration_ms)
{
  CheckError(SDL_RumbleGamepad(
    gamepad, low_frequency_rumble, high_frequency_rumble, duration_ms));
}
 
inline void Gamepad::Rumble(Uint16 low_frequency_rumble,
                            Uint16 high_frequency_rumble,
                            Uint32 duration_ms)
{
  SDL::RumbleGamepad(
    get(), low_frequency_rumble, high_frequency_rumble, duration_ms);
}

inline void RumbleGamepadTriggers(GamepadRef gamepad,
                                  Uint16 left_rumble,
                                  Uint16 right_rumble,
                                  Uint32 duration_ms)
{
  CheckError(
    SDL_RumbleGamepadTriggers(gamepad, left_rumble, right_rumble, duration_ms));
}
 
inline void Gamepad::RumbleTriggers(Uint16 left_rumble,
                                    Uint16 right_rumble,
                                    Uint32 duration_ms)
{
  SDL::RumbleGamepadTriggers(get(), left_rumble, right_rumble, duration_ms);
}

inline void SetGamepadLED(GamepadRef gamepad,
                          Uint8 red,
                          Uint8 green,
                          Uint8 blue)
{
  CheckError(SDL_SetGamepadLED(gamepad, red, green, blue));
}
 
inline void Gamepad::SetLED(Uint8 red, Uint8 green, Uint8 blue)
{
  SDL::SetGamepadLED(get(), red, green, blue);
}

inline void SendGamepadEffect(GamepadRef gamepad, const void* data, int size)
{
  CheckError(SDL_SendGamepadEffect(gamepad, data, size));
}
 
inline void Gamepad::SendEffect(const void* data, int size)
{
  SDL::SendGamepadEffect(get(), data, size);
}

inline void CloseGamepad(GamepadRaw gamepad) { SDL_CloseGamepad(gamepad); }
 
inline void Gamepad::Close() { CloseGamepad(release()); }

inline const char* GetGamepadAppleSFSymbolsNameForButton(GamepadRef gamepad,
                                                         GamepadButton button)
{
  return SDL_GetGamepadAppleSFSymbolsNameForButton(gamepad, button);
}
 
inline const char* Gamepad::GetAppleSFSymbolsNameForButton(GamepadButton button)
{
  return SDL::GetGamepadAppleSFSymbolsNameForButton(get(), button);
}

inline const char* GetGamepadAppleSFSymbolsNameForAxis(GamepadRef gamepad,
                                                       GamepadAxis axis)
{
  return SDL_GetGamepadAppleSFSymbolsNameForAxis(gamepad, axis);
}
 
inline const char* Gamepad::GetAppleSFSymbolsNameForAxis(GamepadAxis axis)
{
  return SDL::GetGamepadAppleSFSymbolsNameForAxis(get(), axis);
}

 
} // namespace SDL
 
#endif /* SDL3PP_GAMEPAD_H_ */