HlslShaderTextureResource.h

#pragma once
 
// Standard.
#include <string>
#include <memory>
#include <unordered_set>
#include <variant>
 
// Custom.
#include "shader/general/resources/ShaderResource.h"
#include "render/directx/descriptors/DirectXDescriptorHeap.h"
 
namespace ne {
    class Pipeline;
    class DirectXPso;
 
    class HlslShaderTextureResource : public ShaderTextureResource {
        // Only shader resource manager should be able to create such resources.
        friend class ShaderTextureResourceManager;
 
    public:
        virtual ~HlslShaderTextureResource() override = default;
 
        inline void setGraphicsRootDescriptorTableOfOnlyPipeline(
            const ComPtr<ID3D12GraphicsCommandList>& pCommandList) const {
            // we don't need to lock texture mutex here because when this function is called it's called
            // inside of the `draw` function and shader resource mutex (outside) is locked which means:
            // - if our old texture resource is being destroyed before the GPU resource is deleted
            // the rendering will be stopped and thus we won't be in the `draw` function
            // - although after the old texture is destroyed we can start the `draw` function
            // the renderer will still need to lock shader resources mutex (in material for example)
            // but when the texture is being changed (in material for example) the material locks
            // shader resources mutex which means that when we get in this function the texture will
            // always be valid and so its GPU virtual address too
 
            // only descriptor index (offset) may change due to heap re-creation (expand/shrink)
            // but before a heap is destroyed (to be re-created) all rendering is stopped so
            // that no new frames will be queued until all descriptor offsets are updated
 
#if defined(DEBUG)
            // Self check: make sure there is indeed just 1 pipeline.
            if (mtxRootParameterIndices.second.size() != 1) [[unlikely]] {
                Error error(std::format(
                    "shader resource \"{}\" was requested to set its graphics root descriptor "
                    "table of the only used pipeline but this shader resource references "
                    "{} pipeline(s)",
                    getResourceName(),
                    mtxRootParameterIndices.second.size()));
                error.showError();
                throw std::runtime_error(error.getFullErrorMessage());
            }
#endif
 
            // Set table.
            pCommandList->SetGraphicsRootDescriptorTable(
                mtxRootParameterIndices.second.begin()->second,
                D3D12_GPU_DESCRIPTOR_HANDLE{
                    pSrvHeap->getInternalHeap()->GetGPUDescriptorHandleForHeapStart().ptr +
                    pTextureSrv->getDescriptorOffsetInDescriptors() * iSrvDescriptorSize});
        }
 
        inline void setGraphicsRootDescriptorTableOfPipeline(
            const ComPtr<ID3D12GraphicsCommandList>& pCommandList, DirectXPso* pUsedPipeline) const {
            // same thing as above, we don't need to lock mutexes here
 
            // Find root parameter index of this pipeline.
            const auto it = mtxRootParameterIndices.second.find(pUsedPipeline);
 
#if defined(DEBUG)
            if (it == mtxRootParameterIndices.second.end()) [[unlikely]] {
                Error error(std::format(
                    "shader resource \"{}\" was requested to set its graphics root descriptor table "
                    "but this shader resource does not reference the specified pipeline",
                    getResourceName(),
                    mtxRootParameterIndices.second.size()));
                error.showError();
                throw std::runtime_error(error.getFullErrorMessage());
            }
#endif
 
            // Set table.
            pCommandList->SetGraphicsRootDescriptorTable(
                it->second,
                D3D12_GPU_DESCRIPTOR_HANDLE{
                    pSrvHeap->getInternalHeap()->GetGPUDescriptorHandleForHeapStart().ptr +
                    pTextureSrv->getDescriptorOffsetInDescriptors() * iSrvDescriptorSize});
        }
 
        [[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:
        HlslShaderTextureResource(
            const std::string& sResourceName,
            std::unique_ptr<TextureHandle> pTextureToUse,
            const std::unordered_map<DirectXPso*, UINT>& rootParameterIndices);
 
        [[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);
 
        std::pair<std::mutex, std::unique_ptr<TextureHandle>> mtxUsedTexture;
 
        DirectXDescriptor* pTextureSrv = nullptr;
 
        DirectXDescriptorHeap* pSrvHeap = nullptr;
 
        UINT iSrvDescriptorSize = 0;
 
        std::pair<std::recursive_mutex, std::unordered_map<DirectXPso*, UINT>> mtxRootParameterIndices;
    };
} // namespace ne