Engine.h

Go to the documentation of this file.

#pragma once
 
#include "../Component/MeshComponent.h"
#include "Engine/Core/Window.h"
#include "Engine/Mesh/AssetManager.h"
#include "Engine/Physics/PhysicsEngine.h"
#include "Engine/World/SceneManager.h"
#include "Tick.h"
 
#include <Engine/Core/ApplicationContext.h>
#include <Engine/Input/XrInputHandler.h>
#include <Engine/Renderer/MirrorView.h>
#include <Engine/Renderer/Renderer.h>
#include <openxr/openxr.h>
#include <vector>
#include <vulkan/vulkan_core.h>
#include <future>
#include <atomic>
#include <Engine/Renderer/NamedThreadPool.h>
#ifdef ENABLE_TRACY
#include "tracy/TracyVulkan.hpp"
#endif
 
namespace EngineCore {
class Ticker;
class MeshLoader;
class GameModule;
class World;
class RenderProcess;
class MaterialShader;
class DataBuffer;
class PhysicsEngine;
}
 
namespace EngineCore {
    class Engine {
    public:
        Engine() = default;
        ~Engine();

        void initRenderDoc();

        void run(std::unique_ptr<GameModule> module);

        std::shared_ptr<InputHandler> getInputHandler();
 
        const std::unique_ptr<AssetManager>& getAssetManager() const;
 
    private:
        double gameTime = 0.0f;
    public:

        double getDeltaTimeSeconds();

        double getGlobalTimeSeconds();

        [[nodiscard]] ApplicationContext* getContext() const { return applicationContext; }
 
    private:
        double deltaTimeSeconds;
 
        std::unique_ptr<AssetManager> assetManager;
        std::shared_ptr<InputHandler> inputHandler;
 
        // Game reference
        std::unique_ptr<GameModule> module;
 
        // debug messenger for vulkan debug layer
        VkDebugUtilsMessengerEXT debugMessenger = nullptr;
 
        Input::XrInputHandler* xrInputHandler = nullptr;
        uint64_t frameCounter = 0;
        void createInputManager();
    public:
        [[nodiscard]] uint32_t getRenderableSceneObjectCount() const;

        [[nodiscard]] Renderer* getRenderer() const;

        [[nodiscard]] Input::XrInputHandler* getXrInputHandler() const { return xrInputHandler; }

        [[nodiscard]] Headset* getHeadset() const { return headset; }
    private:
 
        bool descriptorDataIsDirty = false;
 
        // command pool for all commands
        
        std::vector<VkCommandBuffer> commandBuffers;
 
        // frame time counter
        uint32_t currentFrame = 0;
 
        uint32_t textureCount = 0;
        uint32_t meshCount = 0;
 
        // virtual reality
        bool isXrSessionRunning = false;
 
        // function
        void initWindow();
 
        PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = nullptr;
        void createVulkanDebugMessenger();
 
        void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT &createInfo);
 
        static VkBool32 debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
                                      VkDebugUtilsMessageTypeFlagsEXT messageType,
                                      const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData, void *pUserData);
 
        bool checkValidationLayerSupport();
 
        ApplicationContext* applicationContext = nullptr;
        MirrorView* mirrorView = nullptr;
        Headset* headset = nullptr;
        Renderer* renderer = nullptr;
 
        // Async frame completion for pipelined rendering
        // This allows xrWaitFrame(N+1) to overlap with GPU work from frame N
        std::future<void> frameCompletionFuture_;
        std::atomic<bool> previousFrameXrComplete_{true};
 
        // Named thread pool for XR frame operations (shows up properly in Tracy)
        std::unique_ptr<NamedThreadPool> xrFrameThreadPool_;

        void completeFrameAsync(VkFence graphicsFence, bool presentMirror);

        void createStartupScene();

        void initVulkan();

        void tryCreateApplicationContext();
 
#ifdef ENABLE_TRACY
        std::vector<TracyVkCtx> tracyVulkanContext;
#endif
        
 
    public:
        void processMirrorWindowEvents();
 
        const std::unique_ptr<SceneManager>& getSceneManager() const { return sceneManager; }
    private:
 
        void calculateFrameTime( double& lastTime );
        void fixLoadingAssets() const;
        void processResourceLoadingPipelines();
        void update( double & gameTime );

        void captureRenderdocFrame();
        int  isMirrorViewMinimized();

        void mainLoop();

        void cleanup();
 
        void initializePlogDebugger();
 
        MeshComponent* rightHand = nullptr;
        MeshComponent* leftHand = nullptr;
        void initStartupScene();
 
    public:
        template <typename T>
        void loadScene() {
            sceneManager->loadScene<T>();
        }

        PhysicsEngine * getPhysicsEngine() const;
 
    private:
        std::unique_ptr<SceneManager> sceneManager;
 
        void createAssetManager();
 
        void initAssets();

        void createPhysicsWorld();
        void destroyPhysicsWorld();
        PhysicsEngine* physicsEngine = nullptr;
    };

    class EngineManager {
    public:
        virtual ~EngineManager() = default;

        static EngineManager& getInstance();

        EngineCore::Engine* getEngineModule();

        void setEngine(Engine* engineInstance);
 
    protected:
        EngineCore::Engine* engine = nullptr;
 
        EngineManager() = default;
        EngineManager(const EngineManager&) = delete;
        EngineManager& operator=(const EngineManager&) = delete;
    };
 
 
}