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*;
 
// Forward decl
struct GamepadRef;
 
struct GamepadParam
{
  GamepadRaw value; 
 
  constexpr GamepadParam(GamepadRaw value)
    : value(value)
  {
  }
 
  constexpr GamepadParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const GamepadParam& other) const = default;
 
  constexpr operator GamepadRaw() const { return value; }
};
 
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;
 
class Gamepad
{
  GamepadRaw m_resource = nullptr;
 
public:
  constexpr Gamepad(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit Gamepad(const GamepadRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr Gamepad(const Gamepad& other) noexcept = default;
 
public:
  constexpr Gamepad(Gamepad&& other) noexcept
    : Gamepad(other.release())
  {
  }
 
  constexpr Gamepad(const GamepadRef& other) = delete;
 
  constexpr Gamepad(GamepadRef&& other) = delete;
 
  Gamepad(JoystickID instance_id)
    : m_resource(SDL_OpenGamepad(instance_id))
  {
  }
 
  ~Gamepad() { SDL_CloseGamepad(m_resource); }
 
  constexpr Gamepad& operator=(Gamepad&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr Gamepad& operator=(const Gamepad& other) noexcept = default;
 
public:
  constexpr GamepadRaw get() const noexcept { return m_resource; }
 
  constexpr GamepadRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Gamepad& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator GamepadParam() const noexcept { return {m_resource}; }
 
  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);
};
 
struct GamepadRef : Gamepad
{
  using Gamepad::Gamepad;
 
  GamepadRef(GamepadParam resource) noexcept
    : Gamepad(resource.value)
  {
  }
 
  GamepadRef(GamepadRaw resource) noexcept
    : Gamepad(resource)
  {
  }
 
  constexpr GamepadRef(const GamepadRef& other) noexcept = default;
 
  ~GamepadRef() { release(); }
};
 
inline int AddGamepadMapping(StringParam mapping)
{
  return SDL_AddGamepadMapping(mapping);
}
 
inline int AddGamepadMappingsFromIO(IOStreamParam 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 = SDL_GetGamepadMappings(&count);
  return OwnArray<char*>(data);
}
 
inline StringResult GetGamepadMappingForGUID(GUID guid)
{
  return StringResult(SDL_GetGamepadMappingForGUID(guid));
}
 
inline StringResult GetGamepadMapping(GamepadParam gamepad)
{
  return StringResult(SDL_GetGamepadMapping(gamepad));
}
 
inline StringResult Gamepad::GetMapping()
{
  return SDL::GetGamepadMapping(m_resource);
}
 
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 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(GamepadParam gamepad)
{
  return {CheckError(SDL_GetGamepadProperties(gamepad))};
}
 
inline PropertiesRef Gamepad::GetProperties()
{
  return SDL::GetGamepadProperties(m_resource);
}
 
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(GamepadParam gamepad)
{
  return CheckError(SDL_GetGamepadID(gamepad));
}
 
inline JoystickID Gamepad::GetID() { return SDL::GetGamepadID(m_resource); }
 
inline const char* GetGamepadName(GamepadParam gamepad)
{
  return SDL_GetGamepadName(gamepad);
}
 
inline const char* Gamepad::GetName()
{
  return SDL::GetGamepadName(m_resource);
}
 
inline const char* GetGamepadPath(GamepadParam gamepad)
{
  return SDL_GetGamepadPath(gamepad);
}
 
inline const char* Gamepad::GetPath()
{
  return SDL::GetGamepadPath(m_resource);
}
 
inline GamepadType GetGamepadType(GamepadParam gamepad)
{
  return SDL_GetGamepadType(gamepad);
}
 
inline GamepadType Gamepad::GetType()
{
  return SDL::GetGamepadType(m_resource);
}
 
inline GamepadType GetRealGamepadType(GamepadParam gamepad)
{
  return SDL_GetRealGamepadType(gamepad);
}
 
inline GamepadType Gamepad::GetRealType()
{
  return SDL::GetRealGamepadType(m_resource);
}
 
inline int GetGamepadPlayerIndex(GamepadParam gamepad)
{
  return SDL_GetGamepadPlayerIndex(gamepad);
}
 
inline int Gamepad::GetPlayerIndex()
{
  return SDL::GetGamepadPlayerIndex(m_resource);
}
 
inline void SetGamepadPlayerIndex(GamepadParam gamepad, int player_index)
{
  CheckError(SDL_SetGamepadPlayerIndex(gamepad, player_index));
}
 
inline void Gamepad::SetPlayerIndex(int player_index)
{
  SDL::SetGamepadPlayerIndex(m_resource, player_index);
}
 
inline Uint16 GetGamepadVendor(GamepadParam gamepad)
{
  return SDL_GetGamepadVendor(gamepad);
}
 
inline Uint16 Gamepad::GetVendor() { return SDL::GetGamepadVendor(m_resource); }
 
inline Uint16 GetGamepadProduct(GamepadParam gamepad)
{
  return SDL_GetGamepadProduct(gamepad);
}
 
inline Uint16 Gamepad::GetProduct()
{
  return SDL::GetGamepadProduct(m_resource);
}
 
inline Uint16 GetGamepadProductVersion(GamepadParam gamepad)
{
  return SDL_GetGamepadProductVersion(gamepad);
}
 
inline Uint16 Gamepad::GetProductVersion()
{
  return SDL::GetGamepadProductVersion(m_resource);
}
 
inline Uint16 GetGamepadFirmwareVersion(GamepadParam gamepad)
{
  return SDL_GetGamepadFirmwareVersion(gamepad);
}
 
inline Uint16 Gamepad::GetFirmwareVersion()
{
  return SDL::GetGamepadFirmwareVersion(m_resource);
}
 
inline const char* GetGamepadSerial(GamepadParam gamepad)
{
  return SDL_GetGamepadSerial(gamepad);
}
 
inline const char* Gamepad::GetSerial()
{
  return SDL::GetGamepadSerial(m_resource);
}
 
inline Uint64 GetGamepadSteamHandle(GamepadParam gamepad)
{
  return SDL_GetGamepadSteamHandle(gamepad);
}
 
inline Uint64 Gamepad::GetSteamHandle()
{
  return SDL::GetGamepadSteamHandle(m_resource);
}
 
inline JoystickConnectionState GetGamepadConnectionState(GamepadParam gamepad)
{
  return CheckError(SDL_GetGamepadConnectionState(gamepad));
}
 
inline JoystickConnectionState Gamepad::GetConnectionState()
{
  return SDL::GetGamepadConnectionState(m_resource);
}
 
inline PowerState GetGamepadPowerInfo(GamepadParam gamepad, int* percent)
{
  return SDL_GetGamepadPowerInfo(gamepad, percent);
}
 
inline PowerState Gamepad::GetPowerInfo(int* percent)
{
  return SDL::GetGamepadPowerInfo(m_resource, percent);
}
 
inline bool GamepadConnected(GamepadParam gamepad)
{
  return SDL_GamepadConnected(gamepad);
}
 
inline bool Gamepad::Connected() { return SDL::GamepadConnected(m_resource); }
 
inline JoystickRef GetGamepadJoystick(GamepadParam gamepad)
{
  return {SDL_GetGamepadJoystick(gamepad)};
}
 
inline JoystickRef Gamepad::GetJoystick()
{
  return SDL::GetGamepadJoystick(m_resource);
}
 
inline void SetGamepadEventsEnabled(bool enabled)
{
  SDL_SetGamepadEventsEnabled(enabled);
}
 
inline bool GamepadEventsEnabled() { return SDL_GamepadEventsEnabled(); }
 
inline OwnArray<GamepadBinding*> GetGamepadBindings(GamepadParam gamepad)
{
  int count;
  auto r = (SDL_GetGamepadBindings(gamepad, &count));
  return OwnArray<GamepadBinding*>(r, count);
}
 
inline OwnArray<GamepadBinding*> Gamepad::GetBindings()
{
  return SDL::GetGamepadBindings(m_resource);
}
 
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(GamepadParam gamepad, GamepadAxis axis)
{
  return SDL_GamepadHasAxis(gamepad, axis);
}
 
inline bool Gamepad::HasAxis(GamepadAxis axis)
{
  return SDL::GamepadHasAxis(m_resource, axis);
}
 
inline Sint16 GetGamepadAxis(GamepadParam gamepad, GamepadAxis axis)
{
  return SDL_GetGamepadAxis(gamepad, axis);
}
 
inline Sint16 Gamepad::GetAxis(GamepadAxis axis)
{
  return SDL::GetGamepadAxis(m_resource, axis);
}
 
inline GamepadButton GetGamepadButtonFromString(StringParam str)
{
  return SDL_GetGamepadButtonFromString(str);
}
 
inline const char* GetGamepadStringForButton(GamepadButton button)
{
  return SDL_GetGamepadStringForButton(button);
}
 
inline bool GamepadHasButton(GamepadParam gamepad, GamepadButton button)
{
  return SDL_GamepadHasButton(gamepad, button);
}
 
inline bool Gamepad::HasButton(GamepadButton button)
{
  return SDL::GamepadHasButton(m_resource, button);
}
 
inline bool GetGamepadButton(GamepadParam gamepad, GamepadButton button)
{
  return SDL_GetGamepadButton(gamepad, button);
}
 
inline bool Gamepad::GetButton(GamepadButton button)
{
  return SDL::GetGamepadButton(m_resource, button);
}
 
inline GamepadButtonLabel GetGamepadButtonLabelForType(GamepadType type,
                                                       GamepadButton button)
{
  return SDL_GetGamepadButtonLabelForType(type, button);
}
 
inline GamepadButtonLabel GetGamepadButtonLabel(GamepadParam gamepad,
                                                GamepadButton button)
{
  return SDL_GetGamepadButtonLabel(gamepad, button);
}
 
inline GamepadButtonLabel Gamepad::GetButtonLabel(GamepadButton button)
{
  return SDL::GetGamepadButtonLabel(m_resource, button);
}
 
inline int GetNumGamepadTouchpads(GamepadParam gamepad)
{
  return SDL_GetNumGamepadTouchpads(gamepad);
}
 
inline int Gamepad::GetNumTouchpads()
{
  return SDL::GetNumGamepadTouchpads(m_resource);
}
 
inline int GetNumGamepadTouchpadFingers(GamepadParam gamepad, int touchpad)
{
  return SDL_GetNumGamepadTouchpadFingers(gamepad, touchpad);
}
 
inline int Gamepad::GetNumTouchpadFingers(int touchpad)
{
  return SDL::GetNumGamepadTouchpadFingers(m_resource, touchpad);
}
 
inline void GetGamepadTouchpadFinger(GamepadParam 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(
    m_resource, touchpad, finger, down, x, y, pressure);
}
 
inline bool GamepadHasSensor(GamepadParam gamepad, SensorType type)
{
  return SDL_GamepadHasSensor(gamepad, type);
}
 
inline bool Gamepad::HasSensor(SensorType type)
{
  return SDL::GamepadHasSensor(m_resource, type);
}
 
inline void SetGamepadSensorEnabled(GamepadParam gamepad,
                                    SensorType type,
                                    bool enabled)
{
  CheckError(SDL_SetGamepadSensorEnabled(gamepad, type, enabled));
}
 
inline void Gamepad::SetSensorEnabled(SensorType type, bool enabled)
{
  SDL::SetGamepadSensorEnabled(m_resource, type, enabled);
}
 
inline bool GamepadSensorEnabled(GamepadParam gamepad, SensorType type)
{
  return SDL_GamepadSensorEnabled(gamepad, type);
}
 
inline bool Gamepad::SensorEnabled(SensorType type)
{
  return SDL::GamepadSensorEnabled(m_resource, type);
}
 
inline float GetGamepadSensorDataRate(GamepadParam gamepad, SensorType type)
{
  return SDL_GetGamepadSensorDataRate(gamepad, type);
}
 
inline float Gamepad::GetSensorDataRate(SensorType type)
{
  return SDL::GetGamepadSensorDataRate(m_resource, type);
}
 
inline void GetGamepadSensorData(GamepadParam 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(m_resource, type, data, num_values);
}
 
inline void RumbleGamepad(GamepadParam 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(
    m_resource, low_frequency_rumble, high_frequency_rumble, duration_ms);
}
 
inline void RumbleGamepadTriggers(GamepadParam 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(
    m_resource, left_rumble, right_rumble, duration_ms);
}
 
inline void SetGamepadLED(GamepadParam 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(m_resource, red, green, blue);
}
 
inline void SendGamepadEffect(GamepadParam gamepad, const void* data, int size)
{
  CheckError(SDL_SendGamepadEffect(gamepad, data, size));
}
 
inline void Gamepad::SendEffect(const void* data, int size)
{
  SDL::SendGamepadEffect(m_resource, data, size);
}
 
inline void CloseGamepad(GamepadRaw gamepad) { SDL_CloseGamepad(gamepad); }
 
inline void Gamepad::Close() { CloseGamepad(release()); }
 
inline const char* GetGamepadAppleSFSymbolsNameForButton(GamepadParam gamepad,
                                                         GamepadButton button)
{
  return SDL_GetGamepadAppleSFSymbolsNameForButton(gamepad, button);
}
 
inline const char* Gamepad::GetAppleSFSymbolsNameForButton(GamepadButton button)
{
  return SDL::GetGamepadAppleSFSymbolsNameForButton(m_resource, button);
}
 
inline const char* GetGamepadAppleSFSymbolsNameForAxis(GamepadParam gamepad,
                                                       GamepadAxis axis)
{
  return SDL_GetGamepadAppleSFSymbolsNameForAxis(gamepad, axis);
}
 
inline const char* Gamepad::GetAppleSFSymbolsNameForAxis(GamepadAxis axis)
{
  return SDL::GetGamepadAppleSFSymbolsNameForAxis(m_resource, axis);
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_GAMEPAD_H_ */