ShaderPrintParameters.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// The ShaderPrint system uses a RWBuffer to capture any debug print from a shader.
// This means that the buffer needs to be bound for the shader you wish to debug.
// It would be ideal if that was automatic (maybe by having a fixed bind point for the buffer and binding it for the entire view).
// But for now you need to manually add binding information to your FShader class.
// To do this use SHADER_PARAMETER_STRUCT_INCLUDE(ShaderPrint::FShaderParameters) in your FShader::FParameters declaration.
// Then call a variant of SetParameters().
 
#pragma once
 
#include "CoreMinimal.h"
#include "RenderGraphDefinitions.h"
#include "RenderGraphResources.h"
#include "ShaderParameterMacros.h"
#include "ShaderParameters.h"
 
class FRDGBuilder;
class FSceneView;
class FViewInfo;
struct FFrozenShaderPrintData;
struct FGlobalShaderPermutationParameters;
struct FShaderCompilerEnvironment;
struct FShaderPrintData;
 
namespace ShaderPrint
{
    // ShaderPrint uniform buffer layout
    BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT(FShaderPrintCommonParameters, RENDERER_API)
        SHADER_PARAMETER(FIntPoint, Resolution)
        SHADER_PARAMETER(FIntPoint, CursorCoord)
        SHADER_PARAMETER(FVector3f, TranslatedWorldOffset)
        SHADER_PARAMETER(FVector2f, FontSize)
        SHADER_PARAMETER(FVector2f, FontSpacing)
        SHADER_PARAMETER(uint32, MaxCharacterCount)
        SHADER_PARAMETER(uint32, MaxSymbolCount)
        SHADER_PARAMETER(uint32, MaxStateCount)
        SHADER_PARAMETER(uint32, MaxLineCount)
        SHADER_PARAMETER(uint32, MaxTriangleCount)
        SHADER_PARAMETER(uint32, IsDrawLocked)
    END_GLOBAL_SHADER_PARAMETER_STRUCT()
 
