ShaderParameterParser.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "ShaderParameterMetadata.h"
#include "ShaderCore.h"
 
class FShaderCompilerFlags;
struct FShaderCompilerInput;
struct FShaderCompilerOutput;
struct FShaderCompilerEnvironment;
struct FShaderCompilerError;
 
enum class EShaderParameterType : uint8;
 
enum class EBindlessConversionType : uint8
{
    None,
    SRV,
    UAV,
    Sampler,
};
 
enum class EShaderParameterParserConfigurationFlags
{
    None                    = 0,
    UseStableConstantBuffer = 1 << 0,
    SupportsBindless        = 1 << 1,
    // "Vulkan" style
    BindlessUsesArrays      = 1 << 2,
    // Some RHI Validation requires parameters to be parsed
    AlwaysParseParams       = 1 << 3,
    // Replace loose data globals in bindless shaders
    ReplaceGlobals          = 1 << 4,
};
ENUM_CLASS_FLAGS(EShaderParameterParserConfigurationFlags)
 
 
class FShaderParameterParser
{
public:
    struct FPlatformConfiguration
    {
        FPlatformConfiguration() = default;
        FPlatformConfiguration(FStringView InStableConstantBufferType, EShaderParameterParserConfigurationFlags InFlags = EShaderParameterParserConfigurationFlags::None)
            : StableConstantBufferType(InStableConstantBufferType)
            , Flags(InFlags)
        {
            if (InStableConstantBufferType.Len())
            {
                EnumAddFlags(Flags, EShaderParameterParserConfigurationFlags::UseStableConstantBuffer);
            }
        }
 
        virtual ~FPlatformConfiguration()
        {}
 
        virtual FString GenerateBindlessAccess(EBindlessConversionType BindlessType, FStringView FullTypeString, FStringView ArrayNameOverride, FStringView IndexString) const
        {
            checkf(false, TEXT("Platforms that support bindless must override GenerateBindlessAccess"));
            return FString();
        }
 
        virtual FString ReplaceGlobal(FStringView FullDeclString, FStringView ParamName) const
        {
            checkf(false, TEXT("Platforms that support replacing globals must override ReplaceGlobal"));
            return FString();
        }
 
        virtual FString GetStableConstantBufferRegisterString(EShaderFrequency ShaderFrequency) const
        {
            // Not required to be overridden
            return FString();
        }
 
        TConstArrayView<FStringView> ExtraSRVTypes;
        TConstArrayView<FStringView> ExtraUAVTypes;
        FStringView StableConstantBufferType;
        EShaderParameterParserConfigurationFlags Flags = EShaderParameterParserConfigurationFlags::None;
    };
 
    struct FParsedShaderParameter
    {
    public:
        TEnumAsByte<EUniformBufferBaseType> BaseType{ UBMT_INVALID };
        TEnumAsByte<EShaderPrecisionModifier::Type> PrecisionModifier{ EShaderPrecisionModifier::Invalid };
        uint32 NumRows = 0u;
        uint32 NumColumns = 0u;
        uint32 MemberSize = 0u;
 
        FStringView ParsedName; 
        FStringView ParsedType; 
        FStringView ParsedArraySize; 
        int32 ConstantBufferOffset = 0;
 
        /* Returns whether the shader parameter has been found when parsing. */
        bool IsFound() const
        {
            return !ParsedType.IsEmpty();
        }
 
        int32 ParsedPragmaLineOffset = 0;
        int32 ParsedLineOffset = 0;
 
        int32 ParsedCharOffsetStart = INDEX_NONE;
        int32 ParsedCharOffsetEnd = INDEX_NONE;
 
        EBindlessConversionType BindlessConversionType{};
        EShaderParameterType ConstantBufferParameterType{};
 
        bool bGloballyCoherent = false;
        bool bIsBindable = false;
 
        EShaderCodeResourceBindingType ParsedTypeDecl = EShaderCodeResourceBindingType::Invalid;
 
        friend class FShaderParameterParser;
    };
 
    FShaderParameterParser() = delete;
    RENDERCORE_API FShaderParameterParser(const FPlatformConfiguration& InPlatformConfiguration);
 
    RENDERCORE_API virtual ~FShaderParameterParser();
 
    static constexpr const TCHAR* kBindlessSRVPrefix = TEXT("BindlessSRV_");
    static constexpr const TCHAR* kBindlessUAVPrefix = TEXT("BindlessUAV_");
    static constexpr const TCHAR* kBindlessSamplerPrefix = TEXT("BindlessSampler_");
 
