ShaderCpuWriteResourceBinding.h

#pragma once
 
// Standard.
#include <unordered_map>
#include <optional>
#include <variant>
#include <string>
#include <functional>
 
// Custom.
#include "render/general/resource/frame/FrameResourceManager.h"
#include "shader/general/resource/cpuwrite/DynamicCpuWriteShaderResourceArray.h"
#include "render/general/pipeline/PipelineShaderConstantsManager.hpp"
#include "shader/general/resource/binding/ShaderResourceBinding.h"
#include "misc/Error.h"
 
namespace ne {
    class Renderer;
    class Pipeline;
 
    class ShaderCpuWriteResourceBinding : public ShaderResourceBindingBase {
        // Only manager should be able to create this resource and update data of this resource.
        friend class ShaderCpuWriteResourceBindingManager;
 
    public:
        virtual ~ShaderCpuWriteResourceBinding() override = default;
 
        inline void copyResourceIndexToShaderConstants(
            PipelineShaderConstantsManager* pShaderConstantsManager,
            Pipeline* pUsedPipeline,
            size_t iCurrentFrameResourceIndex) {
            // Since pipelines won't change here (because we are inside of the `draw` function)
            // we don't need to lock the mutex here.
 
            // Find push constant index of this pipeline.
            const auto offsetIt = mtxUintShaderConstantOffsets.second.find(pUsedPipeline);
 
#if defined(DEBUG)
            if (offsetIt == mtxUintShaderConstantOffsets.second.end()) [[unlikely]] {
                Error error(std::format(
                    "shader resource \"{}\" was requested to set its push constant "
                    "index but this shader resource does not reference the specified pipeline",
                    getShaderResourceName(),
                    mtxUintShaderConstantOffsets.second.size()));
                error.showError();
                throw std::runtime_error(error.getFullErrorMessage());
            }
#endif
 
            // Copy value to root/push constants.
            pShaderConstantsManager->copyValueToShaderConstant(
                offsetIt->second, vResourceData[iCurrentFrameResourceIndex]->getIndexIntoArray());
        }
 
        inline size_t getResourceDataSizeInBytes() const { return iResourceDataSizeInBytes; }
 
        [[nodiscard]] virtual std::optional<Error>
        changeUsedPipelines(const std::unordered_set<Pipeline*>& pipelinesToUse) override;
 
    protected:
        static std::variant<std::unique_ptr<ShaderCpuWriteResourceBinding>, Error> create(
            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);
 
        static std::variant<std::unordered_map<Pipeline*, size_t>, Error>
        getUintShaderConstantOffsetsFromPipelines(
            const std::unordered_set<Pipeline*>& pipelines, const std::string& sFieldName);
 
        ShaderCpuWriteResourceBinding(
            const std::string& sShaderResourceName,
            size_t iResourceDataSizeInBytes,
            const std::function<void*()>& onStartedUpdatingResource,
            const std::function<void()>& onFinishedUpdatingResource,
            const std::unordered_map<Pipeline*, size_t>& uintShaderConstantOffsets);
 
        [[nodiscard]] virtual std::optional<Error> onAfterAllPipelinesRefreshedResources() override;
 
        std::pair<std::recursive_mutex, std::unordered_map<Pipeline*, size_t>> mtxUintShaderConstantOffsets;
 
        std::array<
            std::unique_ptr<DynamicCpuWriteShaderResourceArraySlot>,
            FrameResourceManager::getFrameResourceCount()>
            vResourceData;
 
    private:
        inline void updateResource(size_t iCurrentFrameResourceIndex) {
            void* pDataToCopy = onStartedUpdatingResource();
 
            vResourceData[iCurrentFrameResourceIndex]->updateDataBecauseGpuUnused(pDataToCopy);
 
            onFinishedUpdatingResource();
        }
 
        const std::function<void*()> onStartedUpdatingResource;
 
        const std::function<void()> onFinishedUpdatingResource;
 
        const size_t iResourceDataSizeInBytes = 0;
    };
}