SDL3pp_haptic.h

#ifndef SDL3PP_HAPTIC_H_
#define SDL3PP_HAPTIC_H_
 
#include <SDL3/SDL_haptic.h>
#include "SDL3pp_error.h"
#include "SDL3pp_joystick.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
// Forward decl
struct Haptic;
 
using HapticRaw = SDL_Haptic*;
 
// Forward decl
struct HapticRef;
 
struct HapticParam
{
  HapticRaw value; 
 
  constexpr HapticParam(HapticRaw value)
    : value(value)
  {
  }
 
  constexpr HapticParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const HapticParam& other) const = default;
 
  constexpr operator HapticRaw() const { return value; }
};
 
using HapticEffectType = Uint32;
 
constexpr HapticEffectType HAPTIC_CONSTANT = SDL_HAPTIC_CONSTANT;
 
constexpr HapticEffectType HAPTIC_SINE = SDL_HAPTIC_SINE;
 
constexpr HapticEffectType HAPTIC_SQUARE = SDL_HAPTIC_SQUARE;
 
constexpr HapticEffectType HAPTIC_TRIANGLE = SDL_HAPTIC_TRIANGLE;
 
constexpr HapticEffectType HAPTIC_SAWTOOTHUP = SDL_HAPTIC_SAWTOOTHUP;
 
constexpr HapticEffectType HAPTIC_SAWTOOTHDOWN = SDL_HAPTIC_SAWTOOTHDOWN;
 
constexpr HapticEffectType HAPTIC_RAMP = SDL_HAPTIC_RAMP;
 
constexpr HapticEffectType HAPTIC_SPRING = SDL_HAPTIC_SPRING;
 
constexpr HapticEffectType HAPTIC_DAMPER = SDL_HAPTIC_DAMPER;
 
constexpr HapticEffectType HAPTIC_INERTIA = SDL_HAPTIC_INERTIA;
 
constexpr HapticEffectType HAPTIC_FRICTION = SDL_HAPTIC_FRICTION;
 
constexpr HapticEffectType HAPTIC_LEFTRIGHT = SDL_HAPTIC_LEFTRIGHT;
 
constexpr HapticEffectType HAPTIC_RESERVED1 = SDL_HAPTIC_RESERVED1;
 
constexpr HapticEffectType HAPTIC_RESERVED2 = SDL_HAPTIC_RESERVED2;
 
constexpr HapticEffectType HAPTIC_RESERVED3 = SDL_HAPTIC_RESERVED3;
 
constexpr HapticEffectType HAPTIC_CUSTOM = SDL_HAPTIC_CUSTOM;
 
constexpr HapticEffectType HAPTIC_GAIN = SDL_HAPTIC_GAIN;
 
constexpr HapticEffectType HAPTIC_AUTOCENTER = SDL_HAPTIC_AUTOCENTER;
 
constexpr HapticEffectType HAPTIC_STATUS = SDL_HAPTIC_STATUS;
 
constexpr HapticEffectType HAPTIC_PAUSE = SDL_HAPTIC_PAUSE;
 
 
using HapticDirectionType = Uint8;
 
constexpr HapticDirectionType HAPTIC_POLAR = SDL_HAPTIC_POLAR;
 
constexpr HapticDirectionType HAPTIC_CARTESIAN = SDL_HAPTIC_CARTESIAN;
 
constexpr HapticDirectionType HAPTIC_SPHERICAL = SDL_HAPTIC_SPHERICAL;
 
constexpr HapticDirectionType HAPTIC_STEERING_AXIS = SDL_HAPTIC_STEERING_AXIS;
 
 
constexpr Uint32 HAPTIC_INFINITY = SDL_HAPTIC_INFINITY;
 
using HapticDirection = SDL_HapticDirection;
 
using HapticConstant = SDL_HapticConstant;
 
using HapticPeriodic = SDL_HapticPeriodic;
 
using HapticCondition = SDL_HapticCondition;
 
using HapticRamp = SDL_HapticRamp;
 
using HapticLeftRight = SDL_HapticLeftRight;
 
using HapticCustom = SDL_HapticCustom;
 
using HapticEffect = SDL_HapticEffect;
 
using HapticID = SDL_HapticID;
 
class Haptic
{
  HapticRaw m_resource = nullptr;
 
public:
  constexpr Haptic() = default;
 
  constexpr explicit Haptic(const HapticRaw resource)
    : m_resource(resource)
  {
  }
 
  constexpr Haptic(const Haptic& other) = delete;
 
  constexpr Haptic(Haptic&& other)
    : Haptic(other.release())
  {
  }
 
  constexpr Haptic(const HapticRef& other) = delete;
 