    // Prefix used to declare arrays of samplers/resources for bindless
    static constexpr const TCHAR* kBindlessSRVArrayPrefix = TEXT("SRVDescriptorHeap_");
    static constexpr const TCHAR* kBindlessUAVArrayPrefix = TEXT("UAVDescriptorHeap_");
    static constexpr const TCHAR* kBindlessSamplerArrayPrefix = TEXT("SamplerDescriptorHeap_");
 
    static RENDERCORE_API EShaderParameterType ParseAndRemoveBindlessParameterPrefix(FStringView& InName);
    static RENDERCORE_API EShaderParameterType ParseAndRemoveBindlessParameterPrefix(FString& InName);
    static RENDERCORE_API bool RemoveBindlessParameterPrefix(FString& InName);
    static RENDERCORE_API FStringView GetBindlessParameterPrefix(EShaderParameterType InShaderParameterType);
 
    RENDERCORE_API bool ParseAndModify(
        const FShaderCompilerInput& CompilerInput,
        TArray<FShaderCompilerError>& OutErrors,
        FString& PreprocessedShaderSource
    );
 
    const FParsedShaderParameter& FindParameterInfos(const FString& ParameterName) const
    {
        const FParsedShaderParameter* ShaderParameter = ParsedParameters.Find(ParameterName);
        checkf(ShaderParameter != nullptr, TEXT("Missing shader parameter '%s'"), *ParameterName);
        return *ShaderParameter;
    }
 
    const FParsedShaderParameter* FindParameterInfosUnsafe(const FString& ParameterName) const
    {
        return ParsedParameters.Find(ParameterName);
    }
 
    RENDERCORE_API void ValidateShaderParameterType(
        const FShaderCompilerInput& CompilerInput,
        const FString& ShaderBindingName,
        int32 ReflectionOffset,
        int32 ReflectionSize,
        bool bPlatformSupportsPrecisionModifier,
        FShaderCompilerOutput& CompilerOutput) const;
 
    void ValidateShaderParameterType(
        const FShaderCompilerInput& CompilerInput,
        const FString& ShaderBindingName,
        int32 ReflectionOffset,
        int32 ReflectionSize,
        FShaderCompilerOutput& CompilerOutput) const
    {
        ValidateShaderParameterType(CompilerInput, ShaderBindingName, ReflectionOffset, ReflectionSize, false, CompilerOutput);
    }
 
    RENDERCORE_API void ValidateShaderParameterTypes(
        const FShaderCompilerInput& CompilerInput,
        bool bPlatformSupportsPrecisionModifier,
        FShaderCompilerOutput& CompilerOutput) const;
 
    void ValidateShaderParameterTypes(
        const FShaderCompilerInput& CompilerInput,
        FShaderCompilerOutput& CompilerOutput) const
    {
        ValidateShaderParameterTypes(CompilerInput, false, CompilerOutput);
    }
 
    void GetParameterFileAndLine(const FParsedShaderParameter& ParsedParameter, FString& OutFile, FString& OutLine) const
    {
        return ExtractFileAndLine(ParsedParameter.ParsedPragmaLineOffset, ParsedParameter.ParsedLineOffset, OutFile, OutLine);
    }
 
    bool DidModifyShader() const { return bModifiedShader; }
 
protected:
    RENDERCORE_API EShaderParameterType ParseParameterType(FStringView InType);
 
    RENDERCORE_API bool ParseParameters(
        const FShaderParametersMetadata* RootParametersStructure,
        TArray<FShaderCompilerError>& OutErrors
    );
 
    RENDERCORE_API void RemoveMovingParametersFromSource(
        FString& PreprocessedShaderSource
    );
 
    RENDERCORE_API void ApplyBindlessModifications(
        FString& PreprocessedShaderSource
    );
 
    RENDERCORE_API bool MoveShaderParametersToRootConstantBuffer(
        const FShaderParametersMetadata* RootParametersStructure,
        EShaderFrequency ShaderFrequency,
        FString& PreprocessedShaderSource
    );
 
    RENDERCORE_API void ExtractFileAndLine(int32 PragamLineoffset, int32 LineOffset, FString& OutFile, FString& OutLine) const;
 
    RENDERCORE_API virtual FString GenerateBindlessParameterDeclaration(const FParsedShaderParameter& ParsedParameter) const;
 
    const FPlatformConfiguration& PlatformConfiguration;
 
    FString OriginalParsedShader;
 
    TMap<FString, FParsedShaderParameter> ParsedParameters;
 
    bool bBindlessEnabled = false;
 
    bool bNeedToMoveToRootConstantBuffer = false;
 
    bool bMovedLoosedParametersToRootConstantBuffer = false;
 
    bool bModifiedShader = false;
};