ModelAssetPipeline.h

#pragma once
#include <filesystem>
#include <future>
#include <memory>
#include <vector>
 
#include "Engine/Ecs/EcsData.h"
 
class NamedThreadPool;
 
namespace Engine::Assets
{
    class AnimationAssetManager;
    class MaterialAssetManager;
    class MeshAssetManager;
    class Model;
    class ModelAssetManager;
    class SkinAssetManager;
    class TextureAssetManager;
}  // namespace Engine::Assets
 
namespace Engine::Core
{
    class AssetManager;
    class RenderingDataManager;
}
 
namespace Engine::Assets::Loaders
{
    class GltfLoader;
}
 
namespace Engine::Ecs
{
    class AssetImportPipeline;

    class ModelAssetPipeline {
        friend class AssetManager;
        friend class Engine;
 
    public:
        explicit ModelAssetPipeline(
            Assets::MeshAssetManager *     meshAssetManager,
            Assets::MaterialAssetManager * materialAssetManager,
            Assets::ModelAssetManager *    modelAssetManager,
            Assets::SkinAssetManager *     skinAssetManager,
            Assets::AnimationAssetManager * animationAssetManager,
            Assets::TextureAssetManager *  textureAssetManager,
            NamedThreadPool *      assetLoaderPool,
            Core::AssetManager *         assetManager = nullptr
        );

        ~ModelAssetPipeline();

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

        void tick(bool async = true);

        void setRenderingDataManager( Core::RenderingDataManager * renderingDataManager) { renderingDataManager_ = renderingDataManager; }

        void setAssetImportPipeline(AssetImportPipeline* pipeline) { assetImportPipeline_ = pipeline; }

        std::vector<CompletedMeshletGeneration> takePendingMeshletCompletions();

        [[nodiscard]] bool hasPendingWork() const {
            return
                !assetQueue_.empty() ||
                !modelLoadingFutures_.empty() ||
                !materialResults_.empty() ||
                !primitiveDataFutures_.empty() ||
                !meshletGenerationFutures_.empty() ||
                !pendingMeshletCompletions_.empty() ||
                !pendingKtx2Futures_.empty();
        }

        void discardPendingWork();
 
    private:
        void submitLoadModel(bool async = true);
        void processModel(bool async = true);
        void processSkinData(bool async = true);
        void processMaterial(bool async = true);
        void processMeshData(bool async = true);
        void processKtx2Textures(bool async = true);

        void processTextures(Assets::Model* modelAsset,
                             const std::shared_ptr<tinygltf::Model>& gltfModel,
                             const std::filesystem::path& modelPath);
 
        Assets::MeshAssetManager * meshAssetManager_ = nullptr;
        Assets::MaterialAssetManager * materialAssetManager_ = nullptr;
        Assets::ModelAssetManager * modelAssetManager_ = nullptr;
        Assets::SkinAssetManager * skinAssetManager_ = nullptr;
        Assets::AnimationAssetManager * animationAssetManager_ = nullptr;
        Assets::TextureAssetManager * textureAssetManager_ = nullptr;
        Core::RenderingDataManager * renderingDataManager_ = nullptr;
        Core::AssetManager* assetManager_ = nullptr;  
        AssetImportPipeline* assetImportPipeline_ = nullptr;  
 
        NamedThreadPool * threadPool_ = nullptr;
        Assets::Loaders::GltfLoader * loader_ = nullptr;
 
        std::vector<std::filesystem::path> assetQueue_;
        std::vector<GltfModelFuture> modelLoadingFutures_;
        std::vector<MaterialLoadingData> materialResults_;
        std::vector<std::future<PrimitiveDataLoading>> primitiveDataFutures_;
        std::vector<std::future<CompletedMeshletGeneration>> meshletGenerationFutures_;
 
        // Queue for completed meshlet generations waiting to be written to registry
        std::vector<CompletedMeshletGeneration> pendingMeshletCompletions_;
 
        // KTX2 texture loads submitted to thread pool, polled each tick()
        std::vector<Ktx2LoadFuture> pendingKtx2Futures_;
 
        NamedThreadPool* assetLoaderPool_ = nullptr;
    };
 
}  // namespace Engine::Ecs