  constexpr Haptic(HapticRef&& other) = delete;
 
  Haptic(HapticID instance_id)
    : m_resource(SDL_OpenHaptic(instance_id))
  {
  }
 
  Haptic(JoystickParam joystick)
    : m_resource(CheckError(SDL_OpenHapticFromJoystick(joystick)))
  {
  }
 
  static Haptic OpenFromMouse();
 
  ~Haptic() { SDL_CloseHaptic(m_resource); }
 
  Haptic& operator=(Haptic other)
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  constexpr HapticRaw get() const { return m_resource; }
 
  constexpr HapticRaw release()
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Haptic& other) const = default;
 
  constexpr bool operator==(std::nullptr_t _) const { return !m_resource; }
 
  constexpr explicit operator bool() const { return !!m_resource; }
 
  constexpr operator HapticParam() const { return {m_resource}; }
 
  void Close();
 
  HapticID GetID();
 
  const char* GetName();
 
  int GetMaxEffects();
 
  int GetMaxEffectsPlaying();
 
  Uint32 GetFeatures();
 
  int GetNumAxes();
 
  bool EffectSupported(const HapticEffect& effect);
 
  int CreateEffect(const HapticEffect& effect);
 
  void UpdateEffect(int effect, const HapticEffect& data);
 
  void RunEffect(int effect, Uint32 iterations);
 
  void StopEffect(int effect);
 
  void DestroyEffect(int effect);
 
  bool GetEffectStatus(int effect);
 
  void SetGain(int gain);
 
  void SetAutocenter(int autocenter);
 
  void Pause();
 
  void Resume();
 
  void StopEffects();
 
  bool RumbleSupported();
 
  void InitRumble();
 
  void PlayRumble(float strength, Uint32 length);
 
  void StopRumble();
};
 
struct HapticRef : Haptic
{
  HapticRef(HapticParam resource)
    : Haptic(resource.value)
  {
  }
 
  HapticRef(const HapticRef& other)
    : Haptic(other.get())
  {
  }
 
  ~HapticRef() { release(); }
};
 
inline OwnArray<HapticID> GetHaptics()
{
  int count;
  auto data = SDL_GetHaptics(&count);
  return OwnArray<HapticID>{data};
}
 
inline const char* GetHapticNameForID(HapticID instance_id)
{
  return SDL_GetHapticNameForID(instance_id);
}
 
inline Haptic OpenHaptic(HapticID instance_id) { return Haptic(instance_id); }
 
inline HapticRef GetHapticFromID(HapticID instance_id)
{
  return {CheckError(SDL_GetHapticFromID(instance_id))};
}
 
inline HapticID GetHapticID(HapticParam haptic)
{
  return CheckError(SDL_GetHapticID(haptic));
}
 
inline HapticID Haptic::GetID() { return SDL::GetHapticID(m_resource); }
 
inline const char* GetHapticName(HapticParam haptic)
{
  return SDL_GetHapticName(haptic);
}
 
inline const char* Haptic::GetName() { return SDL::GetHapticName(m_resource); }
 
inline bool IsMouseHaptic() { return SDL_IsMouseHaptic(); }
 
inline Haptic OpenHapticFromMouse()
{
  return Haptic(SDL_OpenHapticFromMouse());
}
 
inline Haptic Haptic::OpenFromMouse() { return SDL::OpenHapticFromMouse(); }
 
inline bool IsJoystickHaptic(JoystickParam joystick)
{
  return SDL_IsJoystickHaptic(joystick);
}
 
inline Haptic OpenHapticFromJoystick(JoystickParam joystick)
{
  return Haptic(joystick);
}
 
inline void CloseHaptic(HapticRaw haptic) { SDL_CloseHaptic(haptic); }
 
inline void Haptic::Close() { CloseHaptic(release()); }
 
inline int GetMaxHapticEffects(HapticParam haptic)
{
  return SDL_GetMaxHapticEffects(haptic);
}
 
inline int Haptic::GetMaxEffects()
{
  return SDL::GetMaxHapticEffects(m_resource);
}
 
inline int GetMaxHapticEffectsPlaying(HapticParam haptic)
{
  return SDL_GetMaxHapticEffectsPlaying(haptic);
}
 
inline int Haptic::GetMaxEffectsPlaying()
{
  return SDL::GetMaxHapticEffectsPlaying(m_resource);
}
 
inline Uint32 GetHapticFeatures(HapticParam haptic)
{
  return SDL_GetHapticFeatures(haptic);
}
 
inline Uint32 Haptic::GetFeatures()
{
  return SDL::GetHapticFeatures(m_resource);
}
 
inline int GetNumHapticAxes(HapticParam haptic)
{
  return CheckError(SDL_GetNumHapticAxes(haptic));
}
 
