SDL3pp_main.h

#ifndef SDL3PP_MAIN_H_
#define SDL3PP_MAIN_H_
 
#ifdef SDL3PP_MAIN_HANDLED
#define SDL_MAIN_HANDLED
#endif // SDL3PP_MAIN_HANDLED
 
#ifdef SDL3PP_MAIN_USE_CALLBACKS
#define SDL_MAIN_USE_CALLBACKS
#endif // SDL3PP_MAIN_USE_CALLBACKS
 
#ifdef SDL3PP_MAIN_USE_CLASS_CALLBACKS
#define SDL_MAIN_USE_CALLBACKS
#endif // SDL3PP_MAIN_USE_CLASS_CALLBACKS
 
#include <SDL3/SDL_main.h>
#include "SDL3pp.h"
 
namespace SDL {

 
#ifdef SDL3PP_DOC

#define SDL3PP_MAIN_HANDLED SDL_MAIN_HANDLED

#define SDL3PP_MAIN_USE_CALLBACKS SDL_MAIN_USE_CALLBACKS

#define SDL3PP_MAIN_USE_CLASS_CALLBACKS 1
 
#endif // SDL3PP_DOC

using main_func = int(SDLCALL*)(int argc, char* argv[]);

inline void SetMainReady() { SDL_SetMainReady(); }

inline int RunApp(int argc,
                  char* argv[],
                  main_func mainFunction,
                  void* reserved)
{
  return SDL_RunApp(argc, argv, mainFunction, reserved);
}

inline int EnterAppMainCallbacks(int argc,
                                 char* argv[],
                                 AppInit_func appinit,
                                 AppIterate_func appiter,
                                 AppEvent_func appevent,
                                 AppQuit_func appquit)
{
  return SDL_EnterAppMainCallbacks(
    argc, argv, appinit, appiter, appevent, appquit);
}
 
#if defined(SDL_PLATFORM_WINDOWS)

inline bool RegisterApp(StringParam name, Uint32 style, void* hInst)
{
  return SDL_RegisterApp(name, style, hInst);
}

inline void UnregisterApp() { SDL_UnregisterApp(); }
 
#endif /* defined(SDL_PLATFORM_WINDOWS) */

inline void GDKSuspendComplete() { SDL_GDKSuspendComplete(); }

struct AppInterface
{
  virtual ~AppInterface() = default;

  virtual SDL::AppResult Init() { return SDL::APP_CONTINUE; }

  virtual SDL::AppResult Iterate() { return SDL::APP_CONTINUE; }

  virtual SDL::AppResult Event(const SDL::Event& ev)
  {
    return ev.type == SDL_EVENT_QUIT ? SDL::APP_SUCCESS : SDL::APP_CONTINUE;
  }

  virtual void quit(SDL::AppResult result) {}
};
 
} // namespace SDL

extern "C" SDLMAIN_DECLSPEC SDL::AppInterface* SDLCALL
SDL_AppCreate(int argc, char* argv[]);

