application_shell_internal.h

#pragma once
 
#include "pixelbullet/core/event.h"
 
#include "pixelbullet/application/application_internal.h"
#include "pixelbullet/application/launch_gpu_defaults_internal.h"
#include "pixelbullet/graphics/gpu_session.h"
 
#include <filesystem>
#include <functional>
#include <memory>
#include <optional>
#include <string>
 
namespace pixelbullet
{
class Layer;
struct GraphicsConfig;
struct WindowConfig;
} // 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_graphics_resource_cache;
    std::function<void(const WindowConfig&)> create_window;
    std::function<void(const std::function<void(pixelbullet::core::Event&)>&)> set_window_event_callback;
    std::function<void(const GraphicsConfig&)> create_graphics;
    std::function<void(const GraphicsDeviceSelectionSession&)> set_graphics_device_selection_session;
    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_window_callbacks;
    std::function<void()> clear_renderer;
    std::function<void(UiFrameLayer*&)> reset_layer_stack;
    std::function<void()> reset_graphics_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 GraphicsDeviceSelectionSession& device_selection_session,
                             const std::function<void(pixelbullet::core::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