D3D12RootSignatureDefinitions.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "D3D12RHI.h"
#include "D3D12RayTracingResources.h"
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/StringBuilder.h"
#include "RayTracingBuiltInResources.h"
#include "RHIDefinitions.h"
#include "RHIShaderBindingLayout.h"
 
#if !defined(D3D12_MAJOR_VERSION)
    #include "D3D12ThirdParty.h"
#endif
 
namespace D3D12ShaderUtils
{
    namespace StaticRootSignatureConstants
    {
        // Assume descriptors are volatile because we don't initialize all the descriptors in a table, just the ones used by the current shaders.
        constexpr D3D12_DESCRIPTOR_RANGE_FLAGS SRVDescriptorRangeFlags = D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE | D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE;
        constexpr D3D12_DESCRIPTOR_RANGE_FLAGS CBVDescriptorRangeFlags = D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE | D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE;
        constexpr D3D12_DESCRIPTOR_RANGE_FLAGS UAVDescriptorRangeFlags = D3D12_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE | D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE;
        constexpr D3D12_DESCRIPTOR_RANGE_FLAGS SamplerDescriptorRangeFlags = D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE;
 
        // We always set the data in an upload heap before calling Set*RootConstantBufferView.
        constexpr D3D12_ROOT_DESCRIPTOR_FLAGS CBVRootDescriptorFlags = D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC;
    }
 
    enum class ERootSignatureRangeType
    {
        CBV,
        SRV,
        UAV,
        Sampler,
    };
 
    enum class ERootSignatureVisibility
    {
        Vertex,
        Pixel,
        Geometry,
        Mesh,
        Amplification,
        All
    };
 
    inline D3D12_DESCRIPTOR_RANGE_TYPE GetD3D12DescriptorRangeType(ERootSignatureRangeType Type)
    {
        switch (Type)
        {
        case ERootSignatureRangeType::SRV:
            return D3D12_DESCRIPTOR_RANGE_TYPE_SRV;
        case ERootSignatureRangeType::UAV:
            return D3D12_DESCRIPTOR_RANGE_TYPE_UAV;
        case ERootSignatureRangeType::Sampler:
            return D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER;
        default:
            return D3D12_DESCRIPTOR_RANGE_TYPE_CBV;
        }
    }
 
    inline D3D12_DESCRIPTOR_RANGE_FLAGS GetD3D12DescriptorRangeFlags(ERootSignatureRangeType Type)
    {
        switch (Type)
        {
        case ERootSignatureRangeType::SRV:
            return D3D12ShaderUtils::StaticRootSignatureConstants::SRVDescriptorRangeFlags;
        case ERootSignatureRangeType::CBV:
            return D3D12ShaderUtils::StaticRootSignatureConstants::CBVDescriptorRangeFlags;
        case ERootSignatureRangeType::UAV:
            return D3D12ShaderUtils::StaticRootSignatureConstants::UAVDescriptorRangeFlags;
        case ERootSignatureRangeType::Sampler:
            return D3D12ShaderUtils::StaticRootSignatureConstants::SamplerDescriptorRangeFlags;
        default:
            return D3D12_DESCRIPTOR_RANGE_FLAG_NONE;
        }
    }
 
    inline D3D12_SHADER_VISIBILITY GetD3D12ShaderVisibility(ERootSignatureVisibility Visibility)
    {
        switch (Visibility)
        {
        case ERootSignatureVisibility::Vertex:
            return D3D12_SHADER_VISIBILITY_VERTEX;
        case ERootSignatureVisibility::Pixel:
            return D3D12_SHADER_VISIBILITY_PIXEL;
        case ERootSignatureVisibility::Geometry:
            return D3D12_SHADER_VISIBILITY_GEOMETRY;
#if !defined(D3D12RHI_TOOLS_MESH_SHADERS_UNSUPPORTED)
        case ERootSignatureVisibility::Mesh:
            return D3D12_SHADER_VISIBILITY_MESH;
        case ERootSignatureVisibility::Amplification:
            return D3D12_SHADER_VISIBILITY_AMPLIFICATION;
#endif
        default:
            return D3D12_SHADER_VISIBILITY_ALL;
        }
    }
 
