Engine.h

Go to the documentation of this file.

#pragma once
 
#include "Engine/Audio/AudioEngine.h"
#include "Engine/Mesh/AssetManager.h"
#include "Engine/Physics/PhysicsEngine.h"
#include "Engine/World/WindField.h"
#include "Engine/World/SceneManager.h"
 
#include <Engine/Core/ApplicationContext.h>
#include <Engine/Input/XrInputHandler.h>
#include <Engine/Renderer/Renderer.h>
#include <vector>
#include <vulkan/vulkan_core.h>
#include <future>
#include <atomic>
#include <Engine/Renderer/NamedThreadPool.h>
#include "Engine/Logging/TracyVkContextManager.h"
 
namespace Input
{
    class InputManager;
    class XrRig;
}
 
namespace Engine {
 
    namespace Debug::UI
    {
        class ImGuiManager;
    }  // namespace Debug::UI
    class GameModule;
 
    namespace Rendering
    {
        class MirrorView;
    }
 
    class EngineKern {
    public:
        EngineKern() = default;
        ~EngineKern();

        void initRenderDoc();

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

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

        double getDeltaTimeSeconds();

        double getGlobalTimeSeconds();

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

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

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

        [[nodiscard]] Input::InputManager* getInputManager() const { return inputManager; }

        [[nodiscard]] Input::XrRig* getXrRig() const { return xrRig; }

        [[nodiscard]] Rendering::Headset * getHeadset() const { return headset; }
 
        [[nodiscard]] World::WindField& getWindField() { return windField_; }
        [[nodiscard]] const World::WindField& getWindField() const { return windField_; }
    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();
 
        Core::ApplicationContext * applicationContext = nullptr;
        Rendering::MirrorView * mirrorView = nullptr;
        Rendering::Headset * headset = nullptr;
        Rendering::Renderer * renderer = nullptr;
        Debug::UI::ImGuiManager * imguiManager_ = 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};
 
        // After a headset sleep/wake state transition, force several frames to
        // complete synchronously (endXrFrame on the main thread).  This prevents
        // the engine from rapid-firing frames that saturate the XR compositor
        // queue and cause xrEndFrame to block indefinitely while the main thread
        // deadlocks at frameCompletionFuture_.wait().
        int forceSyncFramesRemaining_ = 0;
 
        // 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() const;

        void initVulkan();

        void tryCreateApplicationContext();
 
#ifdef ENABLE_TRACY
        Debug::Tracy::TracyVkContextManager tracyContextManager_;
#endif
        
 
    public:
        void processMirrorWindowEvents();
 
        const std::unique_ptr<Core::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();
 
        void initStartupScene();
 
    public:
        template <typename T>
        void loadScene() {
            sceneManager->loadScene<T>();
        }

        [[nodiscard]] Core::PhysicsEngine * getPhysicsEngine() const { return physicsEngine; }

        [[nodiscard]] Core::AudioEngine* getAudioEngine() const { return audioEngine_; }
 
    private:
        std::unique_ptr<Core::SceneManager> sceneManager;
 
        void createAssetManager();
 
        void initAssets();

        void createPhysicsWorld();
        void destroyPhysicsWorld();
        Core::PhysicsEngine* physicsEngine = nullptr;

        void createAudioEngine();
        void destroyAudioEngine();
        Core::AudioEngine* audioEngine_ = nullptr;
 
        World::WindField windField_;
    };

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

        static EngineManager& getInstance();

        EngineKern* getEngineModule();

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