GlslShaderTextureResource.h

#pragma once
 
// Standard.
#include <string>
#include <memory>
#include <variant>
#include <unordered_set>
 
// Custom.
#include "shader/general/resources/ShaderResource.h"
#include "material/TextureManager.h"
#include "render/general/pipeline/PipelineShaderConstantsManager.hpp"
#include "shader/general/resources/ShaderArrayIndexManager.h"
 
// External.
#include "vulkan/vulkan.h"
 
namespace ne {
    class Pipeline;
    class VulkanPipeline;
 
    class GlslShaderTextureResource : public ShaderTextureResource {
        // Only shader resource manager should be able to create such resources.
        friend class ShaderTextureResourceManager;
 
        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 ~GlslShaderTextureResource() override = default;
 
        std::string getPathToTextureResource();
 
        inline void copyResourceIndexOfOnlyPipelineToPushConstants(
            PipelineShaderConstantsManager* pPushConstantsManager) {
            // Since pipelines won't change here (because we are inside of the `draw` function)
            // we don't need to lock the mutex here.
 
#if defined(DEBUG)
            // Self check: make sure there is indeed just 1 pipeline.
            if (mtxPushConstantIndices.second.size() != 1) [[unlikely]] {
                Error error(std::format(
                    "shader resource \"{}\" was requested to set its push constant "
                    "index of the only used pipeline but this shader resource references "
                    "{} pipeline(s)",
                    getResourceName(),
                    mtxPushConstantIndices.second.size()));
                error.showError();
                throw std::runtime_error(error.getFullErrorMessage());
            }
#endif
 
            // Save iterator to the first item.
            const auto it = mtxPushConstantIndices.second.begin();
 
            // Copy value to push constants.
            pPushConstantsManager->copyValueToShaderConstant(
                it->second.iPushConstantIndex, it->second.pShaderArrayIndex->getActualIndex());
        }
 
        inline void copyResourceIndexOfPipelineToPushConstants(
            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",
                    getResourceName(),
                    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:
        GlslShaderTextureResource(
            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<ShaderTextureResource>, 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,
            VkImageView pTextureView,
            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