Application.hpp

#pragma once
 
#include "PixelBullet/Application/Assert.hpp"
#include "PixelBullet/Application/LayerStack.hpp"
 
#include "tools/cpp/runfiles/runfiles.h"
 
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
int main(int argc, char* argv[]);
 
namespace PixelBullet
{
    struct ApplicationSpecification;
    struct ApplicationCommandLineArgs;
 
    class ResourceLocator;
 
    class Window;
    class Graphics;
 
    class Event;
    class WindowCloseEvent;
    class WindowResizeEvent;
 
    class Audio;
 
    class Layer;
 
    class Application
    {
    public:
        explicit Application(const ApplicationSpecification& specification, const char* binaryPath);
 
        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>
        void 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)...);
            layer->OnAttach();
            m_LayerStack->PushLayer(std::move(layer));
        }
 
        template <typename T, typename... Args>
        void 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)...);
            layer->OnAttach();
            m_LayerStack->PushOverlay(std::move(layer));
        }
 
        static Application& Get()
        {
            ASSERT(s_Instance, "Application instance is null!");
            return *s_Instance;
        }
 
        const ApplicationSpecification& GetSpecification() const
        {
            ASSERT(m_Specification, "Application specification is null!");
            return *m_Specification;
        }
 
        Window& GetWindow()
        {
            ASSERT(m_Window, "Window has not been initialized!");
            return *m_Window;
        }
 
        Graphics& GetGraphics()
        {
            ASSERT(m_Graphics, "Graphics system has not been initialized!");
            return *m_Graphics;
        }
 
        Audio& GetAudio()
        {
            ASSERT(m_Audio, "Audio system has not been initialized!");
            return *m_Audio;
        }
 
        ResourceLocator& GetResourceLocator()
        {
            ASSERT(m_ResourceLocator, "Resource locator has not been initialized!");
            return *m_ResourceLocator;
        }
 
        bazel::tools::cpp::runfiles::Runfiles& GetRunfiles()
        {
            ASSERT(m_Runfiles, "Bazel runfiles are not available!");
            return *m_Runfiles;
        }
 
        void Start() noexcept
        {
            m_Running = true;
        }
        void Stop() noexcept
        {
            m_Running = false;
        }
 
        [[nodiscard]] inline bool IsRunning() const noexcept
        {
            return m_Running;
        }
 
        void Restart(const ApplicationSpecification& newSpecification);
 
        void SubmitToMainThread(std::function<void()> function);
 
    private:
        void Run();
 
        bool OnWindowClose(WindowCloseEvent& e);
 
        bool OnWindowResize(WindowResizeEvent& e);
 
        void ExecuteMainThreadQueue();
 
    private:
        std::unique_ptr<ResourceLocator> m_ResourceLocator;
        std::unique_ptr<bazel::tools::cpp::runfiles::Runfiles> m_Runfiles; 
        std::unique_ptr<Window> m_Window;     
        std::unique_ptr<Graphics> m_Graphics; 
        std::unique_ptr<Audio> m_Audio;
 
        std::unique_ptr<LayerStack> m_LayerStack; 
    private:
        const ApplicationSpecification* m_Specification; 
        bool m_Running = true;        
        bool m_Minimized = false;     
        float m_LastFrameTime = 0.0f; 
        std::vector<std::function<void()>> m_MainThreadQueue; 
        std::mutex m_MainThreadQueueMutex;                    
    private:
        static Application* s_Instance; 
        static int Launch(const ApplicationCommandLineArgs& cliArgs, const char* binaryPath);
 
        friend int ::main(int argc, char* argv[]);
    };
 
    Application* CreateApplication(const ApplicationCommandLineArgs& args, const char* binaryPath);
} // namespace PixelBullet