FrameProcessing.h

Go to the documentation of this file.

#pragma once
#include <filesystem>
#include <future>
 
#include "EcsData.h"
#include "Engine/Audio/AudioConfig.h"
#include "Engine/Audio/AudioAssetRef.h"
#include "Engine/Audio/AudioLoader.h"
#include "Engine/Material/MaterialAsset.h"
#include "Engine/Mesh/GltfLoader.h"
#include "Engine/Texture/ExrLoader.h"
 
namespace Engine::Assets
{
    class Audio;
    class AudioAssetManager;
    class AnimationAssetManager;
    class Model;
    class ModelAssetManager;
    class MeshAssetManager;
    class SkinAssetManager;
    class TextureAssetManager;
    class Texture;
}  // namespace Engine
 
namespace Engine
{
    class EngineKern;
}
 
namespace Engine::Core
{
    class AudioEngine;
    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;  
    };

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

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

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

        void setTextureAssetPipeline(TextureAssetPipeline* pipeline) { textureAssetPipeline_ = 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;  
        TextureAssetPipeline* textureAssetPipeline_ = nullptr;  
 
        NamedThreadPool * threadPool_ = new NamedThreadPool( 2, "Gltf loader" );
        Assets::Loaders::GltfLoader * loader_ = new Assets::Loaders::GltfLoader(threadPool_);
 
        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;
    };

    class AudioAssetPipeline {
        friend class AssetManager;
        friend class EngineKern;
 
    public:
        AudioAssetPipeline(
            Assets::AudioAssetManager * audioAssetManager,
                           NamedThreadPool* assetLoaderPool);

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

        void tick(bool async = true);

        void setAudioEngine( Core::AudioEngine * engine) { audioEngine_ = engine; }

        [[nodiscard]] size_t getPendingCount() const {
            return assetQueue_.size() + loadFutures_.size();
        }
 
        void discardPendingWork();
 
    private:
        void submitDecodeJobs();
        void retrieveDecodedAudio();
 
        struct AudioLoadFuture {
            std::filesystem::path path;
            Assets::AudioAssetRef ref;
            uint64_t generation = 0;
            std::future<Assets::AudioData> future;
        };
 
        Assets::AudioAssetManager * audioAssetManager_;
        Core::AudioEngine * audioEngine_ = nullptr;
        NamedThreadPool* assetLoaderPool_ = nullptr;
 
        std::vector<std::filesystem::path> assetQueue_;
        std::vector<AudioLoadFuture> loadFutures_;
 
        size_t maxLoadsPerFrame_ = Core::Audio::MAX_AUDIO_LOADS_PER_FRAME;
    };
 
}  // namespace Ecs