SDL3pp_joystick.h

#ifndef SDL3PP_JOYSTICK_H_
#define SDL3PP_JOYSTICK_H_
 
#include <SDL3/SDL_joystick.h>
#include "SDL3pp_error.h"
#include "SDL3pp_guid.h"
#include "SDL3pp_mutex.h"
#include "SDL3pp_power.h"
#include "SDL3pp_properties.h"
#include "SDL3pp_rect.h"
#include "SDL3pp_sensor.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
// Forward decl
struct Joystick;
 
using JoystickRaw = SDL_Joystick*;
 
// Forward decl
struct JoystickRef;
 
struct JoystickParam
{
  JoystickRaw value; 
 
  constexpr JoystickParam(JoystickRaw value)
    : value(value)
  {
  }
 
  constexpr JoystickParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const JoystickParam& other) const = default;
 
  constexpr operator JoystickRaw() const { return value; }
};
 
using JoystickIDRaw = SDL_JoystickID;
 
using JoystickType = SDL_JoystickType;
 
constexpr JoystickType JOYSTICK_TYPE_UNKNOWN =
  SDL_JOYSTICK_TYPE_UNKNOWN; 
 
constexpr JoystickType JOYSTICK_TYPE_GAMEPAD =
  SDL_JOYSTICK_TYPE_GAMEPAD; 
 
constexpr JoystickType JOYSTICK_TYPE_WHEEL =
  SDL_JOYSTICK_TYPE_WHEEL; 
 
constexpr JoystickType JOYSTICK_TYPE_ARCADE_STICK =
  SDL_JOYSTICK_TYPE_ARCADE_STICK; 
 
constexpr JoystickType JOYSTICK_TYPE_FLIGHT_STICK =
  SDL_JOYSTICK_TYPE_FLIGHT_STICK; 
 
constexpr JoystickType JOYSTICK_TYPE_DANCE_PAD =
  SDL_JOYSTICK_TYPE_DANCE_PAD; 
 
constexpr JoystickType JOYSTICK_TYPE_GUITAR =
  SDL_JOYSTICK_TYPE_GUITAR; 
 
constexpr JoystickType JOYSTICK_TYPE_DRUM_KIT =
  SDL_JOYSTICK_TYPE_DRUM_KIT; 
 
constexpr JoystickType JOYSTICK_TYPE_ARCADE_PAD =
  SDL_JOYSTICK_TYPE_ARCADE_PAD; 
 
constexpr JoystickType JOYSTICK_TYPE_THROTTLE =
  SDL_JOYSTICK_TYPE_THROTTLE; 
 
constexpr JoystickType JOYSTICK_TYPE_COUNT =
  SDL_JOYSTICK_TYPE_COUNT; 
 
class JoystickID
{
  JoystickIDRaw m_joystickID;
 
public:
  constexpr JoystickID(JoystickIDRaw joystickID = {})
    : m_joystickID(joystickID)
  {
  }
 
  constexpr operator JoystickIDRaw() const { return m_joystickID; }
 
  const char* GetJoystickNameForID();
 
  const char* GetJoystickPathForID();
 
  int GetJoystickPlayerIndexForID();
 
  GUID GetJoystickGUIDForID();
 
  Uint16 GetJoystickVendorForID();
 
  Uint16 GetJoystickProductForID();
 
  Uint16 GetJoystickProductVersionForID();
 
  JoystickType GetJoystickTypeForID();
 
  Joystick OpenJoystick();
 
  JoystickRef GetJoystickFromID();
 
  void DetachVirtualJoystick();
 
  bool IsJoystickVirtual();
};
 
using JoystickConnectionState = SDL_JoystickConnectionState;
 
constexpr JoystickConnectionState JOYSTICK_CONNECTION_INVALID =
  SDL_JOYSTICK_CONNECTION_INVALID; 
 
constexpr JoystickConnectionState JOYSTICK_CONNECTION_UNKNOWN =
  SDL_JOYSTICK_CONNECTION_UNKNOWN; 
 
constexpr JoystickConnectionState JOYSTICK_CONNECTION_WIRED =
  SDL_JOYSTICK_CONNECTION_WIRED; 
 
constexpr JoystickConnectionState JOYSTICK_CONNECTION_WIRELESS =
  SDL_JOYSTICK_CONNECTION_WIRELESS; 
 
using HatState = Uint8;
 
