TextureAssetPipeline.h

#pragma once
#include <filesystem>
#include <future>
#include <vector>
 
#include "Engine/Ecs/EcsData.h"
 
class NamedThreadPool;
 
namespace Engine::Assets
{
    class TextureAssetManager;
}  // namespace Engine::Assets
 
namespace Engine
{
    class EngineKern;
}
 
namespace Engine::Core
{
    class AssetManager;
    class RenderingDataManager;
}
 
namespace Engine::Ecs
{
    class TextureAssetPipeline {
        friend class Core::AssetManager;
        friend class EngineKern;
 
    public:
        TextureAssetPipeline(
            Assets::TextureAssetManager * textureAssetManager, NamedThreadPool * assetLoaderPool );

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

        void tick(bool async = true);

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

        void setMaxTexturesPerFrame(size_t max) { maxTexturesPerFrame_ = max; }

        size_t getPendingCount() const {
            return assetQueue_.size() + exrHeaderFutures_.size() + imageFutures_.size() + ktx2LoadFutures_.size();
        }

        void discardPendingWork();
 
    private:
        void requestExrHeaders(bool async = true);
        void loadImageData(bool async = true);
        void retrieveImageData(bool async = true);
        void processKtx2Textures(bool async = true);
 
        Assets::TextureAssetManager * textureAssetManager_ = nullptr;
        Core::RenderingDataManager * renderingDataManager_ = nullptr;
        NamedThreadPool* assetLoaderPool_ = nullptr;
 
        std::vector<std::filesystem::path> assetQueue_;
        std::vector<std::filesystem::path> ktx2Queue_;
        std::vector<ExrHeaderFuture> exrHeaderFutures_;
        std::vector<AssetLoadingImage> imageFutures_;
        std::vector<Ktx2LoadFuture> ktx2LoadFutures_;
 
        size_t maxTexturesPerFrame_ = 16;  
    };
 
}  // namespace Engine::Ecs