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_events.h"
#include "SDL3pp_log.h"
#include "SDL3pp_strings.h"
 
namespace SDL {
 
using InitFlags = Uint32;
 
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 = AppResult(SDLCALL*)(void** appstate,
                                         int argc,
                                         char* argv[]);
 
using AppIterate_func = AppResult(SDLCALL*)(void* appstate);
 
using AppEvent_func = AppResult(SDLCALL*)(void* appstate, Event* event);
 
using AppQuit_func = void(SDLCALL*)(void* appstate, AppResult result);
 
 
inline void Init(InitFlags flags) { CheckError(SDL_Init(flags)); }
 
inline void InitSubSystem(InitFlags flags)
{
  CheckError(SDL_InitSubSystem(flags));
}
 
inline void QuitSubSystem(InitFlags flags) { SDL_QuitSubSystem(flags); }
 
inline InitFlags WasInit(InitFlags flags) { return SDL_WasInit(flags); }
 
inline void Quit() { SDL_Quit(); }
 
inline bool IsMainThread() { return SDL_IsMainThread(); }
 
using MainThreadCallback = void(SDLCALL*)(void* userdata);
 
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));
  RunOnMainThread(&Wrapper::CallOnce, wrapped, wait_complete);
}
 
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);
}
 
#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);
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_INIT_H_ */