namespace SDL {
 
#ifdef SDL3PP_MAIN_USE_CLASS_CALLBACKS

extern "C" SDLMAIN_DECLSPEC SDL::AppResult SDL_AppInit(void** appstate,
                                                       int argc,
                                                       char* argv[])
{
  try {
    auto app = SDL_AppCreate(argc, argv);
    if (!app) return APP_SUCCESS;
    *appstate = app;
    app->Init();
    return APP_CONTINUE;
  } catch (std::exception& e) {
    LOG_CATEGORY_APPLICATION.LogUnformatted(SDL3PP_APPCLASS_LOG_PRIORITY,
                                            e.what());
  } catch (...) {
    LOG_CATEGORY_APPLICATION.LogUnformatted(
      SDL3PP_APPCLASS_LOG_PRIORITY, "Critical error during app initialization");
  }
  return APP_FAILURE;
}

extern "C" SDLMAIN_DECLSPEC SDL::AppResult SDL_AppIterate(void* appstate)
{
  try {
    return static_cast<AppInterface*>(appstate)->Iterate();
  } catch (std::exception& e) {
    LOG_CATEGORY_APPLICATION.LogUnformatted(SDL3PP_APPCLASS_LOG_PRIORITY,
                                            e.what());
  } catch (...) {
    LOG_CATEGORY_APPLICATION.LogUnformatted(
      SDL3PP_APPCLASS_LOG_PRIORITY, "Critical error during app iteration");
  }
  return APP_FAILURE;
}

extern "C" SDLMAIN_DECLSPEC SDL::AppResult SDL_AppEvent(void* appstate,
                                                        SDL::Event* event)
{
  try {
    return static_cast<AppInterface*>(appstate)->Event(*event);
  } catch (std::exception& e) {
    LOG_CATEGORY_APPLICATION.LogUnformatted(SDL3PP_APPCLASS_LOG_PRIORITY,
                                            e.what());
  } catch (...) {
    LOG_CATEGORY_APPLICATION.LogUnformatted(
      SDL3PP_APPCLASS_LOG_PRIORITY, "Critical error during app event handling");
  }
  return APP_FAILURE;
}

extern "C" SDLMAIN_DECLSPEC void SDL_AppQuit(void* appstate,
                                             SDL::AppResult result)
{
  try {
    auto app = static_cast<AppInterface*>(appstate);
    if (!app) return;
    app->quit(result);
    delete app;
  } catch (std::exception& e) {
    LOG_CATEGORY_APPLICATION.LogUnformatted(SDL3PP_APPCLASS_LOG_PRIORITY,
                                            e.what());
  } catch (...) {
    LOG_CATEGORY_APPLICATION.LogUnformatted(SDL3PP_APPCLASS_LOG_PRIORITY,
                                            "Critical error during app exit");
  }
}

#define SDL3PP_DEFINE_CALLBACKS(CLASS)                                         \
  extern "C" SDLMAIN_DECLSPEC SDL::AppInterface* SDLCALL SDL_AppCreate(        \
    int, char*[])                                                              \
  {                                                                            \
    return new CLASS();                                                        \
  }

#define SDL3PP_DEFINE_CLASS_CALLBACKS(                                         \
  CLASS, INIT_FLAGS, APPNAME, APPVERSION, APPIDENTIFIER)                       \
  extern "C" SDLMAIN_DECLSPEC SDL::AppInterface* SDLCALL SDL_AppCreate(        \
    int, char*[])                                                              \
  {                                                                            \
    SDL::SetAppMetadata(APPNAME, APPVERSION, APPIDENTIFIER);                   \
    SDL::Init(INIT_FLAGS);                                                     \
    return new CLASS();                                                        \
  }
 
#else // SDL3PP_MAIN_USE_CLASS_CALLBACKS

#define SDL3PP_DEFINE_CALLBACKS(CLASS)                                         \
  static_assert(SDL::HasIterateFunction<CLASS>, "Main class not compatible");  \
  inline SDL::AppResult SDL_AppInit(void** appstate, int argc, char* argv[])   \
  {                                                                            \
    return SDL::InitClass(reinterpret_cast<CLASS**>(appstate),                 \
                          SDL::AppArgs{argv, size_t(argc)});                   \
  }                                                                            \
  inline SDL::AppResult SDL_AppIterate(void* appstate)                         \
  {                                                                            \
    return SDL::IterateClass(static_cast<CLASS*>(appstate));                   \
  }                                                                            \
  inline SDL::AppResult SDL_AppEvent(void* appstate, SDL::Event* event)        \
  {                                                                            \
    return SDL::EventClass(static_cast<CLASS*>(appstate), *event);             \
  }                                                                            \
  inline void SDL_AppQuit(void* appstate, SDL::AppResult result)               \
  {                                                                            \
    SDL::QuitClass(static_cast<CLASS*>(appstate), result);                     \
  }
 
#endif // SDL3PP_MAIN_USE_CLASS_CALLBACKS

 
} // namespace SDL
 
#endif /* SDL3PP_MAIN_H_ */