constexpr Uint8 HAT_CENTERED = SDL_HAT_CENTERED; 
 
constexpr Uint8 HAT_UP = SDL_HAT_UP; 
 
constexpr Uint8 HAT_RIGHT = SDL_HAT_RIGHT; 
 
constexpr Uint8 HAT_DOWN = SDL_HAT_DOWN; 
 
constexpr Uint8 HAT_LEFT = SDL_HAT_LEFT; 
 
constexpr Uint8 HAT_RIGHTUP = SDL_HAT_RIGHTUP; 
 
constexpr Uint8 HAT_RIGHTDOWN = SDL_HAT_RIGHTDOWN; 
 
constexpr Uint8 HAT_LEFTUP = SDL_HAT_LEFTUP; 
 
constexpr Uint8 HAT_LEFTDOWN = SDL_HAT_LEFTDOWN; 
 
class Joystick
{
  JoystickRaw m_resource = nullptr;
 
public:
  constexpr Joystick() = default;
 
  constexpr explicit Joystick(const JoystickRaw resource)
    : m_resource(resource)
  {
  }
 
  constexpr Joystick(const Joystick& other) = delete;
 
  constexpr Joystick(Joystick&& other)
    : Joystick(other.release())
  {
  }
 
  constexpr Joystick(const JoystickRef& other) = delete;
 
  constexpr Joystick(JoystickRef&& other) = delete;
 
  Joystick(JoystickID instance_id)
    : m_resource(CheckError(SDL_OpenJoystick(instance_id)))
  {
  }
 
  ~Joystick() { SDL_CloseJoystick(m_resource); }
 
  Joystick& operator=(Joystick other)
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  constexpr JoystickRaw get() const { return m_resource; }
 
  constexpr JoystickRaw release()
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Joystick& other) const = default;
 
  constexpr bool operator==(std::nullptr_t _) const { return !m_resource; }
 
  constexpr explicit operator bool() const { return !!m_resource; }
 
  constexpr operator JoystickParam() const { return {m_resource}; }
 
  void Close();
 
  void SetVirtualAxis(int axis, Sint16 value);
 
  void SetVirtualBall(int ball, Sint16 xrel, Sint16 yrel);
 
  void SetVirtualButton(int button, bool down);
 
  void SetVirtualHat(int hat, Uint8 value);
 
  void SetVirtualTouchpad(int touchpad,
                          int finger,
                          bool down,
                          const FPointRaw& p,
                          float pressure);
 
  void SendVirtualSensorData(SensorType type,
                             Uint64 sensor_timestamp,
                             const float* data,
                             int num_values);
 
  PropertiesRef GetProperties();
 
  const char* GetName();
 
  const char* GetPath();
 
  int GetPlayerIndex();
 
  void SetPlayerIndex(int player_index);
 
  GUID GetGUID();
 
  Uint16 GetVendor();
 
  Uint16 GetProduct();
 
  Uint16 GetProductVersion();
 
  Uint16 GetFirmwareVersion();
 
  const char* GetSerial();
 
  JoystickType GetType();
 
  bool Connected();
 
  JoystickID GetID();
 
  int GetNumAxes();
 
  int GetNumBalls();
 
  int GetNumHats();
 
  int GetNumButtons();
 
  Sint16 GetAxis(int axis);
 
  bool GetAxisInitialState(int axis, Sint16* state);
 
  void GetBall(int ball, int* dx, int* dy);
 
  Uint8 GetHat(int hat);
 
  bool GetButton(int button);
 
  bool 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);
 
  JoystickConnectionState GetConnectionState();
 
  PowerState GetPowerInfo(int* percent);
};
 
struct JoystickRef : Joystick
{
  JoystickRef(JoystickParam resource)
    : Joystick(resource.value)
  {
  }
 
  JoystickRef(const JoystickRef& other)
    : Joystick(other.get())
  {
  }
 
  ~JoystickRef() { release(); }
};
 
constexpr int JOYSTICK_AXIS_MAX = SDL_JOYSTICK_AXIS_MAX;
 
constexpr int JOYSTICK_AXIS_MIN = SDL_JOYSTICK_AXIS_MIN;
 
inline void LockJoysticks(void) { SDL_LockJoysticks(); }
 
inline void UnlockJoysticks(void) { SDL_UnlockJoysticks(); }
 
inline bool HasJoystick() { return SDL_HasJoystick(); }
 