    // ShaderPrint parameter struct declaration
    BEGIN_SHADER_PARAMETER_STRUCT(FShaderParameters, )
        SHADER_PARAMETER_STRUCT_REF(FShaderPrintCommonParameters, Common)
        SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer<uint>, ShaderPrint_StateBuffer)
        SHADER_PARAMETER_RDG_BUFFER_UAV(RWBuffer<uint>, ShaderPrint_RWEntryBuffer)
    END_SHADER_PARAMETER_STRUCT()
 
    // Does the platform support the ShaderPrint system?
    // Use this to create debug shader permutations only for supported platforms.
    RENDERER_API bool IsSupported(EShaderPlatform Platform);
 
    // Set any flags or defines needed when using ShaderPrint
    RENDERER_API void ModifyCompilationEnvironment(const EShaderPlatform Platform, FShaderCompilerEnvironment& OutEnvironment);
    RENDERER_API void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment);
 
    // Have we enabled the ShaderPrint system?
    // Note that even when the ShaderPrint system is enabled, it may be disabled on any view due to platform support or view flags.
    RENDERER_API bool IsEnabled();
 
    // Force enable/disable the ShaderPrint system.
    RENDERER_API void SetEnabled(bool bInEnabled);
 
    // Returns true if the shader print data is valid for binding.
    // This should be checked before using with any ShaderPrint shader permutation.
    RENDERER_API bool IsValid(FShaderPrintData const& InShaderPrintData);
 
    // Returns true if the shader print data is enabled.
    // When the shader print data is valid but disabled then it can be used with any ShaderPrint shader permutation, but no data will be captured.
    // This can be checked to early out on any work that is only generating ShaderPrint data.
    RENDERER_API bool IsEnabled(FShaderPrintData const& InShaderPrintData);
 
    // Returns true if the default view exists and has valid shader print data.
    // This should be checked before using with any ShaderPrint shader permutation.
    RENDERER_API bool IsDefaultViewValid();
 
    // Returns true if the default view exists and shader print data that is enabled.
    // When the shader print data is valid but disabled then it can be used with any ShaderPrint shader permutation, but no data will be captured.
    // This can be checked to early out on any work that is only generating ShaderPrint data.
    RENDERER_API bool IsDefaultViewEnabled();
 
    RENDERER_API void RequestSpaceForCharacters(uint32 MaxElementCount);
 
    RENDERER_API void RequestSpaceForLines(uint32 MaxElementCount);
 
    RENDERER_API void RequestSpaceForTriangles(uint32 MaxElementCount);
 
    struct FShaderPrintSetup
    {
        FShaderPrintSetup() = default;
        RENDERER_API FShaderPrintSetup(FSceneView const& InView);
        RENDERER_API FShaderPrintSetup(FIntRect InViewRect);
 
        bool bEnabled = false;
        FIntRect ViewRect = FIntRect(0, 0, 1, 1);
        FIntPoint CursorCoord = FIntPoint(-1, -1);
        FVector PreViewTranslation = FVector::ZeroVector;
        float DPIScale = 1.f;
        FIntPoint FontSize = 1;
        FIntPoint FontSpacing = 1;
        uint32 MaxCharacterCount = 0;
        uint32 MaxStateCount = 0;
        uint32 MaxLineCount = 0;
        uint32 MaxTriangleCount = 0;
        // Whether current draw is locked or not. Useful to stop rendering new stuff on top of the history. */
        bool bIsDrawLocked = false;
    };
 
    RENDERER_API void GetParameters(FShaderPrintSetup const& InSetup, FShaderPrintCommonParameters& OutParameters);
 
    RENDERER_API FShaderPrintData CreateShaderPrintData(FRDGBuilder& GraphBuilder, FShaderPrintSetup const& InSetup);
    
    RENDERER_API FFrozenShaderPrintData FreezeShaderPrintData(FRDGBuilder& GraphBuilder, FShaderPrintData& ShaderPrintData);
    RENDERER_API FShaderPrintData UnFreezeShaderPrintData(FRDGBuilder& GraphBuilder, FFrozenShaderPrintData& FrozenShaderPrintData);
 
    RENDERER_API void SubmitShaderPrintData(FFrozenShaderPrintData& InData, FSceneInterface const* InScene);
 
    UE_DEPRECATED(5.2, "Use the version of this function that takes a FSceneInterface")
    RENDERER_API void SubmitShaderPrintData(FFrozenShaderPrintData& InData);
 
    RENDERER_API void SetParameters(FRDGBuilder& GraphBuilder, FShaderPrintData const& InData, FShaderParameters& OutParameters);
    RENDERER_API void SetParameters(FRDGBuilder& GraphBuilder, FShaderParameters& OutParameters);
    
    UE_DEPRECATED(5.1, "Use one of the other implementations of SetParameters()")
    void SetParameters(FRDGBuilder& GraphBuilder, const FViewInfo& View, FShaderParameters& OutParameters);
 
    // Experimental GPU string
    //
    // In Cpp:
    //   SHADER_PARAMETER_STRUCT(ShaderPrint::FStrings::FShaderPararameters, MyVariable)
    //   ShaderPrint::FStrings MyVariable;
    //   MyVariable.Add(FString(...), StringId);
    //
    // In shader:
    //   FSTRINGS(MyVariable)
    //   void foo()
    //   {  
    //     InitShaderPrintContext Ctx = InitShaderPrintContext(...);
    //     PrintMyVariable(Ctx, StringId, FontWhite);
    //   }
    struct FStrings
    {
    public:
        BEGIN_SHADER_PARAMETER_STRUCT(FShaderParameters, )
            SHADER_PARAMETER(uint32, InfoCount)
            SHADER_PARAMETER(uint32, CharCount)
            SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<uint2>, InfoBuffer)
            SHADER_PARAMETER_RDG_BUFFER_SRV(Buffer<uint8>, CharBuffer)
        END_SHADER_PARAMETER_STRUCT()
 
        RENDERER_API FStrings(uint32 InAvgEntryCount=128u, uint32 InAvgStringLength=32u);
        RENDERER_API void Add(const FString& In, uint32 EntryID);
        RENDERER_API void Add(const FString& In);
        RENDERER_API FShaderParameters GetParameters(FRDGBuilder& GraphBuilder);
    private:
        struct FEntryInfo
        {
            uint32 EntryID;
            uint16 Offset;
            uint8  Length;
            uint8  Pad0;
        };
        TArray<FEntryInfo> Infos;
        TArray<uint8> Chars;
    };
}
 
struct FShaderPrintData
{
    ShaderPrint::FShaderPrintSetup Setup;
    TUniformBufferRef<ShaderPrint::FShaderPrintCommonParameters> UniformBuffer;
 
    FRDGBufferRef ShaderPrintEntryBuffer = nullptr;
    FRDGBufferRef ShaderPrintStateBuffer = nullptr;
};
 
struct FFrozenShaderPrintData
{
    ShaderPrint::FShaderPrintSetup Setup;
 
    TRefCountPtr<FRDGPooledBuffer> ShaderPrintEntryBuffer;
    TRefCountPtr<FRDGPooledBuffer> ShaderPrintStateBuffer;
};