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 SDL::LOG_PRIORITY_CRITICAL
#endif // SDL3PP_APPCLASS_LOG_PRIORITY

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