ShaderParameterMetadata.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    ShaderParameterMetadata.h: Meta data about shader parameter structures
=============================================================================*/
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/List.h"
#include "Containers/Map.h"
#include "Containers/StaticArray.h"
#include "Containers/StringFwd.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "HAL/Platform.h"
#include "Misc/AssertionMacros.h"
#include "Misc/CString.h"
#include "Misc/StringBuilder.h"
#include "RHI.h"
#include "RHIDefinitions.h"
#include "Serialization/MemoryHasher.h"
#include "Serialization/MemoryImage.h"
#include "Serialization/MemoryLayout.h"
#include "Templates/AlignmentTemplates.h"
#include "UObject/NameTypes.h"
#include "Templates/SharedPointer.h"
 
using FThreadSafeSharedStringPtr = TSharedPtr<FString, ESPMode::ThreadSafe>;
using FThreadSafeSharedAnsiStringPtr = TSharedPtr<TArray<ANSICHAR>, ESPMode::ThreadSafe>;
using FThreadSafeNameBufferPtr = TSharedPtr<TArray<TCHAR>, ESPMode::ThreadSafe>;
class FShaderKeyGenerator;
struct FShaderResourceTableMap;
 
namespace EShaderPrecisionModifier
{
    enum Type : uint8
    {
        Float,
        Half,
        Fixed,
        Invalid
    };
};
 
bool SupportShaderPrecisionModifier(EShaderPlatform Platform);
 
struct FUniformResourceEntry
{
    const TCHAR* UniformBufferMemberName;
    uint8 UniformBufferNameLength{};
    uint8 Type{};
    uint16 ResourceIndex{};
 
    inline FStringView GetUniformBufferName() const { return FStringView(UniformBufferMemberName, UniformBufferNameLength); }
};
 
struct FUniformBufferEntry
{
    FString StaticSlotName;
 
    FThreadSafeNameBufferPtr MemberNameBuffer;
 
    uint32 LayoutHash{};
 
    EUniformBufferBindingFlags BindingFlags{ EUniformBufferBindingFlags::Shader };
 
    ERHIUniformBufferFlags Flags{ ERHIUniformBufferFlags::None };
};
 
EShaderCodeResourceBindingType ParseShaderResourceBindingType(const TCHAR* ShaderType);
 
class FUniformBufferStaticSlotRegistrar
{
public:
    RENDERCORE_API FUniformBufferStaticSlotRegistrar(const TCHAR* InName);
};
 
class FUniformBufferStaticSlotRegistry
{
public:
    static RENDERCORE_API FUniformBufferStaticSlotRegistry& Get();
 
    RENDERCORE_API void RegisterSlot(FName SlotName);
 
    inline int32 GetSlotCount() const
    {
        return SlotNames.Num();
    }
 
    inline FString GetDebugDescription(FUniformBufferStaticSlot Slot) const
    {
        return FString::Printf(TEXT("[Name: %s, Slot: %u]"), *GetSlotName(Slot).ToString(), Slot);
    }
 
    inline FName GetSlotName(FUniformBufferStaticSlot Slot) const
    {
        checkf(Slot < SlotNames.Num(), TEXT("Requesting name for an invalid slot: %u."), Slot);
        return SlotNames[Slot];
    }
 
    inline FUniformBufferStaticSlot FindSlotByName(FName SlotName) const
    {
        // Brute force linear search. The search space is small and the find operation should not be critical path.
        for (int32 Index = 0; Index < SlotNames.Num(); ++Index)
        {
            if (SlotNames[Index] == SlotName)
            {
                return FUniformBufferStaticSlot(Index);
            }
        }
        return MAX_UNIFORM_BUFFER_STATIC_SLOTS;
    }
 
private:
    TArray<FName> SlotNames;
};
 
class FShaderParametersMetadata
{
public:
    enum class EUseCase : uint8
    {
        ShaderParameterStruct,
 
        UniformBuffer,
 
        DataDrivenUniformBuffer,
    };
 
    enum class EUsageFlags : uint8
    {
        None = 0,
 
        NoEmulatedUniformBuffer = 1 << 0,
        
        UniformView = 1 << 1,
 
        NeedsReflectedMembers = 1 << 2,
 