    inline const TCHAR* GetVisibilityFlag(ERootSignatureVisibility Visibility)
    {
        switch (Visibility)
        {
        case ERootSignatureVisibility::Vertex:
            return TEXT("SHADER_VISIBILITY_VERTEX");
        case ERootSignatureVisibility::Geometry:
            return TEXT("SHADER_VISIBILITY_GEOMETRY");
        case ERootSignatureVisibility::Pixel:
            return TEXT("SHADER_VISIBILITY_PIXEL");
#if !defined(D3D12RHI_TOOLS_MESH_SHADERS_UNSUPPORTED)
        case ERootSignatureVisibility::Mesh:
            return TEXT("SHADER_VISIBILITY_MESH");
        case ERootSignatureVisibility::Amplification:
            return TEXT("SHADER_VISIBILITY_AMPLIFICATION");
#endif
        default:
            return TEXT("SHADER_VISIBILITY_ALL");
        }
    };
 
    inline const TCHAR* GetTypePrefix(ERootSignatureRangeType Type)
    {
        switch (Type)
        {
        case ERootSignatureRangeType::SRV:
            return TEXT("SRV(t");
        case ERootSignatureRangeType::UAV:
            return TEXT("UAV(u");
        case ERootSignatureRangeType::Sampler:
            return TEXT("Sampler(s");
        default:
            return TEXT("CBV(b");
        }
    }
 
    inline const TCHAR* GetFlagName(D3D12_ROOT_SIGNATURE_FLAGS Flag)
    {
        switch (Flag)
        {
        case D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT:
            return TEXT("ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT");
        case D3D12_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS:
            return TEXT("DENY_VERTEX_SHADER_ROOT_ACCESS");
        case D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS:
            return TEXT("DENY_GEOMETRY_SHADER_ROOT_ACCESS");
        case D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS:
            return TEXT("DENY_PIXEL_SHADER_ROOT_ACCESS");
        case D3D12_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT:
            return TEXT("ALLOW_STREAM_OUTPUT");
 
#if !defined(D3D12RHI_TOOLS_MESH_SHADERS_UNSUPPORTED)
        case D3D12_ROOT_SIGNATURE_FLAG_DENY_AMPLIFICATION_SHADER_ROOT_ACCESS:
            return TEXT("DENY_AMPLIFICATION_SHADER_ROOT_ACCESS");
        case D3D12_ROOT_SIGNATURE_FLAG_DENY_MESH_SHADER_ROOT_ACCESS:
            return TEXT("DENY_MESH_SHADER_ROOT_ACCESS");
#endif
 
        case D3D12_ROOT_SIGNATURE_FLAG_CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED:
            return TEXT("CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED");
        case D3D12_ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED:
            return TEXT("SAMPLER_HEAP_DIRECTLY_INDEXED");
 
        default:
            break;
        }
 
        return TEXT("");
    };
 
    // Simple base class to help write out a root signature (subclass to generate either to a binary struct or a #define)
    struct FRootSignatureCreator
    {
        EShaderBindingLayoutFlags Flags = EShaderBindingLayoutFlags::None;
        uint32 RegisterSpace = 0;
 
        virtual ~FRootSignatureCreator() = default;
 
        virtual void AddRootFlag(D3D12_ROOT_SIGNATURE_FLAGS Flag) = 0;
        virtual void AddConstantBufferViewParameter(uint32 Register, uint32 Space, ERootSignatureVisibility Visibility = ERootSignatureVisibility::All) = 0;
        virtual void AddShaderResourceViewParameter(uint32 Register, uint32 Space, ERootSignatureVisibility Visibility = ERootSignatureVisibility::All) = 0;
        virtual void AddUnorderedAccessViewParameter(uint32 Register, uint32 Space, ERootSignatureVisibility Visibility = ERootSignatureVisibility::All) = 0;
        virtual void AddTable(ERootSignatureVisibility Visibility, ERootSignatureRangeType Type, int32 NumDescriptors, D3D12_DESCRIPTOR_RANGE_FLAGS FlagsOverride = D3D12_DESCRIPTOR_RANGE_FLAG_NONE) = 0;
        virtual void AddConstantsParameter(uint32 Num32BitValues, uint32 Register, uint32 Space) = 0;
 
