SDL3pp_timer.h

#ifndef SDL3PP_TIMER_H_
#define SDL3PP_TIMER_H_
 
#include <SDL3/SDL_timer.h>
#include "SDL3pp_stdinc.h"
 
namespace SDL {


constexpr Uint32 MS_PER_SECOND = SDL_MS_PER_SECOND;

constexpr Uint32 US_PER_SECOND = SDL_US_PER_SECOND;

constexpr Uint64 NS_PER_SECOND = SDL_NS_PER_SECOND;

constexpr Uint32 NS_PER_MS = SDL_NS_PER_MS;

constexpr Uint32 NS_PER_US = SDL_NS_PER_US;

constexpr Uint64 SecondsToNs(Number auto S) { return SDL_SECONDS_TO_NS(S); }

constexpr Time TimeFromPosix(Sint64 time)
{
  return Time::FromNS(SecondsToNs(time));
}
 
constexpr Time Time::FromPosix(Sint64 time)
{
  return Time::FromNS(SecondsToNs(time));
}

constexpr auto NsToSeconds(Number auto NS) { return SDL_NS_TO_SECONDS(NS); }

constexpr Sint64 TimeToPosix(Time time) { return NsToSeconds(time.ToPosix()); }
 
constexpr Sint64 Time::ToPosix() const { return NsToSeconds(m_time.count()); }

constexpr Uint64 MsToNs(Number auto MS) { return SDL_MS_TO_NS(MS); }

constexpr auto NsToMs(Number auto NS) { return SDL_NS_TO_MS(NS); }

constexpr Uint64 UsToNs(Number auto US) { return SDL_US_TO_NS(US); }

constexpr auto NsToUs(Number auto NS) { return SDL_NS_TO_US(NS); }

inline Nanoseconds GetTicks() { return Nanoseconds(SDL_GetTicksNS()); }

inline Uint64 GetTicksMS() { return SDL_GetTicks(); }

inline Uint64 GetTicksNS() { return SDL_GetTicksNS(); }

inline Uint64 GetPerformanceCounter() { return SDL_GetPerformanceCounter(); }

inline Uint64 GetPerformanceFrequency()
{
  return SDL_GetPerformanceFrequency();
}

inline void Delay(Uint32 ms) { SDL_Delay(ms); }

inline void Delay(Nanoseconds duration) { SDL_DelayNS(duration.count()); }

inline void DelayNS(Uint64 ns) { SDL_DelayNS(ns); }

inline void DelayPrecise(Uint64 ns) { SDL_DelayPrecise(ns); }

inline void DelayPrecise(Nanoseconds duration)
{
  SDL_DelayPrecise(duration.count());
}

using TimerID = SDL_TimerID;

using MSTimerCallback = Uint32(SDLCALL*)(void* userdata,
                                         TimerID timerID,
                                         Uint32 interval);

using NSTimerCallback = Uint64(SDLCALL*)(void* userdata,
                                         TimerID timerID,
                                         Uint64 interval);

struct TimerCB : LightweightCallbackT<TimerCB, Uint64, TimerID, Uint64>
{
  template<std::invocable<TimerID, Nanoseconds> F>
  TimerCB(const F& func)
    : LightweightCallbackT<TimerCB, Uint64, TimerID, Uint64>(func)
  {
  }

  template<std::invocable<TimerID, Nanoseconds> F>
  static Uint64 doCall(F& func, TimerID timerID, Uint64 interval)
  {
    return func(timerID, std::chrono::nanoseconds(interval)).count();
  }
};

inline TimerID AddTimer(Milliseconds interval,
                        MSTimerCallback callback,
                        void* userdata)
{
  return SDL_AddTimer(Uint32(interval.count()), callback, userdata);
}

inline TimerID AddTimer(Nanoseconds interval,
                        NSTimerCallback callback,
                        void* userdata)
{
  return CheckError(SDL_AddTimerNS(interval.count(), callback, userdata));
}

inline TimerID AddTimer(Nanoseconds interval, TimerCB callback)
{
  return SDL_AddTimerNS(interval.count(), callback.wrapper, callback.data);
}

inline void RemoveTimer(TimerID id) { CheckError(SDL_RemoveTimer(id)); }

 
} // namespace SDL
 
#endif /* SDL3PP_TIMER_H_ */