        ManuallyBoundByPass = 1 << 3,
    };
 
    static constexpr const TCHAR* kRootUniformBufferBindingName = TEXT("_RootShaderParameters");
 
    static constexpr int32 kRootCBufferBindingIndex = 0;
 
    class FMember
    {
    public:
 
        FMember(
            const TCHAR* InName,
            const TCHAR* InShaderType,
            int32 InFileLine,
            uint32 InOffset,
            EUniformBufferBaseType InBaseType,
            EShaderPrecisionModifier::Type InPrecision,
            uint32 InNumRows,
            uint32 InNumColumns,
            uint32 InNumElements,
            const FShaderParametersMetadata* InStruct
            )
        :   Name(InName)
        ,   ShaderType(InShaderType)
        ,   FileLine(InFileLine)
        ,   Offset(InOffset)
        ,   BaseType(InBaseType)
        ,   Precision(InPrecision)
        ,   NumRows(InNumRows)
        ,   NumColumns(InNumColumns)
        ,   NumElements(InNumElements)
        ,   Struct(InStruct)
        {
            check(InShaderType);
        }
 
        const TCHAR* GetName() const { return Name; }
 
        const TCHAR* GetShaderType() const { return ShaderType; }
 
        int32 GetFileLine() const { return int32(FileLine); }
 
        uint32 GetOffset() const { return Offset; }
 
        EUniformBufferBaseType GetBaseType() const { return BaseType; }
 
        EShaderPrecisionModifier::Type GetPrecision() const { return Precision; }
 
        uint32 GetNumRows() const { return NumRows; }
 
        uint32 GetNumColumns() const { return NumColumns; }
 
        uint32 GetNumElements() const { return NumElements; }
 
        const FShaderParametersMetadata* GetStructMetadata() const { return Struct; }
 
        inline bool IsVariableNativeType() const
        {
            return 
                BaseType == UBMT_INT32 ||
                BaseType == UBMT_UINT32 ||
                BaseType == UBMT_FLOAT32;
        }
 
        inline uint32 GetMemberSize() const
        {
            check(IsVariableNativeType());
            uint32 ElementSize = sizeof(uint32) * NumRows * NumColumns;
 
            if (NumElements > 0)
            {
                return Align(ElementSize, SHADER_PARAMETER_ARRAY_ELEMENT_ALIGNMENT) * NumElements;
            }
            return ElementSize;
        }
 
        static RENDERCORE_API void GenerateShaderParameterType(
            FString& Result,
            bool bSupportsPrecisionModifier,
            EUniformBufferBaseType BaseType,
            EShaderPrecisionModifier::Type PrecisionModifier,
            uint32 NumRows,
            uint32 NumColumns
        );
        RENDERCORE_API void GenerateShaderParameterType(FString& Result, bool bSupportsPrecisionModifier) const;
        RENDERCORE_API void GenerateShaderParameterType(FString& Result, EShaderPlatform ShaderPlatform) const;
 
    private:
        friend class FShaderParametersMetadata;
        
        template<typename FHasherType, typename FHashType>
        void HashLayout(TMemoryHasher<FHasherType, FHashType>& Hasher)
        {
            Hasher << Offset;
            Hasher << reinterpret_cast<uint8&>(BaseType);
 
            Hasher.Serialize(const_cast<TCHAR*>(Name), FCString::Strlen(Name));
            Hasher << NumElements;
 
            const bool bIsRHIResource = IsShaderParameterTypeReadOnlyRHIResource(BaseType);
            const bool bIsRDGResource = IsRDGResourceReferenceShaderParameterType(BaseType);
 
            if (BaseType == UBMT_INT32 ||
                BaseType == UBMT_UINT32 ||
                BaseType == UBMT_FLOAT32)
            {
                Hasher << reinterpret_cast<uint8&>(Precision);
                Hasher << NumRows;
                Hasher << NumColumns;
            }
            else if (BaseType == UBMT_INCLUDED_STRUCT || BaseType == UBMT_NESTED_STRUCT)
            {
                const_cast<FShaderParametersMetadata*>(Struct)->HashLayout(Hasher);
            }
            else if (bIsRHIResource || bIsRDGResource)
            {
                Hasher.Serialize(const_cast<TCHAR*>(ShaderType), FCString::Strlen(ShaderType));
            }
        }
 
