SDL3pp_init.h

#ifndef SDL3PP_INIT_H_
#define SDL3PP_INIT_H_
 
#include <atomic>
#include <SDL3/SDL_init.h>
#include "SDL3pp_callbackWrapper.h"
#include "SDL3pp_error.h"
#include "SDL3pp_log.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
using InitFlags = Uint32;
 
struct InitFlagsExtra
{};
 
constexpr InitFlags INIT_AUDIO =
  SDL_INIT_AUDIO; 
 
constexpr InitFlags INIT_VIDEO = SDL_INIT_VIDEO;
 
constexpr InitFlags INIT_JOYSTICK = SDL_INIT_JOYSTICK;
 
constexpr InitFlags INIT_HAPTIC = SDL_INIT_HAPTIC; 
 
constexpr InitFlags INIT_GAMEPAD =
  SDL_INIT_GAMEPAD; 
 
constexpr InitFlags INIT_EVENTS = SDL_INIT_EVENTS; 
 
constexpr InitFlags INIT_SENSOR =
  SDL_INIT_SENSOR; 
 
constexpr InitFlags INIT_CAMERA =
  SDL_INIT_CAMERA; 
 
 
using AppResult = SDL_AppResult;
 
constexpr AppResult APP_CONTINUE = SDL_APP_CONTINUE;
 
constexpr AppResult APP_SUCCESS = SDL_APP_SUCCESS;
 
constexpr AppResult APP_FAILURE = SDL_APP_FAILURE;
 
 
using AppInit_func = SDL_AppInit_func;
 
using AppIterate_func = SDL_AppIterate_func;
 
using AppEvent_func = SDL_AppEvent_func;
 
using AppQuit_func = SDL_AppQuit_func;
 
 
inline void InitSubSystem(InitFlags flags) { CheckError(SDL_Init(flags)); }
 
template<class FLAG0, class FLAG1, class... FLAGS>
inline void InitSubSystem(FLAG0 flag0, FLAG1 flag1, FLAGS... flags)
{
  InitSubSystem(flag0);
  InitSubSystem(flag1, flags...);
}
 
template<class FLAG, class... FLAGS>
inline void InitSubSystem(FLAG flag0, FLAG flag1, FLAGS... flags)
{
  return InitSubSystem(flag0 | flag1, flags...);
}
 
inline void QuitSubSystem(InitFlags flags) { SDL_QuitSubSystem(flags); }
 
template<class FLAG0, class FLAG1, class... FLAGS>
inline void QuitSubSystem(FLAG0 flag0, FLAG1 flag1, FLAGS... flags)
{
  if (!QuitSubSystem(flag0)) return;
  QuitSubSystem(flag1, flags...);
}
 
template<class FLAG, class... FLAGS>
inline void QuitSubSystem(FLAG flag0, FLAG flag1, FLAGS... flags)
{
  QuitSubSystem(flag0 | flag1, flags...);
}
 
inline bool WasInit(InitFlags flags) { return SDL_WasInit(flags) == flags; }
 
template<class FLAG0, class FLAG1, class... FLAGS>
inline bool WasInit(FLAG0 flag0, FLAG1 flag1, FLAGS... flags)
{
  if (WasInit(flag0)) return WasInit(flag1, flags...);
  return false;
}
 
template<class FLAG, class... FLAGS>
inline bool WasInit(FLAG flag0, FLAG flag1, FLAGS... flags)
{
  return WasInit(flag0 | flag1, flags...);
}
 
inline void Quit() { SDL_Quit(); }
 
class SDL
{
  bool m_active = false;
 
  bool updateActive(bool active);
 
public:
  template<class... FLAGS>
  SDL(FLAGS... flags)
  {
    if (updateActive(true)) {
      try {
        InitSubSystem(flags...);
      } catch (...) {
        updateActive(false);
        throw;
      }
    }
  }
 
  constexpr SDL() = default;
 
  // Copy ctor
  SDL(const SDL& other) = delete;
 
  constexpr SDL(SDL&& other)
    : m_active(other.m_active)
  {
    other.m_active = false;
  }
 
  // Dtor
  ~SDL() { reset(); }
 
  SDL& operator=(SDL rhs)
  {
    std::swap(m_active, rhs.m_active);
    return *this;
  }
 
  bool release()
  {
    bool wasActive = m_active;
    if (wasActive) { updateActive(false); }
    return wasActive;
  }
 
  bool reset()
  {
    if (release()) Quit();
    return false;
  }
 
  operator bool() const { return m_active; }
};
 
inline bool IsMainThread() { return SDL_IsMainThread(); }
 
using MainThreadCallback = SDL_MainThreadCallback;
 
using MainThreadCB = std::function<void()>;
 
 
inline void RunOnMainThread(MainThreadCallback callback,
                            void* userdata,
                            bool wait_complete)
{
  CheckError(SDL_RunOnMainThread(callback, userdata, wait_complete));
}
 
inline void RunOnMainThread(MainThreadCB callback, bool wait_complete)
{
  using Wrapper = CallbackWrapper<MainThreadCB>;
  void* wrapped = Wrapper::Wrap(std::move(callback));
  try {
    RunOnMainThread(&Wrapper::CallOnce, wrapped, wait_complete);
  } catch (...) {
    Wrapper::release(wrapped);
    throw;
  }
}
 
inline void SetAppMetadata(StringParam appname,
                           StringParam appversion,
                           StringParam appidentifier)
{
  CheckError(SDL_SetAppMetadata(appname, appversion, appidentifier));
}
 
