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>
  requires std::convertible_to<AppArgs, T>
inline AppResult DefaultCreateClass(T** state, AppArgs args)
{
  *state = new T{args};
  return APP_CONTINUE;
}
 
template<class T>
inline AppResult DefaultCreateClass(T** state, AppArgs)
{
  static_assert(std::is_default_constructible_v<T>);
  *state = new T{};
  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*, 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)
{
  DefaultClassDestroy(state);
}
 
template<HasQuitFunction T>
inline void QuitClass(T* state, AppResult result)
{
  T::Quit(state, result);
}

 
} // namespace SDL
 
#endif /* SDL3PP_INIT_H_ */