inline OwnArray<JoystickID> GetJoysticks()
{
  int count;
  auto r = reinterpret_cast<JoystickID*>(SDL_GetJoysticks(&count));
  return OwnArray<JoystickID>(r, count);
}
 
inline const char* GetJoystickNameForID(JoystickID instance_id)
{
  return SDL_GetJoystickNameForID(instance_id);
}
 
inline const char* JoystickID::GetJoystickNameForID()
{
  return SDL::GetJoystickNameForID(m_joystickID);
}
 
inline const char* GetJoystickPathForID(JoystickID instance_id)
{
  return SDL_GetJoystickPathForID(instance_id);
}
 
inline const char* JoystickID::GetJoystickPathForID()
{
  return SDL::GetJoystickPathForID(m_joystickID);
}
 
inline int GetJoystickPlayerIndexForID(JoystickID instance_id)
{
  return SDL_GetJoystickPlayerIndexForID(instance_id);
}
 
inline int JoystickID::GetJoystickPlayerIndexForID()
{
  return SDL::GetJoystickPlayerIndexForID(m_joystickID);
}
 
inline GUID GetJoystickGUIDForID(JoystickID instance_id)
{
  return SDL_GetJoystickGUIDForID(instance_id);
}
 
inline GUID JoystickID::GetJoystickGUIDForID()
{
  return SDL::GetJoystickGUIDForID(m_joystickID);
}
 
inline Uint16 GetJoystickVendorForID(JoystickID instance_id)
{
  return SDL_GetJoystickVendorForID(instance_id);
}
 
inline Uint16 JoystickID::GetJoystickVendorForID()
{
  return SDL::GetJoystickVendorForID(m_joystickID);
}
 
inline Uint16 GetJoystickProductForID(JoystickID instance_id)
{
  return SDL_GetJoystickProductForID(instance_id);
}
 
inline Uint16 JoystickID::GetJoystickProductForID()
{
  return SDL::GetJoystickProductForID(m_joystickID);
}
 
inline Uint16 GetJoystickProductVersionForID(JoystickID instance_id)
{
  return SDL_GetJoystickProductVersionForID(instance_id);
}
 
inline Uint16 JoystickID::GetJoystickProductVersionForID()
{
  return SDL::GetJoystickProductVersionForID(m_joystickID);
}
 
inline JoystickType GetJoystickTypeForID(JoystickID instance_id)
{
  return SDL_GetJoystickTypeForID(instance_id);
}
 
inline JoystickType JoystickID::GetJoystickTypeForID()
{
  return SDL::GetJoystickTypeForID(m_joystickID);
}
 
inline Joystick OpenJoystick(JoystickID instance_id)
{
  return Joystick(instance_id);
}
 
inline Joystick JoystickID::OpenJoystick() { return Joystick(m_joystickID); }
 
inline JoystickRef GetJoystickFromID(JoystickID instance_id)
{
  return {CheckError(SDL_GetJoystickFromID(instance_id))};
}
 
inline JoystickRef JoystickID::GetJoystickFromID()
{
  return SDL::GetJoystickFromID(m_joystickID);
}
 
inline JoystickRef GetJoystickFromPlayerIndex(int player_index)
{
  return {CheckError(SDL_GetJoystickFromPlayerIndex(player_index))};
}
 
using VirtualJoystickTouchpadDesc = SDL_VirtualJoystickTouchpadDesc;
 
using VirtualJoystickSensorDesc = SDL_VirtualJoystickSensorDesc;
 
using VirtualJoystickDesc = SDL_VirtualJoystickDesc;
 
inline JoystickID AttachVirtualJoystick(const VirtualJoystickDesc& desc)
{
  return SDL_AttachVirtualJoystick(&desc);
}
 
inline void DetachVirtualJoystick(JoystickID instance_id)
{
  CheckError(SDL_DetachVirtualJoystick(instance_id));
}
 
inline void JoystickID::DetachVirtualJoystick()
{
  SDL::DetachVirtualJoystick(m_joystickID);
}
 
inline bool IsJoystickVirtual(JoystickID instance_id)
{
  return SDL_IsJoystickVirtual(instance_id);
}
 
inline bool JoystickID::IsJoystickVirtual()
{
  return SDL::IsJoystickVirtual(m_joystickID);
}
 
inline void SetJoystickVirtualAxis(JoystickParam joystick,
                                   int axis,
                                   Sint16 value)
{
  CheckError(SDL_SetJoystickVirtualAxis(joystick, axis, value));
}
 