        void SetFlags(EShaderBindingLayoutFlags InFlags)
        {
            Flags = InFlags;
 
            if (EnumHasAnyFlags(InFlags, EShaderBindingLayoutFlags::InputAssembler))
            {
                AddRootFlag(D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
            }
 
            if (EnumHasAnyFlags(InFlags, EShaderBindingLayoutFlags::BindlessResources))
            {
                AddRootFlag(D3D12_ROOT_SIGNATURE_FLAG_CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED);
            }
 
            if (EnumHasAnyFlags(InFlags, EShaderBindingLayoutFlags::BindlessSamplers))
            {
                AddRootFlag(D3D12_ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED);
            }
        }
 
        bool HasFlags(EShaderBindingLayoutFlags InFlags) const
        {
            return EnumHasAllFlags(Flags, InFlags);
        }
 
        void SetRegisterSpace(uint32 InSpace)
        {
            RegisterSpace = InSpace;
        }
 
        uint32 GetRegisterSpace() const
        {
            return RegisterSpace;
        }
 
        inline bool ShouldSkipType(ERootSignatureRangeType Type) const
        {
            if (Type == ERootSignatureRangeType::SRV || Type == ERootSignatureRangeType::UAV)
            {
                return EnumHasAnyFlags(Flags, EShaderBindingLayoutFlags::BindlessResources);
            }
 
            if (Type == ERootSignatureRangeType::Sampler)
            {
                return EnumHasAnyFlags(Flags, EShaderBindingLayoutFlags::BindlessSamplers);
            }
 
            return false;
        }
    };
 
    struct FBinaryRootSignatureCreator final : public FRootSignatureCreator
    {
        D3D12_ROOT_SIGNATURE_FLAGS RootFlags = D3D12_ROOT_SIGNATURE_FLAG_NONE;
        TArray<CD3DX12_DESCRIPTOR_RANGE1> DescriptorRanges;
        TArray<CD3DX12_ROOT_PARAMETER1> Parameters;
        CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC RootDesc;
 
        struct FPendingTable
        {
            ERootSignatureVisibility Visibility;
            ERootSignatureRangeType Type;
            int32 NumDescriptors;
            D3D12_DESCRIPTOR_RANGE_FLAGS FlagsOverride;
        };
        TArray<FPendingTable> PendingTables;
 
        void AddRootFlag(D3D12_ROOT_SIGNATURE_FLAGS RootFlag) override
        {
            RootFlags |= RootFlag;
        }
 
        void AddConstantBufferViewParameter(uint32 Register, uint32 Space, ERootSignatureVisibility Visibility = ERootSignatureVisibility::All) override
        {
            CD3DX12_ROOT_PARAMETER1& Parameter = Parameters.AddZeroed_GetRef();
            Parameter.InitAsConstantBufferView(Register, Space, StaticRootSignatureConstants::CBVRootDescriptorFlags, GetD3D12ShaderVisibility(Visibility));
        }
 
        void AddShaderResourceViewParameter(uint32 Register, uint32 Space, ERootSignatureVisibility Visibility = ERootSignatureVisibility::All) override
        {
            CD3DX12_ROOT_PARAMETER1& Parameter = Parameters.AddZeroed_GetRef();
            Parameter.InitAsShaderResourceView(Register, Space, D3D12_ROOT_DESCRIPTOR_FLAG_NONE, GetD3D12ShaderVisibility(Visibility));
        }
 
        void AddUnorderedAccessViewParameter(uint32 Register, uint32 Space, ERootSignatureVisibility Visibility = ERootSignatureVisibility::All) override
        {
            CD3DX12_ROOT_PARAMETER1& Parameter = Parameters.AddZeroed_GetRef();
            Parameter.InitAsUnorderedAccessView(Register, Space, D3D12_ROOT_DESCRIPTOR_FLAG_NONE, GetD3D12ShaderVisibility(Visibility));
        }
 
        void AddConstantsParameter(uint32 Num32BitValues, uint32 Register, uint32 Space) override
        {
            CD3DX12_ROOT_PARAMETER1& Parameter = Parameters.AddZeroed_GetRef();
            Parameter.InitAsConstants(Num32BitValues, Register, Space);
        }
 
