GlslShaderTextureResourceBinding.h

#pragma once
 
// Standard.
#include <string>
#include <memory>
#include <variant>
#include <unordered_set>
 
// Custom.
#include "shader/general/resource/binding/ShaderResourceBinding.h"
#include "render/general/pipeline/PipelineShaderConstantsManager.hpp"
#include "shader/general/resource/ShaderArrayIndexManager.h"
 
// External.
#include "vulkan/vulkan.h"
 
namespace ne {
    class TextureHandle;
    class Pipeline;
    class VulkanPipeline;
    class VulkanResource;
 
    class GlslShaderTextureResourceBinding : public ShaderTextureResourceBinding {
        // Only the manager should be able to create such resources.
        friend class ShaderTextureResourceBindingManager;
 
        struct PushConstantIndices {
            PushConstantIndices() = default;
 
            PushConstantIndices(
                size_t iPushConstantIndex, std::unique_ptr<ShaderArrayIndex> pShaderArrayIndex) {
                this->iPushConstantIndex = iPushConstantIndex;
                this->pShaderArrayIndex = std::move(pShaderArrayIndex);
            }
 
            PushConstantIndices(PushConstantIndices&&) = default;
 
            PushConstantIndices& operator=(PushConstantIndices&&) = default;
 
            size_t iPushConstantIndex = 0;
 
            std::unique_ptr<ShaderArrayIndex> pShaderArrayIndex;
        };
 
    public:
        virtual ~GlslShaderTextureResourceBinding() override = default;
 
        std::string getPathToTextureResource();
 
        inline void copyResourceIndexToPushConstants(
            PipelineShaderConstantsManager* pPushConstantsManager, VulkanPipeline* pUsedPipeline) {
            // 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 it = mtxPushConstantIndices.second.find(pUsedPipeline);
            if (it == mtxPushConstantIndices.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(),
                    mtxPushConstantIndices.second.size()));
                error.showError();
                throw std::runtime_error(error.getFullErrorMessage());
            }
 
            // Copy value to push constants.
            pPushConstantsManager->copyValueToShaderConstant(
                it->second.iPushConstantIndex, it->second.pShaderArrayIndex->getActualIndex());
        }
 
        [[nodiscard]] virtual std::optional<Error>
        useNewTexture(std::unique_ptr<TextureHandle> pTextureToUse) override;
 
        [[nodiscard]] virtual std::optional<Error>
        changeUsedPipelines(const std::unordered_set<Pipeline*>& pipelinesToUse) override;
 
    protected:
        GlslShaderTextureResourceBinding(
            const std::string& sResourceName,
            std::unique_ptr<TextureHandle> pTextureToUse,
            std::unordered_map<VulkanPipeline*, PushConstantIndices> pushConstantIndices);
 
        [[nodiscard]] virtual std::optional<Error> onAfterAllPipelinesRefreshedResources() override;
 
    private:
        static std::variant<std::unique_ptr<ShaderTextureResourceBinding>, Error> create(
            const std::string& sShaderResourceName,
            const std::unordered_set<Pipeline*>& pipelinesToUse,
            std::unique_ptr<TextureHandle> pTextureToUse);
 
        static std::variant<std::unique_ptr<ShaderArrayIndex>, Error> getTextureIndexInShaderArray(
            const std::string& sShaderResourceName, VulkanPipeline* pPipelineToLookIn);
 
        static std::optional<Error> bindTextureToShaderDescriptorArray(
            const std::string& sShaderResourceName,
            VulkanPipeline* pPipelineWithDescriptors,
            VulkanResource* pTexture,
            unsigned int iIndexIntoShaderArray);
 
        std::pair<std::mutex, std::unique_ptr<TextureHandle>> mtxUsedTexture;
 
        std::pair<std::recursive_mutex, std::unordered_map<VulkanPipeline*, PushConstantIndices>>
            mtxPushConstantIndices;
    };
} // namespace ne