application_shell_internal.h

#pragma once
 
#include "application_internal.h"
 
#include "pixelbullet/application/launch_gpu_defaults_internal.h"
 
#include <filesystem>
#include <functional>
#include <memory>
#include <optional>
#include <string>
 
namespace pixelbullet
{
class Event;
class Layer;
} // namespace pixelbullet
 
namespace pixelbullet::application_internal
{
struct RuntimeInitializationSummary
{
    bool runfiles_available = false;
    std::filesystem::path packaged_runtime_root;
};
 
struct RuntimeShellBindings
{
    std::function<RuntimeInitializationSummary(const ApplicationSpecification&, const std::string&)> create_filesystem;
    std::function<void()> create_resource_cache;
    std::function<void(const ApplicationSpecification&, bool)> create_window;
    std::function<void(const std::function<void(Event&)>&)> set_window_event_callback;
    std::function<void(const ApplicationSpecification&, const ApplicationLaunchOptions&)> create_graphics;
    std::function<void(const ResolvedLaunchGpuDefaults&)> set_graphics_launch_gpu_defaults;
    std::function<void(const std::function<void(uint32_t)>&)> set_framebuffer_resize_callback;
    std::function<void(const std::string&)> set_window_icon;
    std::function<void()> create_audio;
    std::function<void()> create_layer_stack;
    std::function<void()> clear_renderer;
    std::function<void(UiFrameLayer*&)> reset_layer_stack;
    std::function<void()> reset_resource_cache;
};
 
enum class LayerInsertion
{
    Layer,
    Overlay
};
 
enum class LaunchRunOutcome
{
    Completed,
    SmokeSucceeded,
    SmokeTimedOut
};
 
struct LaunchShellBindings
{
    std::function<std::optional<int>(const ApplicationBootstrap&)> execute_cli;
    std::function<LaunchRunOutcome(const ApplicationBootstrap&)> run_application;
};
 
struct LaunchExecutionResult
{
    int exit_code = 1;
    bool cli_handled = false;
};
 
[[nodiscard]] RuntimeInitializationSummary InitializeApplicationRuntime(ApplicationState& state, const ApplicationBootstrap& bootstrap,
                                                                        const ResolvedLaunchGpuDefaults& launch_gpu_defaults,
                                                                        const std::function<void(Event&)>& event_callback,
                                                                        const std::function<void(uint32_t)>& framebuffer_resize_callback,
                                                                        const RuntimeShellBindings& bindings);
void ShutdownApplicationRuntime(ApplicationState& state, const RuntimeShellBindings& bindings) noexcept;
[[nodiscard]] Layer* AttachLayer(ApplicationState& state, std::unique_ptr<Layer> layer, LayerInsertion insertion);
[[nodiscard]] int MapLaunchRunOutcomeToExitCode(LaunchRunOutcome outcome) noexcept;
[[nodiscard]] LaunchExecutionResult ExecuteLaunchShell(const ApplicationBootstrap& bootstrap, const LaunchShellBindings& bindings);
} // namespace pixelbullet::application_internal