inline void Joystick::SetVirtualAxis(int axis, Sint16 value)
{
  SDL::SetJoystickVirtualAxis(m_resource, axis, value);
}
 
inline void SetJoystickVirtualBall(JoystickParam joystick,
                                   int ball,
                                   Sint16 xrel,
                                   Sint16 yrel)
{
  CheckError(SDL_SetJoystickVirtualBall(joystick, ball, xrel, yrel));
}
 
inline void Joystick::SetVirtualBall(int ball, Sint16 xrel, Sint16 yrel)
{
  SDL::SetJoystickVirtualBall(m_resource, ball, xrel, yrel);
}
 
inline void SetJoystickVirtualButton(JoystickParam joystick,
                                     int button,
                                     bool down)
{
  CheckError(SDL_SetJoystickVirtualButton(joystick, button, down));
}
 
inline void Joystick::SetVirtualButton(int button, bool down)
{
  SDL::SetJoystickVirtualButton(m_resource, button, down);
}
 
inline void SetJoystickVirtualHat(JoystickParam joystick, int hat, Uint8 value)
{
  CheckError(SDL_SetJoystickVirtualHat(joystick, hat, value));
}
 
inline void Joystick::SetVirtualHat(int hat, Uint8 value)
{
  SDL::SetJoystickVirtualHat(m_resource, hat, value);
}
 
inline void SetJoystickVirtualTouchpad(JoystickParam joystick,
                                       int touchpad,
                                       int finger,
                                       bool down,
                                       const FPointRaw& p,
                                       float pressure)
{
  CheckError(SDL_SetJoystickVirtualTouchpad(
    joystick, touchpad, finger, down, p.x, p.y, pressure));
}
 
inline void Joystick::SetVirtualTouchpad(int touchpad,
                                         int finger,
                                         bool down,
                                         const FPointRaw& p,
                                         float pressure)
{
  SDL::SetJoystickVirtualTouchpad(
    m_resource, touchpad, finger, down, p, pressure);
}
 
inline void SendJoystickVirtualSensorData(JoystickParam joystick,
                                          SensorType type,
                                          Uint64 sensor_timestamp,
                                          const float* data,
                                          int num_values)
{
  CheckError(SDL_SendJoystickVirtualSensorData(
    joystick, type, sensor_timestamp, data, num_values));
}
 
inline void Joystick::SendVirtualSensorData(SensorType type,
                                            Uint64 sensor_timestamp,
                                            const float* data,
                                            int num_values)
{
  SDL::SendJoystickVirtualSensorData(
    m_resource, type, sensor_timestamp, data, num_values);
}
 
inline PropertiesRef GetJoystickProperties(JoystickParam joystick)
{
  return {CheckError(SDL_GetJoystickProperties(joystick))};
}
 
inline PropertiesRef Joystick::GetProperties()
{
  return SDL::GetJoystickProperties(m_resource);
}
 
namespace prop::JoystickCap {
 
constexpr auto MONO_LED_BOOLEAN = SDL_PROP_JOYSTICK_CAP_MONO_LED_BOOLEAN;
 
constexpr auto RGB_LED_BOOLEAN = SDL_PROP_JOYSTICK_CAP_RGB_LED_BOOLEAN;
 
constexpr auto PLAYER_LED_BOOLEAN = SDL_PROP_JOYSTICK_CAP_PLAYER_LED_BOOLEAN;
 
constexpr auto RUMBLE_BOOLEAN = SDL_PROP_JOYSTICK_CAP_RUMBLE_BOOLEAN;
 
constexpr auto TRIGGER_RUMBLE_BOOLEAN =
  SDL_PROP_JOYSTICK_CAP_TRIGGER_RUMBLE_BOOLEAN;
 
} // namespace prop::JoystickCap
 
inline const char* GetJoystickName(JoystickParam joystick)
{
  return SDL_GetJoystickName(joystick);
}
 
inline const char* Joystick::GetName()
{
  return SDL::GetJoystickName(m_resource);
}
 
inline const char* GetJoystickPath(JoystickParam joystick)
{
  return SDL_GetJoystickPath(joystick);
}
 
inline const char* Joystick::GetPath()
{
  return SDL::GetJoystickPath(m_resource);
}
 
inline int GetJoystickPlayerIndex(JoystickParam joystick)
{
  return SDL_GetJoystickPlayerIndex(joystick);
}
 
