AudioAssetPipeline.h

#pragma once
#include <filesystem>
#include <future>
#include <vector>
 
#include "Engine/Audio/AudioConfig.h"
#include "Engine/Audio/AudioAssetRef.h"
#include "Engine/Audio/AudioLoader.h"
 
class NamedThreadPool;
 
namespace Engine::Assets
{
    class AudioAssetManager;
}  // namespace Engine::Assets
 
namespace Engine
{
    class EngineKern;
}
 
namespace Engine::Core
{
    class AudioEngine;
    class AssetManager;
}
 
namespace Engine::Ecs
{
    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 Engine::Ecs