ShaderCpuWriteResourceManager.h

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