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 JoystickBase;
 
// Forward decl
struct Joystick;

using JoystickRaw = SDL_Joystick*;

using JoystickRef = ResourceRefT<JoystickBase>;

using JoystickIDRaw = SDL_JoystickID;
 
// Forward decl
struct JoystickID;
 
// Forward decl
struct JoystickApiLock;

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 = {}) noexcept
    : m_joystickID(joystickID)
  {
  }

  constexpr operator JoystickIDRaw() const noexcept { 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; 

struct JoystickBase : ResourceBaseT<JoystickRaw>
{
  using ResourceBaseT::ResourceBaseT;

  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 Joystick : JoystickBase
{
  using JoystickBase::JoystickBase;

  constexpr explicit Joystick(JoystickRaw resource) noexcept
    : JoystickBase(resource)
  {
  }

  constexpr Joystick(Joystick&& other) noexcept
    : Joystick(other.release())
  {
  }

  Joystick(JoystickID instance_id);

  ~Joystick() { SDL_CloseJoystick(get()); }

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

constexpr int JOYSTICK_AXIS_MAX = SDL_JOYSTICK_AXIS_MAX;

constexpr int JOYSTICK_AXIS_MIN = SDL_JOYSTICK_AXIS_MIN;

class JoystickApiLock
{
  bool m_lock;
 
public:
  JoystickApiLock();

  JoystickApiLock(const JoystickApiLock& other) = delete;

  JoystickApiLock(JoystickApiLock&& other) noexcept
    : m_lock(other.m_lock)
  {
  }

  ~JoystickApiLock() { reset(); }
 
  JoystickApiLock& operator=(const JoystickApiLock& other) = delete;

  JoystickApiLock& operator=(JoystickApiLock&& other) noexcept
  {
    std::swap(m_lock, other.m_lock);
    return *this;
  }

  constexpr operator bool() const { return bool(m_lock); }

  void reset();

  void release() { m_lock = false; }
};

inline void LockJoysticks() { SDL_LockJoysticks(); }
 
inline JoystickApiLock::JoystickApiLock()
  : m_lock(true)
{
  LockJoysticks();
}

inline void UnlockJoysticks() { SDL_UnlockJoysticks(); }
 
inline void JoystickApiLock::reset()
{
  if (!m_lock) return;
  UnlockJoysticks();
  m_lock = false;
}

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::Joystick(JoystickID instance_id)
  : Joystick(CheckError(SDL_OpenJoystick(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 CheckError(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(JoystickRef joystick, int axis, Sint16 value)
{
  CheckError(SDL_SetJoystickVirtualAxis(joystick, axis, value));
}
 
inline void JoystickBase::SetVirtualAxis(int axis, Sint16 value)
{
  SDL::SetJoystickVirtualAxis(get(), axis, value);
}

inline void SetJoystickVirtualBall(JoystickRef joystick,
                                   int ball,
                                   Sint16 xrel,
                                   Sint16 yrel)
{
  CheckError(SDL_SetJoystickVirtualBall(joystick, ball, xrel, yrel));
}
 
inline void JoystickBase::SetVirtualBall(int ball, Sint16 xrel, Sint16 yrel)
{
  SDL::SetJoystickVirtualBall(get(), ball, xrel, yrel);
}

inline void SetJoystickVirtualButton(JoystickRef joystick,
                                     int button,
                                     bool down)
{
  CheckError(SDL_SetJoystickVirtualButton(joystick, button, down));
}
 
inline void JoystickBase::SetVirtualButton(int button, bool down)
{
  SDL::SetJoystickVirtualButton(get(), button, down);
}

inline void SetJoystickVirtualHat(JoystickRef joystick, int hat, Uint8 value)
{
  CheckError(SDL_SetJoystickVirtualHat(joystick, hat, value));
}
 
inline void JoystickBase::SetVirtualHat(int hat, Uint8 value)
{
  SDL::SetJoystickVirtualHat(get(), hat, value);
}

inline void SetJoystickVirtualTouchpad(JoystickRef 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 JoystickBase::SetVirtualTouchpad(int touchpad,
                                             int finger,
                                             bool down,
                                             const FPointRaw& p,
                                             float pressure)
{
  SDL::SetJoystickVirtualTouchpad(get(), touchpad, finger, down, p, pressure);
}

inline void SendJoystickVirtualSensorData(JoystickRef joystick,
                                          SensorType type,
                                          Uint64 sensor_timestamp,
                                          const float* data,
                                          int num_values)
{
  CheckError(SDL_SendJoystickVirtualSensorData(
    joystick, type, sensor_timestamp, data, num_values));
}
 
inline void JoystickBase::SendVirtualSensorData(SensorType type,
                                                Uint64 sensor_timestamp,
                                                const float* data,
                                                int num_values)
{
  SDL::SendJoystickVirtualSensorData(
    get(), type, sensor_timestamp, data, num_values);
}

inline PropertiesRef GetJoystickProperties(JoystickRef joystick)
{
  return CheckError(SDL_GetJoystickProperties(joystick));
}
 
inline PropertiesRef JoystickBase::GetProperties()
{
  return SDL::GetJoystickProperties(get());
}

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(JoystickRef joystick)
{
  return SDL_GetJoystickName(joystick);
}
 
inline const char* JoystickBase::GetName()
{
  return SDL::GetJoystickName(get());
}

inline const char* GetJoystickPath(JoystickRef joystick)
{
  return SDL_GetJoystickPath(joystick);
}
 
inline const char* JoystickBase::GetPath()
{
  return SDL::GetJoystickPath(get());
}

inline int GetJoystickPlayerIndex(JoystickRef joystick)
{
  return SDL_GetJoystickPlayerIndex(joystick);
}
 
inline int JoystickBase::GetPlayerIndex()
{
  return SDL::GetJoystickPlayerIndex(get());
}

inline void SetJoystickPlayerIndex(JoystickRef joystick, int player_index)
{
  CheckError(SDL_SetJoystickPlayerIndex(joystick, player_index));
}
 
inline void JoystickBase::SetPlayerIndex(int player_index)
{
  SDL::SetJoystickPlayerIndex(get(), player_index);
}

inline GUID GetJoystickGUID(JoystickRef joystick)
{
  return SDL_GetJoystickGUID(joystick);
}
 
inline GUID JoystickBase::GetGUID() { return SDL::GetJoystickGUID(get()); }

inline Uint16 GetJoystickVendor(JoystickRef joystick)
{
  return SDL_GetJoystickVendor(joystick);
}
 
inline Uint16 JoystickBase::GetVendor()
{
  return SDL::GetJoystickVendor(get());
}

inline Uint16 GetJoystickProduct(JoystickRef joystick)
{
  return SDL_GetJoystickProduct(joystick);
}
 
inline Uint16 JoystickBase::GetProduct()
{
  return SDL::GetJoystickProduct(get());
}

inline Uint16 GetJoystickProductVersion(JoystickRef joystick)
{
  return SDL_GetJoystickProductVersion(joystick);
}
 
inline Uint16 JoystickBase::GetProductVersion()
{
  return SDL::GetJoystickProductVersion(get());
}

inline Uint16 GetJoystickFirmwareVersion(JoystickRef joystick)
{
  return SDL_GetJoystickFirmwareVersion(joystick);
}
 
inline Uint16 JoystickBase::GetFirmwareVersion()
{
  return SDL::GetJoystickFirmwareVersion(get());
}

inline const char* GetJoystickSerial(JoystickRef joystick)
{
  return SDL_GetJoystickSerial(joystick);
}
 
inline const char* JoystickBase::GetSerial()
{
  return SDL::GetJoystickSerial(get());
}

inline JoystickType GetJoystickType(JoystickRef joystick)
{
  return SDL_GetJoystickType(joystick);
}
 
inline JoystickType JoystickBase::GetType()
{
  return SDL::GetJoystickType(get());
}

inline void GetJoystickGUIDInfo(GUID guid,
                                Uint16* vendor,
                                Uint16* product,
                                Uint16* version,
                                Uint16* crc16)
{
  SDL_GetJoystickGUIDInfo(guid, vendor, product, version, crc16);
}

inline bool JoystickConnected(JoystickRef joystick)
{
  return SDL_JoystickConnected(joystick);
}
 
inline bool JoystickBase::Connected() { return SDL::JoystickConnected(get()); }

inline JoystickID GetJoystickID(JoystickRef joystick)
{
  return CheckError(SDL_GetJoystickID(joystick));
}
 
inline JoystickID JoystickBase::GetID() { return SDL::GetJoystickID(get()); }

inline int GetNumJoystickAxes(JoystickRef joystick)
{
  return CheckError(SDL_GetNumJoystickAxes(joystick));
}
 
inline int JoystickBase::GetNumAxes() { return SDL::GetNumJoystickAxes(get()); }

inline int GetNumJoystickBalls(JoystickRef joystick)
{
  return CheckError(SDL_GetNumJoystickBalls(joystick));
}
 
inline int JoystickBase::GetNumBalls()
{
  return SDL::GetNumJoystickBalls(get());
}

inline int GetNumJoystickHats(JoystickRef joystick)
{
  return CheckError(SDL_GetNumJoystickHats(joystick));
}
 
inline int JoystickBase::GetNumHats() { return SDL::GetNumJoystickHats(get()); }

inline int GetNumJoystickButtons(JoystickRef joystick)
{
  return CheckError(SDL_GetNumJoystickButtons(joystick));
}
 
inline int JoystickBase::GetNumButtons()
{
  return SDL::GetNumJoystickButtons(get());
}

inline void SetJoystickEventsEnabled(bool enabled)
{
  SDL_SetJoystickEventsEnabled(enabled);
}

inline bool JoystickEventsEnabled() { return SDL_JoystickEventsEnabled(); }

inline void UpdateJoysticks() { SDL_UpdateJoysticks(); }

inline Sint16 GetJoystickAxis(JoystickRef joystick, int axis)
{
  return SDL_GetJoystickAxis(joystick, axis);
}
 
inline Sint16 JoystickBase::GetAxis(int axis)
{
  return SDL::GetJoystickAxis(get(), axis);
}

inline bool GetJoystickAxisInitialState(JoystickRef joystick,
                                        int axis,
                                        Sint16* state)
{
  return SDL_GetJoystickAxisInitialState(joystick, axis, state);
}
 
inline bool JoystickBase::GetAxisInitialState(int axis, Sint16* state)
{
  return SDL::GetJoystickAxisInitialState(get(), axis, state);
}

inline void GetJoystickBall(JoystickRef joystick, int ball, int* dx, int* dy)
{
  CheckError(SDL_GetJoystickBall(joystick, ball, dx, dy));
}
 
inline void JoystickBase::GetBall(int ball, int* dx, int* dy)
{
  SDL::GetJoystickBall(get(), ball, dx, dy);
}

inline Uint8 GetJoystickHat(JoystickRef joystick, int hat)
{
  return SDL_GetJoystickHat(joystick, hat);
}
 
inline Uint8 JoystickBase::GetHat(int hat)
{
  return SDL::GetJoystickHat(get(), hat);
}

inline bool GetJoystickButton(JoystickRef joystick, int button)
{
  return SDL_GetJoystickButton(joystick, button);
}
 
inline bool JoystickBase::GetButton(int button)
{
  return SDL::GetJoystickButton(get(), button);
}

inline bool RumbleJoystick(JoystickRef 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 JoystickBase::Rumble(Uint16 low_frequency_rumble,
                                 Uint16 high_frequency_rumble,
                                 Uint32 duration_ms)
{
  return SDL::RumbleJoystick(
    get(), low_frequency_rumble, high_frequency_rumble, duration_ms);
}

inline void RumbleJoystickTriggers(JoystickRef joystick,
                                   Uint16 left_rumble,
                                   Uint16 right_rumble,
                                   Uint32 duration_ms)
{
  CheckError(SDL_RumbleJoystickTriggers(
    joystick, left_rumble, right_rumble, duration_ms));
}
 
inline void JoystickBase::RumbleTriggers(Uint16 left_rumble,
                                         Uint16 right_rumble,
                                         Uint32 duration_ms)
{
  SDL::RumbleJoystickTriggers(get(), left_rumble, right_rumble, duration_ms);
}

inline void SetJoystickLED(JoystickRef joystick,
                           Uint8 red,
                           Uint8 green,
                           Uint8 blue)
{
  CheckError(SDL_SetJoystickLED(joystick, red, green, blue));
}
 
inline void JoystickBase::SetLED(Uint8 red, Uint8 green, Uint8 blue)
{
  SDL::SetJoystickLED(get(), red, green, blue);
}

inline void SendJoystickEffect(JoystickRef joystick, const void* data, int size)
{
  CheckError(SDL_SendJoystickEffect(joystick, data, size));
}
 
inline void JoystickBase::SendEffect(const void* data, int size)
{
  SDL::SendJoystickEffect(get(), data, size);
}

inline void CloseJoystick(JoystickRaw joystick) { SDL_CloseJoystick(joystick); }
 
inline void JoystickBase::Close() { CloseJoystick(release()); }

inline JoystickConnectionState GetJoystickConnectionState(JoystickRef joystick)
{
  return CheckError(SDL_GetJoystickConnectionState(joystick));
}
 
inline JoystickConnectionState JoystickBase::GetConnectionState()
{
  return SDL::GetJoystickConnectionState(get());
}

inline PowerState GetJoystickPowerInfo(JoystickRef joystick, int* percent)
{
  return SDL_GetJoystickPowerInfo(joystick, percent);
}
 
inline PowerState JoystickBase::GetPowerInfo(int* percent)
{
  return SDL::GetJoystickPowerInfo(get(), percent);
}

 
} // namespace SDL
 
#endif /* SDL3PP_JOYSTICK_H_ */