        const TCHAR* Name;
        const TCHAR* ShaderType;
        int32 FileLine;
        uint32 Offset;
        EUniformBufferBaseType BaseType;
        EShaderPrecisionModifier::Type Precision;
        uint32 NumRows;
        uint32 NumColumns;
        uint32 NumElements;
        const FShaderParametersMetadata* Struct;
    };
 
    RENDERCORE_API FShaderParametersMetadata(
        EUseCase UseCase,
        EUniformBufferBindingFlags InBindingFlags,
        const TCHAR* InLayoutName,
        const TCHAR* InStructTypeName,
        const TCHAR* InShaderVariableName,
        const TCHAR* InStaticSlotName,
        const ANSICHAR* InFileName,
        const int32 InFileLine,
        uint32 InSize,
        const TArray<FMember>& InMembers,
        bool bForceCompleteInitialization = false,
        FRHIUniformBufferLayoutInitializer* OutLayoutInitializer = nullptr,
        EUsageFlags InUsageFlags = EUsageFlags::None);
 
    RENDERCORE_API virtual ~FShaderParametersMetadata();
 
    RENDERCORE_API void GetNestedStructs(TArray<const FShaderParametersMetadata*>& OutNestedStructs) const;
 
#if WITH_EDITOR
    RENDERCORE_API void AddResourceTableEntries(FShaderResourceTableMap& ResourceTableMap, TMap<FString, FUniformBufferEntry>& UniformBufferMap) const;
#endif
 
    const TCHAR* GetStructTypeName() const { return StructTypeName; }
    const TCHAR* GetShaderVariableName() const { return ShaderVariableName; }
    const FHashedName& GetShaderVariableHashedName() const { return ShaderVariableHashedName; }
    const TCHAR* GetStaticSlotName() const { return StaticSlotName; }
 
    bool HasStaticSlot() const { return StaticSlotName != nullptr; }
 
    EUniformBufferBindingFlags GetBindingFlags() const { return BindingFlags; }
 
    EUniformBufferBindingFlags GetPreferredBindingFlag() const
    {
        // Decay to static when both binding flags are specified.
        return BindingFlags != EUniformBufferBindingFlags::StaticAndShader
            ? BindingFlags
            : EUniformBufferBindingFlags::Static;
    }
 
    const ANSICHAR* GetFileName() const { return FileName; }
 
    const int32 GetFileLine() const { return FileLine; }
 
    uint32 GetSize() const { return Size; }
    EUseCase GetUseCase() const { return UseCase; }
    inline bool IsLayoutInitialized() const { return Layout != nullptr; }
    EUsageFlags GetUsageFlags() const { return UsageFlags; }
 
    const FRHIUniformBufferLayout& GetLayout() const
    {
        check(IsLayoutInitialized());
        return *Layout;
    }
    const FRHIUniformBufferLayout* GetLayoutPtr() const
    {
        check(IsLayoutInitialized());
        return Layout;
    }
    const TArray<FMember>& GetMembers() const { return Members; }
 
#if WITH_EDITOR
    inline bool IsUniformBufferDeclarationInitialized() const { return UniformBufferDeclaration.IsValid(); }
    FThreadSafeSharedStringPtr GetUniformBufferDeclarationPtr() const { return UniformBufferDeclaration; }
    FThreadSafeSharedAnsiStringPtr GetUniformBufferDeclarationAnsiPtr() const { return UniformBufferDeclarationAnsi; }
    const FString& GetUniformBufferDeclaration() const { return *UniformBufferDeclaration; }
    inline const FString& GetUniformBufferPath() const { return UniformBufferPath; }
    inline const FString& GetUniformBufferInclude() const { return UniformBufferInclude; }
    inline uint32 GetUniformBufferPathHash() const { return UniformBufferPathHash; }
#endif // WITH_EDITOR
 
    RENDERCORE_API void FindMemberFromOffset(
        uint16 MemberOffset,
        const FShaderParametersMetadata** OutContainingStruct,
        const FShaderParametersMetadata::FMember** OutMember,
        int32* ArrayElementId, FString* NamePrefix) const;
 
