app.h

Go to the documentation of this file.

 
#pragma once
 
#include <exception>
#include <filesystem>
#include <memory>
#include <span>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
#include <rex/cli.h>
#include <rex/platform.h>
#include <rex/platform/process.h>
#include <rex/app_info.h>
#include <rex/module.h>
#include <rex/result.h>
#include <rex/setting.h>
#include <rex/settings_registry.h>
#include <rex/types.h>
 
#if REX_PLATFORM_WIN32
#include <windows.h>
#endif
 
namespace rex {
 
namespace gpu {
class IGraphicsSystem;
}  // namespace gpu
namespace apu {
class IAudioSystem;
}  // namespace apu
namespace hid {
class IInputSystem;
}  // namespace hid
namespace ui {
class IUISystem;
}  // namespace ui
 
}  // namespace rex
 
namespace rex::app {

enum class AppPhase : u8 {
  kStart,       
  kProviders,   
  kRunning,     
  kTitleLaunch, 
  kTitleRunning,
  kTitleStop, 
  kShutdown,  
};

class REX_APP_API App : public SettingOwner {
 public:
  REX_SETTING(std::string, name, "", "App name, set by the constructor", kStartupOnly, kNoSave);
  REX_SETTING(std::filesystem::path, root, "",
              "Folder the app keeps its files in, the folder of the executable when empty",
              kStartupOnly);
  REX_SETTING(std::filesystem::path, log_root, "{app.root}/logs", "Log folder", kStartupOnly);
  REX_SETTING(std::string, single_instance, "",
              "Lock name only one running copy may hold, empty for none", kStartupOnly);

  explicit App(std::string_view name);
  ~App() override;
 
  App(const App&) = delete;
  App& operator=(const App&) = delete;
 
  std::string_view GetName() const;
 
  AppPhase GetPhase() const;

  std::span<const std::string> GetArgs() const;

  rex::hid::IInputSystem& GetInput();
 
  rex::gpu::IGraphicsSystem& GetGraphics();
 
  rex::apu::IAudioSystem& GetAudio();
 
  rex::ui::IUISystem& GetUI();

  void RequestShutdown();

  void RequestRestart();

  [[nodiscard]] Result<void> Init(const CLIArgList& args);

  bool RunFrame();

  void Run();

  int Shutdown();
 
 protected:
  virtual AppSysRequirements GetRequirements() const;

  [[nodiscard]] virtual Result<void> OnConfigure(SettingsRegistry& settings);

  virtual std::span<const CLIAction> GetActions() const;

  [[nodiscard]] virtual Result<void> OnAction(const CLIActionHit& hit);

  virtual void OnModules(std::vector<std::string>& modules);

  virtual void OnRegisterModules(std::vector<IModule*>& modules);

  [[nodiscard]] virtual Result<void> OnInit();

  virtual void OnRun();

  virtual void OnShutdown();

  virtual void ReportError(std::string_view message);

  virtual platform::CrashReporterOptions GetCrashOptions();

  rex::ui::IUISystem* FindUI();

  bool IsHeadlessRequested() const;

  [[nodiscard]] Result<void> Fail(std::string_view step, Error error);

  virtual void OnStop();

  virtual void OnRelease();

  IInterfaceFactory& GetControlFactory();

  void SetPhase(AppPhase phase);
 
 private:
  [[nodiscard]] Result<void> ReportUnknownSettings();
 
  struct State;
  std::unique_ptr<State> state_;
};

REX_APP_API void RequestShutdown(i32 exit_code);

REX_APP_API void RequestRestart(std::vector<std::string> args = {});

REX_APP_API bool IsShutdownRequested();
 
}  // namespace rex::app

#define REX_CONSOLE_APP(AppClass)                             \
  static int ReXConsoleEntry(const ::rex::CLIArgList& args) { \
    AppClass rex_app;                                         \
    if (rex_app.Init(args)) {                                 \
      rex_app.Run();                                          \
    }                                                         \
    return rex_app.Shutdown();                                \
  }                                                           \
  REX_DETAIL_ENTRY_POINTS(ReXConsoleEntry)

#define REX_CONSOLE_APP_MAIN(AppClass, Function)              \
  static int ReXConsoleEntry(const ::rex::CLIArgList& args) { \
    AppClass rex_app;                                         \
    return Function(rex_app, args);                           \
  }                                                           \
  REX_DETAIL_ENTRY_POINTS(ReXConsoleEntry)
 
namespace rex::app {
 
namespace detail {

REX_APP_API int ReportEntryFailure(const char* what) noexcept;

template <typename Fn>
int RunGuarded(Fn&& fn) noexcept {
  try {
    return std::forward<Fn>(fn)();
  } catch (const std::exception& error) {
    return ReportEntryFailure(error.what());
  } catch (...) {
    return ReportEntryFailure("unknown exception");
  }
}
 
#if REX_PLATFORM_WIN32
REX_APP_API CLIArgList GetWindowsCommandLine();
#endif
 
}  // namespace detail
 
}  // namespace rex::app
 
#if REX_PLATFORM_WIN32
#define REX_DETAIL_ENTRY_POINTS(fn)                                      \
  int WINAPI wWinMain(HINSTANCE, HINSTANCE, PWSTR, int) {                \
    return ::rex::app::detail::RunGuarded(                               \
        [] { return fn(::rex::app::detail::GetWindowsCommandLine()); }); \
  }                                                                      \
  int main(int argc, char** argv) {                                      \
    return ::rex::app::detail::RunGuarded(                               \
        [&] { return fn(::rex::CLIArgList::Parse(argc, argv)); });       \
  }
#else
#define REX_DETAIL_ENTRY_POINTS(fn)                                \
  int main(int argc, char** argv) {                                \
    return ::rex::app::detail::RunGuarded(                         \
        [&] { return fn(::rex::CLIArgList::Parse(argc, argv)); }); \
  }
#endif