        void AddTable(ERootSignatureVisibility Visibility, ERootSignatureRangeType Type, int32 NumDescriptors, D3D12_DESCRIPTOR_RANGE_FLAGS FlagsOverride = D3D12_DESCRIPTOR_RANGE_FLAG_NONE) override
        {
            if (!ShouldSkipType(Type))
            {
                const FPendingTable NewTable{ Visibility, Type, NumDescriptors, FlagsOverride };
                PendingTables.Emplace(NewTable);
            }
        }
 
        const D3D12_VERSIONED_ROOT_SIGNATURE_DESC& Finalize()
        {
#if !defined(D3D12RHI_TOOLS_RAYTRACING_SHADERS_UNSUPPORTED)
            if (RootFlags & D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE)
            {
                // if set, D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE should be the only flag set
                RootFlags = D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE;
            }
#endif
 
            DescriptorRanges.SetNum(PendingTables.Num());
 
            for (int32 Index = 0; Index < PendingTables.Num(); Index++)
            {
                const FPendingTable& PendingTable = PendingTables[Index];
 
                const D3D12_DESCRIPTOR_RANGE_FLAGS RangeFlags = PendingTable.FlagsOverride ? PendingTable.FlagsOverride : GetD3D12DescriptorRangeFlags(PendingTable.Type);
 
                DescriptorRanges[Index].Init(GetD3D12DescriptorRangeType(PendingTable.Type), PendingTable.NumDescriptors, 0, RegisterSpace, RangeFlags);
 
                CD3DX12_ROOT_PARAMETER1& Parameter = Parameters.AddZeroed_GetRef();
                Parameter.InitAsDescriptorTable(1, &DescriptorRanges[Index], GetD3D12ShaderVisibility(PendingTable.Visibility));
            }
 
            RootDesc.Init_1_1(Parameters.Num(), Parameters.GetData(), 0, nullptr, RootFlags);
 
            return RootDesc;
        }
    };
 
    /* Root signature generator for DXC */
    struct FTextRootSignatureCreator final : public FRootSignatureCreator
    {
        void AddRootFlag(D3D12_ROOT_SIGNATURE_FLAGS InFlag) override
        {
            if (RootFlags.Len() > 0)
            {
                RootFlags += "|";
            }
            RootFlags += GetFlagName(InFlag);
        }
 
        void AddConstantBufferViewParameter(uint32 Register, uint32 Space, ERootSignatureVisibility Visibility = ERootSignatureVisibility::All) override
        {
            FString Line = FString::Printf(TEXT("CBV(t%d, space=%d, visibility=%s))"), Register, Space, GetVisibilityFlag(Visibility));
            if (Table.Len() > 0)
            {
                Table += ",";
            }
            Table += Line;
        }
 
        void AddShaderResourceViewParameter(uint32 Register, uint32 Space, ERootSignatureVisibility Visibility = ERootSignatureVisibility::All) override
        {
            FString Line = FString::Printf(TEXT("SRV(t%d, space=%d, visibility=%s))"), Register, Space, GetVisibilityFlag(Visibility));
            if (Table.Len() > 0)
            {
                Table += ",";
            }
            Table += Line;
        }
 
        void AddUnorderedAccessViewParameter(uint32 Register, uint32 Space, ERootSignatureVisibility Visibility = ERootSignatureVisibility::All) override
        {
            FString Line = FString::Printf(TEXT("UAV(u%d, space=%d, visibility=%s)"), Register, Space, GetVisibilityFlag(Visibility));
            if (Table.Len() > 0)
            {
                Table += ",";
            }
            Table += Line;
        }
 
        void AddConstantsParameter(uint32 Num32BitValues, uint32 Register, uint32 Space) override
        {
            FString Line = FString::Printf(TEXT("RootConstants(num32BitConstants=%d, b%d, space=%d)"), Num32BitValues, Register, Space);
            if (Table.Len() > 0)
            {
                Table += ",";
            }
            Table += Line;
        }
 
