FrameProcessing.h

Go to the documentation of this file.

#pragma once
#include <filesystem>
#include <future>
 
#include "EcsData.h"
#include "Engine/Material/MaterialAsset.h"
#include "Engine/Mesh/GltfLoader.h"
#include "Engine/Texture/ExrLoader.h"
 
namespace EngineCore {
    class ModelAsset;
    class ModelAssetManager;
    class GltfLoader;
    class RenderingDataManager;
}
 
namespace EngineCore {
    class MeshAssetManager;
    class TextureAssetManager;
}
 
namespace EngineCore {
    class Engine;
    class AssetManager;
}
 
class NamedThreadPool;
 
namespace Ecs
{
    class TextureAssetPipeline {
        friend class EngineCore::AssetManager;
        friend class EngineCore::Engine;
 
    public:
        TextureAssetPipeline(EngineCore::TextureAssetManager* textureAssetManager,
                             NamedThreadPool* assetLoaderPool);

        void submitAsset(const std::filesystem::path &asset);

        void tick(bool async = true);

        void setRenderingDataManager(EngineCore::RenderingDataManager* rdm) { renderingDataManager = rdm; }
 
    private:
        void requestExrHeaders(bool async = true);
        void loadImageData(bool async = true);
        void retrieveImageData(bool async = true);
 
        EngineCore::TextureAssetManager* textureAssetManager;
        EngineCore::RenderingDataManager* renderingDataManager = nullptr;
        NamedThreadPool* assetLoaderPool = nullptr;
 
        std::vector<std::filesystem::path> assetQueue;
        std::vector<Ecs::ExrHeaderFuture> headerFutures;
        std::vector<Ecs::AssetLoadingImage> imageFutures;
    };

    class ModelAssetPipeline {
        friend class EngineCore::AssetManager;
        friend class EngineCore::Engine;
 
    public:
        explicit ModelAssetPipeline(EngineCore::MeshAssetManager *meshAssetManager,
                           EngineCore::MaterialAssetManager *materialAssetManager,
                           EngineCore::ModelAssetManager *modelAssetManager,
                           EngineCore::TextureAssetManager *textureAssetManager,
                           NamedThreadPool* assetLoaderPool,
                           EngineCore::AssetManager* assetManager = nullptr);

        void submitAsset(const std::filesystem::path &asset);
 
        void tick(bool async = true);

        void setRenderingDataManager(EngineCore::RenderingDataManager* rdm) { renderingDataManager = rdm; }

        std::vector<Ecs::CompletedMeshletGeneration> takePendingMeshletCompletions();
 
    private:
        void submitLoadModel(bool async = true);
        void processModel(bool async = true);
        void processMaterial(bool async = true);
        void processMeshData(bool async = true);

        void processTextures(EngineCore::ModelAsset* modelAsset, const std::filesystem::path& modelPath);
 
        EngineCore::MeshAssetManager* meshAssetManager;
        EngineCore::MaterialAssetManager* materialAssetManager;
        EngineCore::ModelAssetManager* modelAssetManager;
        EngineCore::TextureAssetManager* textureAssetManager;
        EngineCore::RenderingDataManager* renderingDataManager = nullptr;
        EngineCore::AssetManager* assetManager_ = nullptr;  
 
        NamedThreadPool * threadPool                    = new NamedThreadPool( 4, "Gltf loader" );
 
        EngineCore::GltfLoader* loader = new EngineCore::GltfLoader(threadPool);
 
        std::vector<std::filesystem::path> assetQueue;
        std::vector<Ecs::GltfModelFuture> modelLoadingFutures;
        std::vector<std::future<Ecs::MaterialLoadingData>> materialFutures;
        std::vector<std::future<Ecs::PrimitiveDataLoading>> primitiveDataFutures;
        std::vector<std::future<Ecs::CompletedMeshletGeneration>> meshletGenerationFutures;
 
        // Queue for completed meshlet generations waiting to be written to registry
        std::vector<Ecs::CompletedMeshletGeneration> pendingMeshletCompletions_;
 
        NamedThreadPool* assetLoaderPool = nullptr;
    };
}  // namespace Ecs