SDL3pp_timer.h

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

 
constexpr Time Time::FromPosix(Sint64 time)
{
  return Time::FromNS(SDL_SECONDS_TO_NS(time));
}
 
constexpr Sint64 Time::ToPosix() const
{
  return SDL_NS_TO_SECONDS(m_time.count());
}

inline std::chrono::nanoseconds GetTicks()
{
  return std::chrono::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(std::chrono::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(std::chrono::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, std::chrono::nanoseconds> F>
  TimerCB(const F& func)
    : LightweightCallbackT<TimerCB, Uint64, TimerID, Uint64>(func)
  {
  }

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

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

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

inline TimerID AddTimer(std::chrono::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_ */