        void AddTable(ERootSignatureVisibility Visibility, ERootSignatureRangeType Type, int32 NumDescriptors, D3D12_DESCRIPTOR_RANGE_FLAGS FlagsOverride = D3D12_DESCRIPTOR_RANGE_FLAG_NONE) override
        {
            if (!ShouldSkipType(Type))
            {
                FString Line = FString::Printf(TEXT("DescriptorTable(visibility=%s, %s0, space=%d, numDescriptors=%d))"),
                    GetVisibilityFlag(Visibility), GetTypePrefix(Type), RegisterSpace, NumDescriptors
                );
                if (Table.Len() > 0)
                {
                    Table += ",";
                }
                Table += Line;
            }
        }
 
        FString GenerateString() const
        {
            FString String = FString::Printf(TEXT("\"RootFlags(%s),%s\""),
                RootFlags.Len() == 0 ? TEXT("0") : *RootFlags,
                *Table);
            return String;
        }
 
        FString RootFlags;
        FString Table;
    };
 
    inline void AddAllStandardTablesForVisibility(FRootSignatureCreator& Creator, ERootSignatureVisibility Visibility)
    {
        Creator.AddTable(Visibility, ERootSignatureRangeType::SRV, MAX_SRVS);
        Creator.AddTable(Visibility, ERootSignatureRangeType::CBV, MAX_CBS);
        Creator.AddTable(Visibility, ERootSignatureRangeType::Sampler, MAX_SAMPLERS);
    }
 
    // Fat/Static Gfx Root Signature
    inline void CreateGfxRootSignature(FRootSignatureCreator& Creator, EShaderBindingLayoutFlags InFlags)
    {
        // Ensure the creator starts in a clean state (in cases of creator reuse, etc.).
        Creator.SetFlags(InFlags | EShaderBindingLayoutFlags::InputAssembler);
 
        Creator.AddUnorderedAccessViewParameter(0, UE_HLSL_SPACE_DIAGNOSTIC);
 
        if (EnumHasAnyFlags(InFlags, EShaderBindingLayoutFlags::RootConstants))
        {
            const uint32 NumConstants = 4u;
            Creator.AddConstantsParameter(NumConstants, 0u, UE_HLSL_SPACE_SHADER_ROOT_CONSTANTS); // UERootConstants
        }
 
        // Tables must be added only after other parameters
 
        AddAllStandardTablesForVisibility(Creator, ERootSignatureVisibility::Pixel);
        AddAllStandardTablesForVisibility(Creator, ERootSignatureVisibility::Vertex);
        AddAllStandardTablesForVisibility(Creator, ERootSignatureVisibility::Geometry);
 
#if !defined(D3D12RHI_TOOLS_MESH_SHADERS_UNSUPPORTED)
        if (EnumHasAnyFlags(InFlags, EShaderBindingLayoutFlags::AllowMeshShaders))
        {
            AddAllStandardTablesForVisibility(Creator, ERootSignatureVisibility::Mesh);
            AddAllStandardTablesForVisibility(Creator, ERootSignatureVisibility::Amplification);
        }
#endif
 
        Creator.AddTable(ERootSignatureVisibility::Pixel, ERootSignatureRangeType::UAV, MAX_UAVS);
        Creator.AddTable(ERootSignatureVisibility::Vertex, ERootSignatureRangeType::UAV, MAX_UAVS);
    }
 
