application.h

#pragma once
 
#include "pixelbullet/core/event.h"
 
#include "pixelbullet/window/window_events.h"
 
#include "pixelbullet/application/specification.h"
 
#include <memory>
#include <type_traits>
#include <utility>
 
namespace pixelbullet
{
struct ApplicationBootstrap;
class Application;
using ApplicationFactory = std::unique_ptr<Application> (*)(const ApplicationBootstrap& bootstrap);
 
namespace integration::application::runtime
{
class ApplicationHostControlBinding;
}
 
class ApplicationState;
class Filesystem;
class GraphicsResourceCache;
 
class Window;
class Graphics;
 
class Audio;
 
class Layer;
class LayerStack;
class UiFrameLayer;

class Application
{
public:
    explicit Application(ApplicationSpecification specification, const ApplicationBootstrap& bootstrap);

    virtual ~Application();

    Application(const Application&) = delete;

    Application& operator=(const Application&) = delete;

    Application(Application&&) = delete;

    Application& operator=(Application&&) = delete;

    void OnEvent(pixelbullet::core::Event& e);

    template <typename T, typename... Args>
    T* PushLayer(Args&&... args)
    {
        static_assert(std::is_base_of<Layer, T>::value, "T must be derived from Layer");
        auto layer = std::make_unique<T>(std::forward<Args>(args)...);
        return static_cast<T*>(PushLayerImpl(std::move(layer)));
    }

    template <typename T, typename... Args>
    T* PushOverlay(Args&&... args)
    {
        static_assert(std::is_base_of<Layer, T>::value, "T must be derived from Layer");
        auto layer = std::make_unique<T>(std::forward<Args>(args)...);
        return static_cast<T*>(PushOverlayImpl(std::move(layer)));
    }

    const ApplicationSpecification& GetSpecification() const;

    Window& GetWindow();

    Graphics& GetGraphics();

    Audio& GetAudio();
 
    Filesystem& GetFilesystem();
    const Filesystem& GetFilesystem() const;
 
    GraphicsResourceCache& GetGraphicsResourceCache();
    const GraphicsResourceCache& GetGraphicsResourceCache() const;
 
    void Start() noexcept;
    void Stop() noexcept;
 
    [[nodiscard]] bool IsRunning() const noexcept;
 
    static int Launch(const ApplicationBootstrap& bootstrap, ApplicationFactory factory);
 
private:
    friend class integration::application::runtime::ApplicationHostControlBinding;
 
    enum class RunResult
    {
        Completed,
        SmokeSucceeded,
        SmokeTimedOut
    };

    RunResult Run();

    pixelbullet::core::EventResult OnWindowClose(pixelbullet::window::WindowCloseEvent& e);

    pixelbullet::core::EventResult OnWindowResize(pixelbullet::window::WindowResizeEvent& e);
    Layer* PushLayerImpl(std::unique_ptr<Layer> layer);
    Layer* PushOverlayImpl(std::unique_ptr<Layer> layer);
    void RegisterUiFrameLayer(Layer* layer);
 
    std::unique_ptr<ApplicationState> state_;
};
} // namespace pixelbullet