inline void SetAppMetadataProperty(StringParam name, StringParam value)
{
  CheckError(SDL_SetAppMetadataProperty(name, value));
}
 
namespace prop::appMetaData {
 
constexpr auto NAME_STRING = SDL_PROP_APP_METADATA_NAME_STRING;
 
constexpr auto VERSION_STRING = SDL_PROP_APP_METADATA_VERSION_STRING;
 
constexpr auto IDENTIFIER_STRING = SDL_PROP_APP_METADATA_IDENTIFIER_STRING;
 
constexpr auto CREATOR_STRING = SDL_PROP_APP_METADATA_CREATOR_STRING;
 
constexpr auto COPYRIGHT_STRING = SDL_PROP_APP_METADATA_COPYRIGHT_STRING;
 
constexpr auto URL_STRING = SDL_PROP_APP_METADATA_URL_STRING;
 
constexpr auto TYPE_STRING = SDL_PROP_APP_METADATA_TYPE_STRING;
 
} // namespace prop::appMetaData
 
inline const char* GetAppMetadataProperty(StringParam name)
{
  return SDL_GetAppMetadataProperty(name);
}
 
#pragma region impl
 
#ifndef SDL3PP_APPCLASS_LOG_PRIORITY
#define SDL3PP_APPCLASS_LOG_PRIORITY LOG_PRIORITY_CRITICAL
#endif // SDL3PP_APPCLASS_LOG_PRIORITY
 
using AppArgs = std::span<char const* const>;
 
template<class T>
inline AppResult DefaultCreateClass(T** state, AppArgs args)
{
  static_assert(std::is_default_constructible_v<T>);
  *state = new T{};
  return APP_CONTINUE;
}
 
template<class T>
  requires std::convertible_to<AppArgs, T>
inline AppResult DefaultCreateClass(T** state, AppArgs args)
{
  *state = new T{args};
  return APP_CONTINUE;
}
 
template<class T>
concept HasInitFunction = requires(T** state) {
  { T::Init(state, AppArgs{}) } -> std::convertible_to<AppResult>;
};
 
template<class T>
inline AppResult InitClass(T** state, AppArgs args)
{
  try {
    return DefaultCreateClass(state, args);
  } catch (std::exception& e) {
    LOG_CATEGORY_APPLICATION.LogUnformatted(SDL3PP_APPCLASS_LOG_PRIORITY,
                                            e.what());
  } catch (...) {
  }
  return APP_FAILURE;
}
 
template<HasInitFunction T>
inline AppResult InitClass(T** state, AppArgs args)
{
  *state = nullptr;
  try {
    AppResult result = T::Init(state, args);
    if (*state == nullptr && result != APP_FAILURE) return APP_SUCCESS;
    return result;
  } catch (std::exception& e) {
    LOG_CATEGORY_APPLICATION.LogUnformatted(SDL3PP_APPCLASS_LOG_PRIORITY,
                                            e.what());
  } catch (...) {
  }
  return APP_FAILURE;
}
 
template<class T>
concept HasIterateFunction = requires(T* state) { state->Iterate(); };
 
template<HasIterateFunction T>
inline AppResult IterateClass(T* state)
{
  try {
    return state->Iterate();
  } catch (std::exception& e) {
    LOG_CATEGORY_APPLICATION.LogUnformatted(SDL3PP_APPCLASS_LOG_PRIORITY,
                                            e.what());
  } catch (...) {
  }
  return APP_FAILURE;
}
 
template<class T>
concept HasEventFunction =
  requires(T* state, const SDL_Event& event) { state->Event(event); };
 
template<class T>
inline AppResult DefaultEventClass(T* state, const SDL_Event& event)
{
  if (event.type == SDL_EVENT_QUIT) return APP_SUCCESS;
  return APP_CONTINUE;
}
 
template<class T>
inline AppResult EventClass(T* state, const SDL_Event& event)
{
  try {
    return DefaultEventClass(state, event);
  } catch (std::exception& e) {
    LOG_CATEGORY_APPLICATION.LogUnformatted(SDL3PP_APPCLASS_LOG_PRIORITY,
                                            e.what());
  } catch (...) {
  }
  return APP_FAILURE;
}
 
template<HasEventFunction T>
inline AppResult EventClass(T* state, const SDL_Event& event)
{
  try {
    return state->Event(event);
  } catch (std::exception& e) {
    LOG_CATEGORY_APPLICATION.LogUnformatted(SDL3PP_APPCLASS_LOG_PRIORITY,
                                            e.what());
  } catch (...) {
  }
  return APP_FAILURE;
}
 
 
template<class T>
inline void DefaultClassDestroy(T* state)
{
  delete state;
}
 
template<class T>
concept HasQuitFunction =
  requires(T* state, AppResult result) { T::Quit(state, result); };
 
template<class T>
inline void QuitClass(T* state, AppResult result)
{
  DefaultClassDestroy(state);
}
 
template<HasQuitFunction T>
inline void QuitClass(T* state, AppResult result)
{
  T::Quit(state, result);
}
 
 
inline bool SDL::updateActive(bool active)
{
  static std::atomic_bool currentlyInitd{false};
  bool result = !currentlyInitd.exchange(active);
  if (active && !result) {
    SetErrorUnformatted(
      "Can not initialize, there is already an active instance");
  } else
    m_active = active;
  return result;
}
 
#pragma endregion
 
} // namespace SDL
 
#endif /* SDL3PP_INIT_H_ */