inline int Joystick::GetPlayerIndex()
{
  return SDL::GetJoystickPlayerIndex(m_resource);
}
 
inline void SetJoystickPlayerIndex(JoystickParam joystick, int player_index)
{
  CheckError(SDL_SetJoystickPlayerIndex(joystick, player_index));
}
 
inline void Joystick::SetPlayerIndex(int player_index)
{
  SDL::SetJoystickPlayerIndex(m_resource, player_index);
}
 
inline GUID GetJoystickGUID(JoystickParam joystick)
{
  return SDL_GetJoystickGUID(joystick);
}
 
inline GUID Joystick::GetGUID() { return SDL::GetJoystickGUID(m_resource); }
 
inline Uint16 GetJoystickVendor(JoystickParam joystick)
{
  return SDL_GetJoystickVendor(joystick);
}
 
inline Uint16 Joystick::GetVendor()
{
  return SDL::GetJoystickVendor(m_resource);
}
 
inline Uint16 GetJoystickProduct(JoystickParam joystick)
{
  return SDL_GetJoystickProduct(joystick);
}
 
inline Uint16 Joystick::GetProduct()
{
  return SDL::GetJoystickProduct(m_resource);
}
 
inline Uint16 GetJoystickProductVersion(JoystickParam joystick)
{
  return SDL_GetJoystickProductVersion(joystick);
}
 
inline Uint16 Joystick::GetProductVersion()
{
  return SDL::GetJoystickProductVersion(m_resource);
}
 
inline Uint16 GetJoystickFirmwareVersion(JoystickParam joystick)
{
  return SDL_GetJoystickFirmwareVersion(joystick);
}
 
inline Uint16 Joystick::GetFirmwareVersion()
{
  return SDL::GetJoystickFirmwareVersion(m_resource);
}
 
inline const char* GetJoystickSerial(JoystickParam joystick)
{
  return SDL_GetJoystickSerial(joystick);
}
 
inline const char* Joystick::GetSerial()
{
  return SDL::GetJoystickSerial(m_resource);
}
 
inline JoystickType GetJoystickType(JoystickParam joystick)
{
  return SDL_GetJoystickType(joystick);
}
 
inline JoystickType Joystick::GetType()
{
  return SDL::GetJoystickType(m_resource);
}
 
inline void GetJoystickGUIDInfo(GUID guid,
                                Uint16* vendor,
                                Uint16* product,
                                Uint16* version,
                                Uint16* crc16)
{
  SDL_GetJoystickGUIDInfo(guid, vendor, product, version, crc16);
}
 
inline bool JoystickConnected(JoystickParam joystick)
{
  return SDL_JoystickConnected(joystick);
}
 
inline bool Joystick::Connected() { return SDL::JoystickConnected(m_resource); }
 
inline JoystickID GetJoystickID(JoystickParam joystick)
{
  return CheckError(SDL_GetJoystickID(joystick));
}
 
inline JoystickID Joystick::GetID() { return SDL::GetJoystickID(m_resource); }
 
inline int GetNumJoystickAxes(JoystickParam joystick)
{
  return CheckError(SDL_GetNumJoystickAxes(joystick));
}
 
inline int Joystick::GetNumAxes()
{
  return SDL::GetNumJoystickAxes(m_resource);
}
 
inline int GetNumJoystickBalls(JoystickParam joystick)
{
  return CheckError(SDL_GetNumJoystickBalls(joystick));
}
 
inline int Joystick::GetNumBalls()
{
  return SDL::GetNumJoystickBalls(m_resource);
}
 
inline int GetNumJoystickHats(JoystickParam joystick)
{
  return CheckError(SDL_GetNumJoystickHats(joystick));
}
 
inline int Joystick::GetNumHats()
{
  return SDL::GetNumJoystickHats(m_resource);
}
 
inline int GetNumJoystickButtons(JoystickParam joystick)
{
  return CheckError(SDL_GetNumJoystickButtons(joystick));
}
 
inline int Joystick::GetNumButtons()
{
  return SDL::GetNumJoystickButtons(m_resource);
}
 
inline void SetJoystickEventsEnabled(bool enabled)
{
  SDL_SetJoystickEventsEnabled(enabled);
}
 
inline bool JoystickEventsEnabled() { return SDL_JoystickEventsEnabled(); }
 
