Engine.h

#pragma once
 
#include "Engine/Asset/AssetHandles.h"
#include "Engine/Audio/AudioEngine.h"
#include "Engine/Files/AssetPath.h"
#include "Engine/Material/RuntimeMaterialLease.h"
#include "Engine/Mesh/AssetManager.h"
#include "Engine/Core/TimerManager.h"
#include "Engine/Entity/EntityContainer.h"
#include "Engine/Physics/CollisionProfileRegistry.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 <vector>
#include <vulkan/vulkan_core.h>
#include <future>
#include <memory>
#include <atomic>
 
#include "Engine/Debug/Debugger.h"
#include "Engine/Input/InputManager.h"
#include "Engine/Logging/TracyVkContextManager.h"
 
class NamedThreadPool;
 
namespace Input
{
    class InputManager;
    class XrRig;
}
 
namespace Engine {
 
    namespace Debug::UI
    {
        class ImGuiManager;
    }  // namespace Debug::UI
    class GameModule;
 
    namespace Core
    {
        class AssetRegistry;
        class TimerManager;
    }
 
    namespace Assets
    {
        class Material;
    }
 
    namespace Rendering
    {
        class Headset;
        class MirrorView;
        class Renderer;
    }

    class EngineKern {
    public:
        EngineKern();

        ~EngineKern();

        void loadEngineConfig();

        void run(GameModule& module);

        [[nodiscard]] Assets::RuntimeMaterialLease registerRuntimeMaterial(
            Asset::MeshPath materialPath,
            std::unique_ptr<Assets::Material> material
        );

        void unregisterRuntimeMaterial( Assets::MaterialHandle handle );

        void setFreezeCulling(bool freeze) const;

        [[nodiscard]] bool isFreezeCulling() const;
 
    private:
        Debugger debugger_;
        double gameTime_ = 0.0f;
    public:

        [[nodiscard]] double getDeltaTimeSeconds() const;

        [[nodiscard]] double getGlobalTimeSeconds() const;

        [[nodiscard]] Core::ApplicationContext * getContext() const { return applicationContext_.get(); }
 
    private:
        double deltaTimeSeconds_ = 0.0;

        int64_t lastPredictedDisplayTime_ = 0;
 
        std::unique_ptr<Core::AssetManager> assetManager_ = nullptr;
        std::unique_ptr<Core::AssetRegistry> assetRegistry_ = nullptr;
 
        // Game reference. Owned by the caller; the engine only borrows its address.
        GameModule* module_ = nullptr;
 
        std::unique_ptr<Input::InputManager> inputManager_;
        uint64_t frameCounter_ = 0;

        void createInputManager();

        void createTimerManager();
    public:
        [[nodiscard]] uint32_t getRenderableSceneObjectCount() const;

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

        [[nodiscard]] Input::XrInputHandler& getXrInputHandler() const { return inputManager_->getXrInputHandler(); }

        [[nodiscard]] Input::InputManager* getInputManager() const { return inputManager_.get(); }

        [[nodiscard]] Input::XrRig& getXrRig() const { return inputManager_->getXrRig(); }

        [[nodiscard]] Core::TimerManager * getTimerManager() const { return timerManager_.get(); }

        [[nodiscard]] Rendering::Headset * getHeadset() const { return headset_.get(); }

        [[nodiscard]] World::WindField& getWindField() { return windField_; }

        [[nodiscard]] const World::WindField& getWindField() const { return windField_; }

        [[nodiscard]] Entities::EntityContainer& getPersistentEntities() { return persistentEntities_; }

        [[nodiscard]] const Entities::EntityContainer& getPersistentEntities() const { return persistentEntities_; }
    private:
 
        void createVulkanDebugMessenger();
 
        std::unique_ptr<Core::ApplicationContext> applicationContext_;
        std::unique_ptr<Rendering::MirrorView> mirrorView_;
        std::unique_ptr<Rendering::Headset> headset_;
        std::unique_ptr<Rendering::Renderer> renderer_;
        std::unique_ptr<Debug::UI::ImGuiManager> imguiManager_;
 
        // 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_;
 
        std::unique_ptr<Core::TimerManager> timerManager_;

        void completeFrameAsync(VkFence graphicsFence, bool presentMirror);

        void createStartupScene() const;

        void initVulkan();

        void tryCreateApplicationContext();
 
#ifdef ENABLE_TRACY
        Debug::Tracy::TracyVkContextManager tracyContextManager_;
#endif
        
        static void processMirrorWindowEvents();
 
    public:

        [[nodiscard]] const std::unique_ptr<Core::SceneManager>& getSceneManager() const { return sceneManager_; }
    private:

        void calculateFrameTime( double& lastFrameTimeMilliseconds );

        void fixLoadingAssets() const;

        void processResourceLoadingPipelines();

        void update( double & gameTime );

        static void physicsFrameUpdate();

        void updateAudioListener();

        void captureRenderdocFrame();

        [[nodiscard]] bool isMirrorViewMinimized() const;

        void mainLoop();

        void cleanup();
 
        void initStartupScene();
 
    public:
        template <typename T>
        void loadScene() {
            sceneManager_->loadScene<T>();
        }

        [[nodiscard]] Physics::CollisionProfileRegistry * getCollisionProfileRegistry() const { return collisionProfileRegistry_.get(); }
 
    private:
        std::unique_ptr<Core::SceneManager> sceneManager_ = nullptr;
 
        void createAssetManager();

        void createPhysicsWorld();
        void destroyPhysicsWorld();
        std::unique_ptr<Core::PhysicsEngine> physicsEngine_ = nullptr;
        std::unique_ptr<Physics::CollisionProfileRegistry> collisionProfileRegistry_ = nullptr;

        void createAudioEngine();
        void destroyAudioEngine();
        std::unique_ptr<Core::AudioEngine> audioEngine_ = nullptr;
 
        World::WindField windField_;
        Entities::EntityContainer persistentEntities_;
    };

    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; 
    };
 
 
}