application.h

#pragma once
 
#include "pixelbullet/application/event.h"
#include "pixelbullet/application/specification.h"
#include "pixelbullet/core/assert.h"
 
#include <memory>
#include <type_traits>
#include <utility>
 
namespace pixelbullet
{
struct ApplicationBootstrap;
class Application;
using ApplicationFactory = std::unique_ptr<Application> (*)(const ApplicationBootstrap& bootstrap);
 
class Filesystem;
class ResourceCache;
 
class Window;
class Graphics;
 
class Event;
class WindowCloseEvent;
class WindowResizeEvent;
 
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(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
    {
        return specification_;
    }
 
    Window& GetWindow()
    {
        ASSERT(window_, "Window has not been initialized!");
        return *window_;
    }
 
    Graphics& GetGraphics()
    {
        ASSERT(graphics_, "Graphics system has not been initialized!");
        return *graphics_;
    }
 
    Audio& GetAudio()
    {
        ASSERT(audio_, "Audio system has not been initialized!");
        return *audio_;
    }
 
    Filesystem& GetFilesystem()
    {
        ASSERT(filesystem_, "Filesystem has not been initialized!");
        return *filesystem_;
    }
    const Filesystem& GetFilesystem() const
    {
        ASSERT(filesystem_, "Filesystem has not been initialized!");
        return *filesystem_;
    }
 
    ResourceCache& GetResourceCache()
    {
        ASSERT(resource_cache_, "Resource cache has not been initialized!");
        return *resource_cache_;
    }
    const ResourceCache& GetResourceCache() const
    {
        ASSERT(resource_cache_, "Resource cache has not been initialized!");
        return *resource_cache_;
    }
 
    void Start() noexcept
    {
        running_ = true;
    }
    void Stop() noexcept
    {
        running_ = false;
    }
 
    [[nodiscard]] inline bool IsRunning() const noexcept
    {
        return running_;
    }
 
    static int Launch(const ApplicationBootstrap& bootstrap, ApplicationFactory factory);
 
private:
    enum class RunResult
    {
        Completed,
        SmokeSucceeded,
        SmokeTimedOut
    };
 
    RunResult Run();
 
    EventResult OnWindowClose(WindowCloseEvent& e);
 
    EventResult OnWindowResize(WindowResizeEvent& e);
    Layer* PushLayerImpl(std::unique_ptr<Layer> layer);
    Layer* PushOverlayImpl(std::unique_ptr<Layer> layer);
    void RegisterUiFrameLayer(Layer* layer);
 
    std::unique_ptr<Filesystem> filesystem_;
    std::unique_ptr<ResourceCache> resource_cache_;
 
    std::unique_ptr<Window> window_;     
    std::unique_ptr<Graphics> graphics_; 
    std::unique_ptr<Audio> audio_;
 
    std::unique_ptr<LayerStack> layer_stack_; 
    UiFrameLayer* ui_frame_layer_ = nullptr;
 
private:
    ApplicationSpecification specification_; 
    ApplicationLaunchOptions launch_options_;
 
    bool running_ = true;          
    bool minimized_ = false;       
    float last_frame_time_ = 0.0f; 
};
} // namespace pixelbullet