inline void UpdateJoysticks() { SDL_UpdateJoysticks(); }
 
inline Sint16 GetJoystickAxis(JoystickParam joystick, int axis)
{
  return SDL_GetJoystickAxis(joystick, axis);
}
 
inline Sint16 Joystick::GetAxis(int axis)
{
  return SDL::GetJoystickAxis(m_resource, axis);
}
 
inline bool GetJoystickAxisInitialState(JoystickParam joystick,
                                        int axis,
                                        Sint16* state)
{
  return SDL_GetJoystickAxisInitialState(joystick, axis, state);
}
 
inline bool Joystick::GetAxisInitialState(int axis, Sint16* state)
{
  return SDL::GetJoystickAxisInitialState(m_resource, axis, state);
}
 
inline void GetJoystickBall(JoystickParam joystick, int ball, int* dx, int* dy)
{
  CheckError(SDL_GetJoystickBall(joystick, ball, dx, dy));
}
 
inline void Joystick::GetBall(int ball, int* dx, int* dy)
{
  SDL::GetJoystickBall(m_resource, ball, dx, dy);
}
 
inline Uint8 GetJoystickHat(JoystickParam joystick, int hat)
{
  return SDL_GetJoystickHat(joystick, hat);
}
 
inline Uint8 Joystick::GetHat(int hat)
{
  return SDL::GetJoystickHat(m_resource, hat);
}
 
inline bool GetJoystickButton(JoystickParam joystick, int button)
{
  return SDL_GetJoystickButton(joystick, button);
}
 
inline bool Joystick::GetButton(int button)
{
  return SDL::GetJoystickButton(m_resource, button);
}
 
inline bool RumbleJoystick(JoystickParam joystick,
                           Uint16 low_frequency_rumble,
                           Uint16 high_frequency_rumble,
                           Uint32 duration_ms)
{
  return SDL_RumbleJoystick(
    joystick, low_frequency_rumble, high_frequency_rumble, duration_ms);
}
 
inline bool Joystick::Rumble(Uint16 low_frequency_rumble,
                             Uint16 high_frequency_rumble,
                             Uint32 duration_ms)
{
  return SDL::RumbleJoystick(
    m_resource, low_frequency_rumble, high_frequency_rumble, duration_ms);
}
 
inline void RumbleJoystickTriggers(JoystickParam joystick,
                                   Uint16 left_rumble,
                                   Uint16 right_rumble,
                                   Uint32 duration_ms)
{
  CheckError(SDL_RumbleJoystickTriggers(
    joystick, left_rumble, right_rumble, duration_ms));
}
 
inline void Joystick::RumbleTriggers(Uint16 left_rumble,
                                     Uint16 right_rumble,
                                     Uint32 duration_ms)
{
  SDL::RumbleJoystickTriggers(
    m_resource, left_rumble, right_rumble, duration_ms);
}
 
inline void SetJoystickLED(JoystickParam joystick,
                           Uint8 red,
                           Uint8 green,
                           Uint8 blue)
{
  CheckError(SDL_SetJoystickLED(joystick, red, green, blue));
}
 
inline void Joystick::SetLED(Uint8 red, Uint8 green, Uint8 blue)
{
  SDL::SetJoystickLED(m_resource, red, green, blue);
}
 
inline void SendJoystickEffect(JoystickParam joystick,
                               const void* data,
                               int size)
{
  CheckError(SDL_SendJoystickEffect(joystick, data, size));
}
 
inline void Joystick::SendEffect(const void* data, int size)
{
  SDL::SendJoystickEffect(m_resource, data, size);
}
 
inline void CloseJoystick(JoystickRaw joystick) { SDL_CloseJoystick(joystick); }
 
inline void Joystick::Close() { CloseJoystick(release()); }
 
inline JoystickConnectionState GetJoystickConnectionState(
  JoystickParam joystick)
{
  return CheckError(SDL_GetJoystickConnectionState(joystick));
}
 
inline JoystickConnectionState Joystick::GetConnectionState()
{
  return SDL::GetJoystickConnectionState(m_resource);
}
 
inline PowerState GetJoystickPowerInfo(JoystickParam joystick, int* percent)
{
  return SDL_GetJoystickPowerInfo(joystick, percent);
}
 
inline PowerState Joystick::GetPowerInfo(int* percent)
{
  return SDL::GetJoystickPowerInfo(m_resource, percent);
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_JOYSTICK_H_ */