    RENDERCORE_API FString GetFullMemberCodeName(uint16 MemberOffset) const;
 
    static RENDERCORE_API TLinkedList<FShaderParametersMetadata*>*& GetStructList();
    static RENDERCORE_API TMap<FHashedName, FShaderParametersMetadata*>& GetNameStructMap();
#if WITH_EDITOR
    static RENDERCORE_API TMap<FString, FShaderParametersMetadata*>& GetStringStructMap();
#endif // WITH_EDITOR
 
    static RENDERCORE_API void InitializeAllUniformBufferStructs();
 
    uint32 GetLayoutHash() const
    {
        check(UseCase == EUseCase::ShaderParameterStruct || UseCase == EUseCase::UniformBuffer);
        check(IsLayoutInitialized());
        return LayoutHash;  
    }
 
#if WITH_EDITOR
    RENDERCORE_API void AppendKeyString(FString& OutKeyString) const;
    RENDERCORE_API void Append(FShaderKeyGenerator& KeyGen) const;
#endif
 
    inline const FBlake3Hash& GetLayoutSignature() const
    {
#if WITH_EDITOR
        check(IsLayoutInitialized());
        return LayoutSignature;
#else
        // shader compilation types & WITH_EDITOR is a massive mess upstream; this should never actually be called outside of the editor
        // but actually compiling the function out is a headache, so we instead just assert if it's called 
        checkNoEntry();
        static FBlake3Hash Dummy;
        return Dummy;
#endif
    }
 
 
    template<typename TParameterFunction>
    void IterateStructureMetadataDependencies(TParameterFunction Lambda) const
    {
        for (const FShaderParametersMetadata::FMember& Member : Members)
        {
            const FShaderParametersMetadata* NewParametersMetadata = Member.GetStructMetadata();
 
            if (NewParametersMetadata)
            {
                NewParametersMetadata->IterateStructureMetadataDependencies(Lambda);
            }
        }
 
        Lambda(this);
    }
 
private:
    const TCHAR* const LayoutName;
 
    const TCHAR* const StructTypeName;
 
    const TCHAR* const ShaderVariableName;
 
    const TCHAR* const StaticSlotName;
 
    FHashedName ShaderVariableHashedName;
 
    const ANSICHAR* const FileName;
 
    const int32 FileLine;
 
    const uint32 Size;
 
    const EUseCase UseCase;
 
    const EUniformBufferBindingFlags BindingFlags;
 
    const EUsageFlags UsageFlags;
 
    FUniformBufferLayoutRHIRef Layout{};
    
    TArray<FMember> Members;
 
#if WITH_EDITOR
    FThreadSafeSharedStringPtr UniformBufferDeclaration;
    FThreadSafeSharedAnsiStringPtr UniformBufferDeclarationAnsi;
 
    TArray<FUniformResourceEntry> ResourceTableCache;
    FThreadSafeNameBufferPtr MemberNameBuffer;
 
    FString UniformBufferPath;      // Format:  "/Engine/Generated/UniformBuffers/%s.ush"
    FString UniformBufferInclude;   // Format:  "#include \"/Engine/Generated/UniformBuffers/%s.ush\"" HLSL_LINE_TERMINATOR
 
    uint32 UniformBufferPathHash;
    uint32 ShaderVariableNameHash;
#endif
 
    TLinkedList<FShaderParametersMetadata*> GlobalListLink;
 
    uint32 LayoutHash = 0;
 
    template<typename FHasherType, typename FHashType>
    void HashLayout(TMemoryHasher<FHasherType, FHashType>& Hasher)
    {
        for (FMember& CurrentMember : Members)
        {
            CurrentMember.HashLayout(Hasher);
        }
    }
 
#if WITH_EDITOR
    
    FBlake3Hash LayoutSignature;
#endif
 
    RENDERCORE_API void InitializeLayout(FRHIUniformBufferLayoutInitializer* OutLayoutInitializer = nullptr);
 
#if WITH_EDITOR
    RENDERCORE_API void InitializeUniformBufferDeclaration();
#endif
};
 
ENUM_CLASS_FLAGS(FShaderParametersMetadata::EUsageFlags);