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 HapticBase;
 
// Forward decl
struct Haptic;

using HapticRaw = SDL_Haptic*;

using HapticRef = ResourceRefT<HapticBase>;


using HapticEffectID = int;

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;

struct HapticBase : ResourceBaseT<HapticRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Close();

  HapticID GetID();

  const char* GetName();

  int GetMaxEffects();

  int GetMaxEffectsPlaying();

  Uint32 GetFeatures();

  int GetNumAxes();

  bool EffectSupported(const HapticEffect& effect);

  HapticEffectID CreateEffect(const HapticEffect& effect);

  void UpdateEffect(HapticEffectID effect, const HapticEffect& data);

  void RunEffect(HapticEffectID effect, Uint32 iterations);

  void StopEffect(HapticEffectID effect);

  void DestroyEffect(HapticEffectID effect);

  bool GetEffectStatus(HapticEffectID 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 Haptic : HapticBase
{
  using HapticBase::HapticBase;

  constexpr explicit Haptic(HapticRaw resource) noexcept
    : HapticBase(resource)
  {
  }

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

  Haptic(HapticID instance_id);

  Haptic(JoystickRef joystick);

  static Haptic OpenFromMouse();

  ~Haptic() { SDL_CloseHaptic(get()); }

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

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 Haptic::Haptic(HapticID instance_id)
  : Haptic(SDL_OpenHaptic(instance_id))
{
}
 
inline Haptic::Haptic(JoystickRef joystick)
  : Haptic(CheckError(SDL_OpenHapticFromJoystick(joystick)))
{
}

inline HapticRef GetHapticFromID(HapticID instance_id)
{
  return {CheckError(SDL_GetHapticFromID(instance_id))};
}

inline HapticID GetHapticID(HapticRef haptic)
{
  return CheckError(SDL_GetHapticID(haptic));
}
 
inline HapticID HapticBase::GetID() { return SDL::GetHapticID(get()); }

inline const char* GetHapticName(HapticRef haptic)
{
  return SDL_GetHapticName(haptic);
}
 
inline const char* HapticBase::GetName() { return SDL::GetHapticName(get()); }

inline bool IsMouseHaptic() { return SDL_IsMouseHaptic(); }

inline Haptic OpenHapticFromMouse()
{
  return Haptic(SDL_OpenHapticFromMouse());
}
 
inline Haptic Haptic::OpenFromMouse() { return SDL::OpenHapticFromMouse(); }

inline bool IsJoystickHaptic(JoystickRef joystick)
{
  return SDL_IsJoystickHaptic(joystick);
}

inline Haptic OpenHapticFromJoystick(JoystickRef joystick)
{
  return Haptic(joystick);
}

inline void CloseHaptic(HapticRaw haptic) { SDL_CloseHaptic(haptic); }
 
inline void HapticBase::Close() { CloseHaptic(release()); }

inline int GetMaxHapticEffects(HapticRef haptic)
{
  return SDL_GetMaxHapticEffects(haptic);
}
 
inline int HapticBase::GetMaxEffects()
{
  return SDL::GetMaxHapticEffects(get());
}

inline int GetMaxHapticEffectsPlaying(HapticRef haptic)
{
  return SDL_GetMaxHapticEffectsPlaying(haptic);
}
 
inline int HapticBase::GetMaxEffectsPlaying()
{
  return SDL::GetMaxHapticEffectsPlaying(get());
}

inline Uint32 GetHapticFeatures(HapticRef haptic)
{
  return CheckError(SDL_GetHapticFeatures(haptic));
}
 
inline Uint32 HapticBase::GetFeatures()
{
  return SDL::GetHapticFeatures(get());
}

inline int GetNumHapticAxes(HapticRef haptic)
{
  return CheckError(SDL_GetNumHapticAxes(haptic));
}
 
inline int HapticBase::GetNumAxes() { return SDL::GetNumHapticAxes(get()); }

inline bool HapticEffectSupported(HapticRef haptic, const HapticEffect& effect)
{
  return SDL_HapticEffectSupported(haptic, &effect);
}
 
inline bool HapticBase::EffectSupported(const HapticEffect& effect)
{
  return SDL::HapticEffectSupported(get(), effect);
}

inline HapticEffectID CreateHapticEffect(HapticRef haptic,
                                         const HapticEffect& effect)
{
  return CheckError(SDL_CreateHapticEffect(haptic, &effect));
}
 
inline HapticEffectID HapticBase::CreateEffect(const HapticEffect& effect)
{
  return SDL::CreateHapticEffect(get(), effect);
}

inline void UpdateHapticEffect(HapticRef haptic,
                               HapticEffectID effect,
                               const HapticEffect& data)
{
  CheckError(SDL_UpdateHapticEffect(haptic, effect, &data));
}
 
inline void HapticBase::UpdateEffect(HapticEffectID effect,
                                     const HapticEffect& data)
{
  SDL::UpdateHapticEffect(get(), effect, data);
}

inline void RunHapticEffect(HapticRef haptic,
                            HapticEffectID effect,
                            Uint32 iterations)
{
  CheckError(SDL_RunHapticEffect(haptic, effect, iterations));
}
 
inline void HapticBase::RunEffect(HapticEffectID effect, Uint32 iterations)
{
  SDL::RunHapticEffect(get(), effect, iterations);
}

inline void StopHapticEffect(HapticRef haptic, HapticEffectID effect)
{
  CheckError(SDL_StopHapticEffect(haptic, effect));
}
 
inline void HapticBase::StopEffect(HapticEffectID effect)
{
  SDL::StopHapticEffect(get(), effect);
}

inline void DestroyHapticEffect(HapticRef haptic, HapticEffectID effect)
{
  SDL_DestroyHapticEffect(haptic, effect);
}
 
inline void HapticBase::DestroyEffect(HapticEffectID effect)
{
  SDL::DestroyHapticEffect(get(), effect);
}

inline bool GetHapticEffectStatus(HapticRef haptic, HapticEffectID effect)
{
  return SDL_GetHapticEffectStatus(haptic, effect);
}
 
inline bool HapticBase::GetEffectStatus(HapticEffectID effect)
{
  return SDL::GetHapticEffectStatus(get(), effect);
}

inline void SetHapticGain(HapticRef haptic, int gain)
{
  CheckError(SDL_SetHapticGain(haptic, gain));
}
 
inline void HapticBase::SetGain(int gain) { SDL::SetHapticGain(get(), gain); }

inline void SetHapticAutocenter(HapticRef haptic, int autocenter)
{
  CheckError(SDL_SetHapticAutocenter(haptic, autocenter));
}
 
inline void HapticBase::SetAutocenter(int autocenter)
{
  SDL::SetHapticAutocenter(get(), autocenter);
}

inline void PauseHaptic(HapticRef haptic)
{
  CheckError(SDL_PauseHaptic(haptic));
}
 
inline void HapticBase::Pause() { SDL::PauseHaptic(get()); }

inline void ResumeHaptic(HapticRef haptic)
{
  CheckError(SDL_ResumeHaptic(haptic));
}
 
inline void HapticBase::Resume() { SDL::ResumeHaptic(get()); }

inline void StopHapticEffects(HapticRef haptic)
{
  CheckError(SDL_StopHapticEffects(haptic));
}
 
inline void HapticBase::StopEffects() { SDL::StopHapticEffects(get()); }

inline bool HapticRumbleSupported(HapticRef haptic)
{
  return SDL_HapticRumbleSupported(haptic);
}
 
inline bool HapticBase::RumbleSupported()
{
  return SDL::HapticRumbleSupported(get());
}

inline void InitHapticRumble(HapticRef haptic)
{
  CheckError(SDL_InitHapticRumble(haptic));
}
 
inline void HapticBase::InitRumble() { SDL::InitHapticRumble(get()); }

inline void PlayHapticRumble(HapticRef haptic, float strength, Uint32 length)
{
  CheckError(SDL_PlayHapticRumble(haptic, strength, length));
}
 
inline void HapticBase::PlayRumble(float strength, Uint32 length)
{
  SDL::PlayHapticRumble(get(), strength, length);
}

inline void StopHapticRumble(HapticRef haptic)
{
  CheckError(SDL_StopHapticRumble(haptic));
}
 
inline void HapticBase::StopRumble() { SDL::StopHapticRumble(get()); }

 
} // namespace SDL
 
#endif /* SDL3PP_HAPTIC_H_ */