    // Fat/Static Compute Root Signature
    inline void CreateComputeRootSignature(FRootSignatureCreator& Creator, EShaderBindingLayoutFlags InFlags)
    {
        // Ensure the creator starts in a clean state (in cases of creator reuse, etc.).
        Creator.SetFlags(InFlags);
 
        Creator.AddUnorderedAccessViewParameter(0, UE_HLSL_SPACE_DIAGNOSTIC);
 
        if (EnumHasAnyFlags(InFlags, EShaderBindingLayoutFlags::RootConstants))
        {
            const uint32 NumConstants = 4u;
            Creator.AddConstantsParameter(NumConstants, 0u, UE_HLSL_SPACE_SHADER_ROOT_CONSTANTS); // UERootConstants
        }
 
        // Tables must be added only after other parameters
 
        AddAllStandardTablesForVisibility(Creator, ERootSignatureVisibility::All);
        Creator.AddTable(ERootSignatureVisibility::All, ERootSignatureRangeType::UAV, MAX_UAVS);
    }
 
#if !defined(D3D12RHI_TOOLS_RAYTRACING_SHADERS_UNSUPPORTED)
    inline void CreateRayTracingSignature(FRootSignatureCreator& Creator, bool bLocalRootSignature, D3D12_ROOT_SIGNATURE_FLAGS BaseRootFlags, EShaderBindingLayoutFlags InFlags)
    {
        Creator.SetFlags(InFlags);
        Creator.AddRootFlag(BaseRootFlags);
        Creator.SetRegisterSpace(bLocalRootSignature ? UE_HLSL_SPACE_RAY_TRACING_LOCAL : UE_HLSL_SPACE_RAY_TRACING_GLOBAL);
 
        if (bLocalRootSignature)
        {
            if (Creator.HasFlags(EShaderBindingLayoutFlags::BindlessResources))
            {
                // Num constants could be 2 smaller if non-bindless data is removed (24 bytes instead of 32)
                // (see notes in FD3D12RootSignatureDesc constructor)
                uint32 NumConstants = sizeof(FD3D12HitGroupSystemParameters) / sizeof(uint32);
                Creator.AddConstantsParameter(NumConstants, RAY_TRACING_SYSTEM_ROOTCONSTANT_REGISTER, UE_HLSL_SPACE_RAY_TRACING_SYSTEM);
            }
            else
            {
                uint32 NumConstants = sizeof(FHitGroupSystemRootConstants) / sizeof(uint32);
                Creator.AddConstantsParameter(NumConstants, RAY_TRACING_SYSTEM_ROOTCONSTANT_REGISTER, UE_HLSL_SPACE_RAY_TRACING_SYSTEM);
 
                Creator.AddShaderResourceViewParameter(RAY_TRACING_SYSTEM_INDEXBUFFER_REGISTER, UE_HLSL_SPACE_RAY_TRACING_SYSTEM);
                Creator.AddShaderResourceViewParameter(RAY_TRACING_SYSTEM_VERTEXBUFFER_REGISTER, UE_HLSL_SPACE_RAY_TRACING_SYSTEM);
            }
        }
        else if (Creator.HasFlags(EShaderBindingLayoutFlags::ShaderBindingLayoutUsed))
        {
            for (uint32 Index = 0; Index < FRHIShaderBindingLayout::MaxUniformBufferEntries; ++Index)
            {
                Creator.AddConstantBufferViewParameter(Index, UE_HLSL_SPACE_STATIC_SHADER_BINDINGS);
            }
        }
 
        if (Creator.HasFlags(EShaderBindingLayoutFlags::BindlessResources))
        {
            for (uint32 Index = 0; Index < MAX_CBS; Index++)
            {
                Creator.AddConstantBufferViewParameter(Index, Creator.GetRegisterSpace());
            }
        }
        else
        {
            AddAllStandardTablesForVisibility(Creator, ERootSignatureVisibility::All);
        }
 
        Creator.AddTable(ERootSignatureVisibility::All, ERootSignatureRangeType::UAV, MAX_UAVS, D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE | D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE);
    }
 
    inline FString GenerateRayTracingSignatureString(bool bLocalRootSignature, D3D12_ROOT_SIGNATURE_FLAGS BaseRootFlags, EShaderBindingLayoutFlags InFlags)
    {
        FTextRootSignatureCreator Creator;
        CreateRayTracingSignature(Creator, bLocalRootSignature, BaseRootFlags, InFlags);
        return Creator.GenerateString();
    }
#endif 
 
    inline FString GenerateRootSignatureString(EShaderFrequency InFrequency, EShaderBindingLayoutFlags InFlags)
    {
        FTextRootSignatureCreator Creator;
 
        if (InFrequency < SF_NumGraphicsFrequencies)
        {
            D3D12ShaderUtils::CreateGfxRootSignature(Creator, InFlags);
        }
        else if (InFrequency == SF_Compute)
        {
            D3D12ShaderUtils::CreateComputeRootSignature(Creator, InFlags);
        }
        else
        {
            return TEXT("");
        }
 
        return Creator.GenerateString();
    }
}