HlslShaderTextureResourceBinding.h

#pragma once
 
// Standard.
#include <string>
#include <memory>
#include <unordered_set>
#include <variant>
#include <mutex>
 
// Custom.
#include "shader/general/resource/binding/ShaderResourceBinding.h"
#include "render/directx/descriptors/DirectXDescriptorHeap.h"
#include "render/general/pipeline/PipelineShaderConstantsManager.hpp"
#include "render/directx/resource/DirectXResource.h"
 
namespace ne {
    class TextureHandle;
    class Pipeline;
    class DirectXPso;
    class Renderer;
 
    class HlslShaderTextureResourceBinding : public ShaderTextureResourceBinding {
        // Only the manager should be able to create such resources.
        friend class ShaderTextureResourceBindingManager;
 
    public:
        virtual ~HlslShaderTextureResourceBinding() override = default;
 
        inline void copyResourceIndexToRootConstants(
            PipelineShaderConstantsManager* pShaderConstantsManager, DirectXPso* 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 shader constant offset.
            const auto it = mtxShaderConstantOffsetPerPipeline.second.find(pUsedPipeline);
            if (it == mtxShaderConstantOffsetPerPipeline.second.end()) [[unlikely]] {
                Error error(std::format(
                    "shader resource \"{}\" was requested to set its root constant "
                    "index but this shader resource does not reference the specified pipeline",
                    getShaderResourceName(),
                    mtxShaderConstantOffsetPerPipeline.second.size()));
                error.showError();
                throw std::runtime_error(error.getFullErrorMessage());
            }
            const auto& shaderConstantsOffsets = it->second;
 
            // Query texture's SRV descriptor offset in the descriptor range.
            unsigned int iRootConstantValue = 0;
            unsigned int iSamplerArrayOffset = 0; // also save offset into the array of texture samplers
            {
                std::scoped_lock textureGuard(mtxUsedTexture.first);
 
                iSamplerArrayOffset = mtxUsedTexture.second.iTextureSamplerOffset;
 
                const auto pDirectXTexture =
                    reinterpret_cast<DirectXResource*>(mtxUsedTexture.second.pTexture->getResource());
 
                // Get SRV.
                const auto pSrvDescriptor = pDirectXTexture->getDescriptor(DirectXDescriptorType::SRV);
                if (pSrvDescriptor == nullptr) [[unlikely]] {
                    Error error(std::format(
                        "shader resource \"{}\" was requested to set its root constant "
                        "index but used texture \"{}\" does not seem to have an SRV bound",
                        getShaderResourceName(),
                        pDirectXTexture->getResourceName()));
                    error.showError();
                    throw std::runtime_error(error.getFullErrorMessage());
                }
 
                // Calculate descriptor offset. This may not be as fast as we want but this is the price we
                // pay for having a simple approach. We could have cached the offset but we would need to keep
                // the cached offset updated after the range resizes which seems like a complicated thing.
                auto result = pSrvDescriptor->getOffsetFromRangeStartOnCurrentFrame();
                if (std::holds_alternative<Error>(result)) [[unlikely]] {
                    auto error = std::get<Error>(std::move(result));
                    error.addCurrentLocationToErrorStack();
                    error.showError();
                    throw std::runtime_error(error.getFullErrorMessage());
                }
 
                iRootConstantValue = std::get<unsigned int>(result);
            }
 
            // Copy descriptor range offset to root constants.
            pShaderConstantsManager->copyValueToShaderConstant(
                shaderConstantsOffsets.iTextureShaderConstantIndex, iRootConstantValue);
 
            // Also set offset into the sampler array.
            pShaderConstantsManager->copyValueToShaderConstant(
                shaderConstantsOffsets.iSamplerArrayOffsetConstantIndex, iSamplerArrayOffset);
        }
 
        [[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:
        struct ShaderConstantOffsets {
            size_t iTextureShaderConstantIndex = 0;
 
            size_t iSamplerArrayOffsetConstantIndex = 0;
        };
 
        struct TextureInfo {
            std::unique_ptr<TextureHandle> pTexture;
 
            unsigned int iTextureSamplerOffset = 0;
        };
 
        HlslShaderTextureResourceBinding(
            const std::string& sResourceName,
            TextureInfo textureInfo,
            std::unordered_map<DirectXPso*, ShaderConstantOffsets>&& shaderConstantOffsetPerPipeline,
            Renderer* pRenderer);
 
        [[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> pTexture);
 
        static std::variant<std::shared_ptr<ContinuousDirectXDescriptorRange>, Error>
        getSrvDescriptorRange(DirectXPso* pPipeline, const std::string& sShaderResourceName);
 
        static unsigned int getTextureSamplerOffset(DirectXResource* pTexture, Renderer* pRenderer);
 
        std::pair<std::mutex, TextureInfo> mtxUsedTexture;
 
        std::pair<std::recursive_mutex, std::unordered_map<DirectXPso*, ShaderConstantOffsets>>
            mtxShaderConstantOffsetPerPipeline;
 
        Renderer* const pRenderer = nullptr;
 
        static constexpr std::string_view sIndexIntoTextureSamplersArrayShaderConstantName =
            "iIndexIntoTextureSamplersArrayForDiffuse";
 
        static constexpr bool bBindSrvToCubemapFaces = false;
    };
} // namespace ne