Application.hpp

Go to the documentation of this file.

#pragma once 
#include "EventSystem/Event.hpp"
#include "Window.hpp"
#include "Layer.hpp"
#include "LayerStack.hpp"
#include "ImGuiLayer.hpp"
#include "WorldSystem/SceneManager.hpp"
#include "Time.hpp"
#include "Core/Threading/MainThreadComandQueue.hpp"
#include "Core/Threading/ThreadPool.hpp"

namespace Cori {
    namespace Core {
        class Application {
        public:
            explicit Application(const char* windowName);
            virtual ~Application();

            void Run();

            [[nodiscard]] static std::expected<void, CoriError<>> PushLayer(Layer* layer);

            [[nodiscard]] static std::expected<void, CoriError<>> PushOverlay(Layer* overlay);
 

            static void PopLayer();

            static void PopOverlay();

            static void SetBackgroundColor(const glm::vec4& color);

            static Window& GetWindow() { return *s_Instance->m_Window; }

            static GameTimer& GetGameTimer() { return s_Instance->m_GameTimer; }

            static void EmitEvent(Event& event);

            template <class F, class... Args>
            static std::future<std::invoke_result_t<F, Args...>> SubmitMainTask(F&& f, Args&&... args) {
                return s_Instance->m_CommandQueue.Submit(std::forward<F>(f), std::forward<Args>(args)...);
            }

            template <class F, class... Args>
            static std::future<std::invoke_result_t<F, Args...>> SubmitWorkerTask(F&& f, Args&&... args) {
                return s_Instance->m_WorkerPool.Submit(std::forward<F>(f), std::forward<Args>(args)...);
            }

            static uint16_t GetWorkerCount();
 
        private:
            void OnEvent(Event& event);
 
            void TickrateUpdate(GameTimer& gameTimer);
 
            bool OnWindowClose();
 
            bool m_RenderImGui{ true };
 
            std::unique_ptr<Window> m_Window;
 
            Internal::ImGuiLayer* m_ImGuiLayer;
 
            LayerStack m_LayerStack;
 
            Threading::MainThreadQueue m_CommandQueue;
 
            Threading::ThreadPool m_WorkerPool;
 
            GameTimer m_GameTimer;
 
            bool m_Running{ true };
 
            static Application* s_Instance;
 
            glm::vec4 m_BackgroundColor{ 0.5f, 0.5f, 0.0f, 1.0f };
        };
 
        Application* CreateApplication();
    }
}