inline int Haptic::GetNumAxes() { return SDL::GetNumHapticAxes(m_resource); }
 
inline bool HapticEffectSupported(HapticParam haptic,
                                  const HapticEffect& effect)
{
  return SDL_HapticEffectSupported(haptic, &effect);
}
 
inline bool Haptic::EffectSupported(const HapticEffect& effect)
{
  return SDL::HapticEffectSupported(m_resource, effect);
}
 
inline int CreateHapticEffect(HapticParam haptic, const HapticEffect& effect)
{
  return CheckError(SDL_CreateHapticEffect(haptic, &effect));
}
 
inline int Haptic::CreateEffect(const HapticEffect& effect)
{
  return SDL::CreateHapticEffect(m_resource, effect);
}
 
inline void UpdateHapticEffect(HapticParam haptic,
                               int effect,
                               const HapticEffect& data)
{
  CheckError(SDL_UpdateHapticEffect(haptic, effect, &data));
}
 
inline void Haptic::UpdateEffect(int effect, const HapticEffect& data)
{
  SDL::UpdateHapticEffect(m_resource, effect, data);
}
 
inline void RunHapticEffect(HapticParam haptic, int effect, Uint32 iterations)
{
  CheckError(SDL_RunHapticEffect(haptic, effect, iterations));
}
 
inline void Haptic::RunEffect(int effect, Uint32 iterations)
{
  SDL::RunHapticEffect(m_resource, effect, iterations);
}
 
inline void StopHapticEffect(HapticParam haptic, int effect)
{
  CheckError(SDL_StopHapticEffect(haptic, effect));
}
 
inline void Haptic::StopEffect(int effect)
{
  SDL::StopHapticEffect(m_resource, effect);
}
 
inline void DestroyHapticEffect(HapticParam haptic, int effect)
{
  SDL_DestroyHapticEffect(haptic, effect);
}
 
inline void Haptic::DestroyEffect(int effect)
{
  SDL::DestroyHapticEffect(m_resource, effect);
}
 
inline bool GetHapticEffectStatus(HapticParam haptic, int effect)
{
  return SDL_GetHapticEffectStatus(haptic, effect);
}
 
inline bool Haptic::GetEffectStatus(int effect)
{
  return SDL::GetHapticEffectStatus(m_resource, effect);
}
 
inline void SetHapticGain(HapticParam haptic, int gain)
{
  CheckError(SDL_SetHapticGain(haptic, gain));
}
 
inline void Haptic::SetGain(int gain) { SDL::SetHapticGain(m_resource, gain); }
 
inline void SetHapticAutocenter(HapticParam haptic, int autocenter)
{
  CheckError(SDL_SetHapticAutocenter(haptic, autocenter));
}
 
inline void Haptic::SetAutocenter(int autocenter)
{
  SDL::SetHapticAutocenter(m_resource, autocenter);
}
 
inline void PauseHaptic(HapticParam haptic)
{
  CheckError(SDL_PauseHaptic(haptic));
}
 
inline void Haptic::Pause() { SDL::PauseHaptic(m_resource); }
 
inline void ResumeHaptic(HapticParam haptic)
{
  CheckError(SDL_ResumeHaptic(haptic));
}
 
inline void Haptic::Resume() { SDL::ResumeHaptic(m_resource); }
 
inline void StopHapticEffects(HapticParam haptic)
{
  CheckError(SDL_StopHapticEffects(haptic));
}
 
inline void Haptic::StopEffects() { SDL::StopHapticEffects(m_resource); }
 
inline bool HapticRumbleSupported(HapticParam haptic)
{
  return SDL_HapticRumbleSupported(haptic);
}
 
inline bool Haptic::RumbleSupported()
{
  return SDL::HapticRumbleSupported(m_resource);
}
 
inline void InitHapticRumble(HapticParam haptic)
{
  CheckError(SDL_InitHapticRumble(haptic));
}
 
inline void Haptic::InitRumble() { SDL::InitHapticRumble(m_resource); }
 
inline void PlayHapticRumble(HapticParam haptic, float strength, Uint32 length)
{
  CheckError(SDL_PlayHapticRumble(haptic, strength, length));
}
 
inline void Haptic::PlayRumble(float strength, Uint32 length)
{
  SDL::PlayHapticRumble(m_resource, strength, length);
}
 
inline void StopHapticRumble(HapticParam haptic)
{
  CheckError(SDL_StopHapticRumble(haptic));
}
 
inline void Haptic::StopRumble() { SDL::StopHapticRumble(m_resource); }
 
 
} // namespace SDL
 
#endif /* SDL3PP_HAPTIC_H_ */