ShaderCpuWriteResourceBindingManager.h

#pragma once
 
// Standard.
#include <set>
#include <memory>
#include <mutex>
#include <array>
#include <unordered_map>
#include <unordered_set>
 
// Custom.
#include "shader/general/resource/binding/cpuwrite/ShaderCpuWriteResourceBinding.h"
#include "shader/general/resource/binding/cpuwrite/ShaderCpuWriteResourceBindingUniquePtr.h"
#include "render/general/resource/frame/FrameResourceManager.h"
 
namespace ne {
    class Renderer;
    class Pipeline;
 
    class ShaderCpuWriteResourceBindingManager {
        // Only renderer should be allowed to create this manager.
        friend class Renderer;
 
        // Unique pointers will notify the manager before destruction.
        friend class ShaderCpuWriteResourceBindingUniquePtr;
 
    public:
        struct Resources {
            std::unordered_map<ShaderCpuWriteResourceBinding*, std::unique_ptr<ShaderCpuWriteResourceBinding>>
                all;
 
            std::array<
                std::unordered_set<ShaderCpuWriteResourceBinding*>,
                FrameResourceManager::getFrameResourceCount()>
                vToBeUpdated;
        };
 
        ShaderCpuWriteResourceBindingManager() = delete;
 
        ShaderCpuWriteResourceBindingManager(const ShaderCpuWriteResourceBindingManager&) = delete;
        ShaderCpuWriteResourceBindingManager& operator=(const ShaderCpuWriteResourceBindingManager&) = delete;
 
        ~ShaderCpuWriteResourceBindingManager();
 
        std::variant<ShaderCpuWriteResourceBindingUniquePtr, Error> createShaderCpuWriteResource(
            const std::string& sShaderResourceName,
            const std::string& sResourceAdditionalInfo,
            size_t iResourceDataSizeInBytes,
            const std::unordered_set<Pipeline*>& pipelinesToUse,
            const std::function<void*()>& onStartedUpdatingResource,
            const std::function<void()>& onFinishedUpdatingResource);
 
        void updateResources(size_t iCurrentFrameResourceIndex);
 
        void markResourceAsNeedsUpdate(ShaderCpuWriteResourceBinding* pResourceToDestroy);
 
        std::pair<std::recursive_mutex, Resources>* getResources();
 
    private:
        ShaderCpuWriteResourceBindingManager(Renderer* pRenderer);
 
        std::variant<ShaderCpuWriteResourceBindingUniquePtr, Error>
        handleResourceCreation(std::variant<std::unique_ptr<ShaderCpuWriteResourceBinding>, Error> result);
 
        void destroyResource(ShaderCpuWriteResourceBinding* pResourceToDestroy);
 
        Renderer* pRenderer = nullptr;
 
        std::pair<std::recursive_mutex, Resources> mtxShaderCpuWriteResources;
    };
} // namespace ne