RendererInterface.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    RendererInterface.h: Renderer interface definition.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Templates/RefCounting.h"
#include "Misc/MemStack.h"
#include "Modules/ModuleInterface.h"
#include "RHI.h"
#include "RenderResource.h"
#include "RenderUtils.h"
#include "Misc/EnumClassFlags.h"
#include "UniformBuffer.h"
#include "VirtualTexturing.h"
#include "RenderGraphDefinitions.h"
#include "PathTracingOutputInvalidateReason.h"
 
class FCanvas;
class FCanvasRenderContext;
class FMaterial;
class FSceneInterface;
class FSceneView;
class FSceneViewFamily;
class FSceneTextureUniformParameters;
class FMobileSceneTextureUniformParameters;
class FGlobalDistanceFieldParameterData;
struct FMeshBatch;
struct FSynthBenchmarkResults;
struct FSceneTextures;
struct FViewMatrices;
class FShader;
class FShaderMapPointerTable;
class FRDGBuilder;
class FMaterialRenderProxy;
class FGPUScenePrimitiveCollector;
class FViewInfo;
template<typename ShaderType, typename PointerTableType> class TShaderRefBase;
class FSceneUniformBuffer;
class FBatchedPrimitiveParameters;
class ISceneRenderer;
class IStateStreamManager;
class ISceneRenderBuilder;
 
namespace Nanite
{
    struct FResources;
};
 
class FRHITransientTexture;
 
struct FSceneRenderingBlockAllocationTag
{
    static constexpr uint32 BlockSize = 64 * 1024;      // Blocksize used to allocate from
    static constexpr bool AllowOversizedBlocks = true;  // The allocator supports oversized Blocks and will store them in a seperate Block with counter 1
    static constexpr bool RequiresAccurateSize = true;  // GetAllocationSize returning the accurate size of the allocation otherwise it could be relaxed to return the size to the end of the Block
    static constexpr bool InlineBlockAllocation = false;  // Inline or Noinline the BlockAllocation which can have an impact on Performance
    static constexpr const char* TagName = "SceneRenderingAllocator";
 
    using Allocator = TBlockAllocationLockFreeCache<BlockSize, FAlignedAllocator>;
};
 
using FSceneRenderingBulkObjectAllocator = TConcurrentLinearBulkObjectAllocator<FSceneRenderingBlockAllocationTag>;
 
template <typename T>
using FSceneRenderingAllocatorObject = TConcurrentLinearObject<T, FSceneRenderingBlockAllocationTag>;
 
using FSceneRenderingAllocator = TConcurrentLinearAllocator<FSceneRenderingBlockAllocationTag>;
using FSceneRenderingArrayAllocator = TConcurrentLinearArrayAllocator<FSceneRenderingBlockAllocationTag>;
 
using SceneRenderingAllocator = TConcurrentLinearArrayAllocator<FSceneRenderingBlockAllocationTag>;
using SceneRenderingBitArrayAllocator = TConcurrentLinearBitArrayAllocator<FSceneRenderingBlockAllocationTag>;
using SceneRenderingSparseArrayAllocator = TConcurrentLinearSparseArrayAllocator<FSceneRenderingBlockAllocationTag>;
using SceneRenderingSetAllocator = TConcurrentLinearSetAllocator<FSceneRenderingBlockAllocationTag>;
 
struct FPooledRenderTargetDesc
{
public:
 
    FPooledRenderTargetDesc()
        : PackedBits(0)
    {
        check(!IsValid());
    }
 
    static FPooledRenderTargetDesc Create2DDesc(
        FIntPoint InExtent,
        EPixelFormat InFormat,
        const FClearValueBinding& InClearValue,
        ETextureCreateFlags InFlags,
        ETextureCreateFlags InTargetableFlags,
        bool bInForceSeparateTargetAndShaderResource,
        uint8 InNumMips = 1,
        bool InAutowritable = true,
        bool InCreateRTWriteMask = false,
        bool InCreateFmask = false)
    {
        check(InExtent.X);
        check(InExtent.Y);
 
        FPooledRenderTargetDesc NewDesc;
        NewDesc.ClearValue = InClearValue;
        NewDesc.Extent = InExtent;
        NewDesc.Depth = 0;
        NewDesc.ArraySize = 1;
        NewDesc.bIsArray = false;
        NewDesc.bIsCubemap = false;
        NewDesc.NumMips = InNumMips;
        NewDesc.NumSamples = 1;
        NewDesc.Format = InFormat;
        NewDesc.Flags = InFlags | InTargetableFlags;
        NewDesc.DebugName = TEXT("UnknownTexture2D");
        check(NewDesc.Is2DTexture());
        return NewDesc;
    }
 
    static FPooledRenderTargetDesc Create2DArrayDesc(
        FIntPoint InExtent,
        EPixelFormat InFormat,
        const FClearValueBinding& InClearValue,
        ETextureCreateFlags InFlags,
        ETextureCreateFlags InTargetableFlags,
        bool bInForceSeparateTargetAndShaderResource,
        uint16 InArraySize,
        uint8 InNumMips = 1,
        bool InAutowritable = true,
        bool InCreateRTWriteMask = false,
        bool InCreateFmask = false)
    {
        check(InExtent.X);
        check(InExtent.Y);
 
        FPooledRenderTargetDesc NewDesc;
        NewDesc.ClearValue = InClearValue;
        NewDesc.Extent = InExtent;
        NewDesc.Depth = 0;
        NewDesc.ArraySize = InArraySize;
        NewDesc.bIsArray = true;
        NewDesc.bIsCubemap = false;
        NewDesc.NumMips = InNumMips;
        NewDesc.NumSamples = 1;
        NewDesc.Format = InFormat;
        NewDesc.Flags = InFlags | InTargetableFlags;
        NewDesc.DebugName = TEXT("UnknownTexture2DArray");
        check(NewDesc.Is2DTexture());
 
        return NewDesc;
    }
 
    static FPooledRenderTargetDesc CreateVolumeDesc(
        uint32 InSizeX,
        uint32 InSizeY,
        uint16 InSizeZ,
        EPixelFormat InFormat,
        const FClearValueBinding& InClearValue,
        ETextureCreateFlags InFlags,
        ETextureCreateFlags InTargetableFlags,
        bool bInForceSeparateTargetAndShaderResource,
        uint8 InNumMips = 1,
        bool InAutowritable = true)
    {
        check(InSizeX);
        check(InSizeY);
 
        FPooledRenderTargetDesc NewDesc;
        NewDesc.ClearValue = InClearValue;
        NewDesc.Extent = FIntPoint(InSizeX,InSizeY);
        NewDesc.Depth = InSizeZ;
        NewDesc.ArraySize = 1;
        NewDesc.bIsArray = false;
        NewDesc.bIsCubemap = false;
        NewDesc.NumMips = InNumMips;
        NewDesc.NumSamples = 1;
        NewDesc.Format = InFormat;
        NewDesc.Flags = InFlags | InTargetableFlags;
        NewDesc.DebugName = TEXT("UnknownTextureVolume");
        check(NewDesc.Is3DTexture());
        return NewDesc;
    }
 
    static FPooledRenderTargetDesc CreateCubemapDesc(
        uint32 InExtent,
        EPixelFormat InFormat,
        const FClearValueBinding& InClearValue,
        ETextureCreateFlags InFlags,
        ETextureCreateFlags InTargetableFlags,
        bool bInForceSeparateTargetAndShaderResource,
        uint16 InArraySize = 1,
        uint8 InNumMips = 1,
        bool InAutowritable = true)
    {
        check(InExtent);
 
        FPooledRenderTargetDesc NewDesc;
        NewDesc.ClearValue = InClearValue;
        NewDesc.Extent = FIntPoint(InExtent, InExtent);
        NewDesc.Depth = 0;
        NewDesc.ArraySize = InArraySize;
        // Note: this doesn't allow an array of size 1
        NewDesc.bIsArray = InArraySize > 1;
        NewDesc.bIsCubemap = true;
        NewDesc.NumMips = InNumMips;
        NewDesc.NumSamples = 1;
        NewDesc.Format = InFormat;
        NewDesc.Flags = InFlags | InTargetableFlags;
        NewDesc.DebugName = TEXT("UnknownTextureCube");
        check(NewDesc.IsCubemap());
 
        return NewDesc;
    }
 
    static FPooledRenderTargetDesc CreateCubemapArrayDesc(
        uint32 InExtent,
        EPixelFormat InFormat,
        const FClearValueBinding& InClearValue,
        ETextureCreateFlags InFlags,
        ETextureCreateFlags InTargetableFlags,
        bool bInForceSeparateTargetAndShaderResource,
        uint16 InArraySize,
        uint8 InNumMips = 1,
        bool InAutowritable = true)
    {
        check(InExtent);
 
        FPooledRenderTargetDesc NewDesc;
        NewDesc.ClearValue = InClearValue;
        NewDesc.Extent = FIntPoint(InExtent, InExtent);
        NewDesc.Depth = 0;
        NewDesc.ArraySize = InArraySize;
        NewDesc.bIsArray = true;
        NewDesc.bIsCubemap = true;
        NewDesc.NumMips = InNumMips;
        NewDesc.NumSamples = 1;
        NewDesc.Format = InFormat;
        NewDesc.Flags = InFlags | InTargetableFlags;
        NewDesc.DebugName = TEXT("UnknownTextureCubeArray");
        check(NewDesc.IsCubemap());
 
        return NewDesc;
    }
 
    bool Compare(const FPooledRenderTargetDesc& rhs, bool bExact) const
    {
        auto LhsFlags = Flags;
        auto RhsFlags = rhs.Flags;
 
        if (!bExact || !FPlatformMemory::SupportsFastVRAMMemory())
        {
            LhsFlags &= (~TexCreate_FastVRAM);
            RhsFlags &= (~TexCreate_FastVRAM);
        }
        
        return ClearValue == rhs.ClearValue
            && LhsFlags == RhsFlags
            && Format == rhs.Format
            && UAVFormat == rhs.UAVFormat
            && Extent == rhs.Extent
            && Depth == rhs.Depth
            && ArraySize == rhs.ArraySize
            && NumMips == rhs.NumMips
            && NumSamples == rhs.NumSamples
            && PackedBits == rhs.PackedBits
            && FastVRAMPercentage == rhs.FastVRAMPercentage 
            && AliasableFormats == rhs.AliasableFormats;
    }
 
    bool IsCubemap() const
    {
        return bIsCubemap;
    }
 
    bool Is2DTexture() const
    {
        return Extent.X != 0 && Extent.Y != 0 && Depth == 0 && !bIsCubemap;
    }
 
    bool Is3DTexture() const
    {
        return Extent.X != 0 && Extent.Y != 0 && Depth != 0 && !bIsCubemap;
    }
 
    // @return true if this texture is a texture array
    bool IsArray() const
    {
        return bIsArray;
    }
 
    bool IsValid() const
    {
        if(NumSamples != 1)
        {
            if(NumSamples < 1 || NumSamples > 8)
            {
                // D3D11 limitations
                return false;
            }
 
            if(!Is2DTexture())
            {
                return false;
            }
        }
 
        return Extent.X != 0 && NumMips != 0 && NumSamples >=1 && NumSamples <=16 && Format != PF_Unknown
            && (EnumHasAnyFlags(Flags, TexCreate_UAV) || GMaxRHIFeatureLevel >= ERHIFeatureLevel::SM5 || GMaxRHIFeatureLevel == ERHIFeatureLevel::ES3_1);
    }
 
    FIntVector GetSize() const
    {
        return FIntVector(Extent.X, Extent.Y, Depth);
    }
 
    FString GenerateInfoString() const
    {
        const TCHAR* FormatString = GetPixelFormatString(Format);
 
        FString FlagsString = TEXT("");
 
        ETextureCreateFlags LocalFlags = Flags;
 
        if(EnumHasAnyFlags(LocalFlags, TexCreate_RenderTargetable))
        {
            FlagsString += TEXT(" RT");
        }
        if(EnumHasAnyFlags(LocalFlags, TexCreate_SRGB))
        {
            FlagsString += TEXT(" sRGB");
        }
        if(NumSamples > 1)
        {
            FlagsString += FString::Printf(TEXT(" %dxMSAA"), NumSamples);
        }
        if(EnumHasAnyFlags(LocalFlags, TexCreate_UAV))
        {
            FlagsString += TEXT(" UAV");
        }
 
        if(EnumHasAnyFlags(LocalFlags, TexCreate_FastVRAM))
        {
            FlagsString += TEXT(" VRam");
        }
 
        FString ArrayString;
 
        if(IsArray())
        {
            ArrayString = FString::Printf(TEXT("[%d]"), ArraySize);
        }
 
        if(Is2DTexture())
        {
            return FString::Printf(TEXT("(2D%s %dx%d %s%s)"), *ArrayString, Extent.X, Extent.Y, FormatString, *FlagsString);
        }
        else if(Is3DTexture())
        {
            return FString::Printf(TEXT("(3D%s %dx%dx%d %s%s)"), *ArrayString, Extent.X, Extent.Y, Depth, FormatString, *FlagsString);
        }
        else if(IsCubemap())
        {
            return FString::Printf(TEXT("(Cube%s %d %s%s)"), *ArrayString, Extent.X, FormatString, *FlagsString);
        }
        else
        {
            return TEXT("(INVALID)");
        }
    }
 
    // useful when compositing graph takes an input as output format
    void Reset()
    {
        // Usually we don't want to propagate MSAA samples.
        NumSamples = 1;
 
        // Remove UAV flag for rendertargets that don't need it (some formats are incompatible)
        Flags |= TexCreate_RenderTargetable;
        Flags &= (~TexCreate_UAV);
    }
 
    const TCHAR* DebugName = TEXT("UnknownTexture");
    FClearValueBinding ClearValue;
    ETextureCreateFlags Flags = TexCreate_None;
    EPixelFormat Format = PF_Unknown;
    EPixelFormat UAVFormat = PF_Unknown;
    FIntPoint Extent = FIntPoint::ZeroValue;
    uint16 Depth = 0;
    uint16 ArraySize = 1;
    uint8 NumMips = 0;
    uint8 NumSamples = 1;
    uint8 FastVRAMPercentage = 0xFF;
    TArray<EPixelFormat, TInlineAllocator<1>> AliasableFormats;
 
    union
    {
        struct
        {
            uint8 bIsArray : 1;
            uint8 bIsCubemap : 1;
            uint8 bReserved0 : 6;
        };
        uint8 PackedBits;
    };
};
 
struct FSceneRenderTargetItem
{
    FSceneRenderTargetItem() {}
 
    FSceneRenderTargetItem(FRHITexture* InTargetableTexture, FRHITexture* InShaderResourceTexture, FUnorderedAccessViewRHIRef InUAV)
        :   TargetableTexture(InTargetableTexture)
        ,   ShaderResourceTexture(InShaderResourceTexture)
        ,   UAV(InUAV)
    {}
 
    void SafeRelease()
    {
        TargetableTexture.SafeRelease();
        ShaderResourceTexture.SafeRelease();
        UAV.SafeRelease();
    }
 
    bool IsValid() const
    {
        return TargetableTexture != 0
            || ShaderResourceTexture != 0
            || UAV != 0;
    }
 
    FRHITexture* GetRHI() const { return TargetableTexture; }
 
    FTextureRHIRef TargetableTexture;
 
    FTextureRHIRef ShaderResourceTexture;
    
    FUnorderedAccessViewRHIRef UAV;
};
 
struct IPooledRenderTarget
{
    virtual ~IPooledRenderTarget() {}
 
    virtual bool IsFree() const = 0;
    
    virtual const FPooledRenderTargetDesc& GetDesc() const = 0;
    
    virtual uint32 ComputeMemorySize() const = 0;
 
    virtual bool IsTracked() const = 0;
 
    virtual FRHITransientTexture* GetTransientTexture() const { return nullptr; }
 
    // Refcounting
    virtual uint32 AddRef() const = 0;
    virtual uint32 Release() = 0;
    virtual uint32 GetRefCount() const = 0;
 
    FRHITexture* GetRHI() const { return RenderTargetItem.TargetableTexture; }
 
protected:
    FSceneRenderTargetItem RenderTargetItem;
};
 
extern RENDERCORE_API TRefCountPtr<IPooledRenderTarget> CreateRenderTarget(FRHITexture* Texture, const TCHAR* Name);
 
extern RENDERCORE_API bool CacheRenderTarget(FRHITexture* Texture, const TCHAR* Name, TRefCountPtr<IPooledRenderTarget>& OutPooledRenderTarget);
 
 
// use r.DrawDenormalizedQuadMode to override the function call setting (quick way to see if an artifact is caused by this optimization)
enum EDrawRectangleFlags
{
    // Rectangle is created by 2 triangles (diagonal can cause some slightly less efficient shader execution), this is the default as it has no artifacts
    EDRF_Default,
    //
    EDRF_UseTriangleOptimization,
    //
    EDRF_UseTesselatedIndexBuffer
};
 
class FPostOpaqueRenderParameters
{
public:
    FIntRect ViewportRect;
    FMatrix ViewMatrix;
    FMatrix ProjMatrix;
    FRDGTexture* ColorTexture = nullptr;
    FRDGTexture* DepthTexture = nullptr;
    FRDGTexture* NormalTexture = nullptr;
    FRDGTexture* VelocityTexture = nullptr;
    FRDGTexture* SmallDepthTexture = nullptr;
    FRDGBuilder* GraphBuilder = nullptr;
    FRHIUniformBuffer* ViewUniformBuffer = nullptr;
    TRDGUniformBufferRef<FSceneTextureUniformParameters> SceneTexturesUniformParams = nullptr;
    TRDGUniformBufferRef<FMobileSceneTextureUniformParameters> MobileSceneTexturesUniformParams = nullptr;
    const FGlobalDistanceFieldParameterData* GlobalDistanceFieldParams = nullptr;
    void* Uid = nullptr; // A unique identifier for the view.
    const FViewInfo* View = nullptr; 
};
DECLARE_MULTICAST_DELEGATE_OneParam(FOnPostOpaqueRender, class FPostOpaqueRenderParameters&);
typedef FOnPostOpaqueRender::FDelegate FPostOpaqueRenderDelegate;
 
class ICustomVisibilityQuery: public IRefCountedObject
{
public:
    virtual bool Prepare() = 0;
 
    virtual bool IsVisible(int32 VisibilityId, const FBoxSphereBounds& Bounds) = 0;
 
    virtual bool IsThreadsafe()
    {
        return false;
    }
};
 
class ICustomCulling
{
public:
    virtual ICustomVisibilityQuery* CreateQuery (const FSceneView& View) = 0;
};
 
class FPixelInspectorRequest
{
public:
    FPixelInspectorRequest()
    {
        SourceViewportUV = FVector2f(-1, -1);
        BufferIndex = -1;
        RenderingCommandSend = false;
        RequestComplete = true;
        ViewId = -1;
        GBufferPrecision = 1;
        AllowStaticLighting = true;
        FrameCountAfterRenderingCommandSend = 0;
        RequestTickSinceCreation = 0;
        PreExposure = 1;
    }
 
    void SetRequestData(FVector2f SrcViewportUV, int32 TargetBufferIndex, int32 ViewUniqueId, int32 GBufferFormat, bool StaticLightingEnable, float InPreExposure)
    {
        SourceViewportUV = SrcViewportUV;
        BufferIndex = TargetBufferIndex;
        RenderingCommandSend = false;
        RequestComplete = false;
        ViewId = ViewUniqueId;
        GBufferPrecision = GBufferFormat;
        AllowStaticLighting = StaticLightingEnable;
        PreExposure = InPreExposure;
        FrameCountAfterRenderingCommandSend = 0;
        RequestTickSinceCreation = 0;
    }
 
    void MarkSendToRendering() { RenderingCommandSend = true; }
 
    ~FPixelInspectorRequest()
    {
    }
 
    bool RenderingCommandSend;
    int32 FrameCountAfterRenderingCommandSend;
    int32 RequestTickSinceCreation;
    bool RequestComplete;
    FVector2f SourceViewportUV;
    int32 BufferIndex;
    int32 ViewId;
 
    //GPU state at capture time
    int32 GBufferPrecision;
    bool AllowStaticLighting;
    float PreExposure;
};
 
class IPersistentViewUniformBufferExtension
{
public:
    virtual void BeginFrame() {}
    virtual void PrepareView(const FSceneView* View) {}
    virtual void BeginRenderView(const FSceneView* View, bool bShouldWaitForJobs = true) {}
    virtual void EndFrame() {}
};
 
class IScenePrimitiveRenderingContext
{
public:
    virtual ~IScenePrimitiveRenderingContext() {}
    virtual ISceneRenderer* GetSceneRenderer() = 0;
};
 
struct FScenePrimitiveRenderingContextScopeHelper
{
    FScenePrimitiveRenderingContextScopeHelper(IScenePrimitiveRenderingContext* InScenePrimitiveRenderingContext)
    : ScenePrimitiveRenderingContext(InScenePrimitiveRenderingContext)
    {
    }
 
    ~FScenePrimitiveRenderingContextScopeHelper()
    {
        // GPUCULL_TODO: Is new/delete reasonable here?
        delete ScenePrimitiveRenderingContext;
    }
 
    IScenePrimitiveRenderingContext* ScenePrimitiveRenderingContext;
};
 
 
class IRendererModule : public IModuleInterface
{
public:
 
    virtual void BeginRenderingViewFamily(FCanvas* Canvas, FSceneViewFamily* ViewFamily) = 0;
    
    virtual void CreateAndInitSingleView(FRHICommandListImmediate& RHICmdList, class FSceneViewFamily* ViewFamily, const struct FSceneViewInitOptions* ViewInitOptions) = 0;
 
    virtual FSceneInterface* AllocateScene(UWorld* World, bool bInRequiresHitProxies, bool bCreateFXSystem, ERHIFeatureLevel::Type InFeatureLevel) = 0;
    
    virtual void RemoveScene(FSceneInterface* Scene) = 0;
 
#if WITH_STATE_STREAM
    virtual IStateStreamManager* AllocateStateStream(UWorld* World) = 0;
    virtual void FreeStateStream(IStateStreamManager* Manager) = 0;
#endif
 
    virtual void UpdateStaticDrawLists() = 0;
 
    virtual void UpdateStaticDrawListsForMaterials(const TArray<const FMaterial*>& Materials) = 0;
 
    virtual class FSceneViewStateInterface* AllocateViewState(ERHIFeatureLevel::Type FeatureLevel) = 0;
    virtual class FSceneViewStateInterface* AllocateViewState(ERHIFeatureLevel::Type FeatureLevel, FSceneViewStateInterface* ShareOriginTarget) = 0;
 
    virtual uint32 GetNumDynamicLightsAffectingPrimitive(const class FPrimitiveSceneInfo* PrimitiveSceneInfo,const class FLightCacheInterface* LCI) = 0;
 
    virtual void OnWorldCleanup(UWorld* World, bool bSessionEnded, bool bCleanupResources, bool bWorldChanged) = 0;
 
    virtual void InitializeSystemTextures(FRHICommandListImmediate& RHICmdList) = 0;
 
    virtual FSceneUniformBuffer* CreateSinglePrimitiveSceneUniformBuffer(FRDGBuilder& GraphBuilder, ERHIFeatureLevel::Type FeatureLevel, FMeshBatch& Mesh) = 0;
    virtual FSceneUniformBuffer* CreateSinglePrimitiveSceneUniformBuffer(FRDGBuilder& GraphBuilder, const FViewInfo& SceneView, FMeshBatch& Mesh) = 0;
    virtual TRDGUniformBufferRef<FBatchedPrimitiveParameters> CreateSinglePrimitiveUniformView(FRDGBuilder& GraphBuilder, ERHIFeatureLevel::Type FeatureLevel, EShaderPlatform ShaderPlatform, FMeshBatch& Mesh) = 0;
    virtual TRDGUniformBufferRef<FBatchedPrimitiveParameters> CreateSinglePrimitiveUniformView(FRDGBuilder& GraphBuilder, const FViewInfo& SceneView, FMeshBatch& Mesh) = 0;
 
    virtual void DrawTileMesh(FCanvasRenderContext& RenderContext, struct FMeshPassProcessorRenderState& DrawRenderState, const FSceneView& View, FMeshBatch& Mesh, bool bIsHitTesting, const class FHitProxyId& HitProxyId, bool bUse128bitRT = false) = 0;
 
    virtual const TSet<FSceneInterface*>& GetAllocatedScenes() = 0;
 
    virtual void DebugLogOnCrash() = 0;
 
    // @param WorkScale >0, 10 for normal precision and runtime of less than a second
    virtual void GPUBenchmark(FSynthBenchmarkResults& InOut, float WorkScale = 10.0f) = 0;
 
    virtual void ExecVisualizeTextureCmd(const FString& Cmd) = 0;
 
    virtual void UpdateMapNeedsLightingFullyRebuiltState(UWorld* World) = 0;
 
    virtual void DrawRectangle(
        FRHICommandList& RHICmdList,
        float X,
        float Y,
        float SizeX,
        float SizeY,
        float U,
        float V,
        float SizeU,
        float SizeV,
        FIntPoint TargetSize,
        FIntPoint TextureSize,
        const TShaderRefBase<FShader, FShaderMapPointerTable>& VertexShader,
        EDrawRectangleFlags Flags = EDRF_Default
        ) = 0;
 
    virtual void RegisterCustomCullingImpl(ICustomCulling* impl) = 0;
    virtual void UnregisterCustomCullingImpl(ICustomCulling* impl) = 0;
 
    virtual FDelegateHandle RegisterPostOpaqueRenderDelegate(const FPostOpaqueRenderDelegate& PostOpaqueRenderDelegate) = 0;
    virtual void RemovePostOpaqueRenderDelegate(FDelegateHandle PostOpaqueRenderDelegate) = 0;
    virtual FDelegateHandle RegisterOverlayRenderDelegate(const FPostOpaqueRenderDelegate& OverlayRenderDelegate) = 0;
    virtual void RemoveOverlayRenderDelegate(FDelegateHandle OverlayRenderDelegate) = 0;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnResolvedSceneColor, FRDGBuilder& /*GraphBuilder*/, const FSceneTextures& /*SceneTextures*/);
 
    virtual FOnResolvedSceneColor& GetResolvedSceneColorCallbacks() = 0;
 
    virtual void PostRenderAllViewports() = 0;
 
    virtual void PerFrameCleanupIfSkipRenderer() = 0;
 
    virtual class IMaterialCacheTagProvider* GetMaterialCacheTagProvider() = 0;
 
    virtual IAllocatedVirtualTexture* AllocateVirtualTexture(FRHICommandListBase& RHICmdList, const FAllocatedVTDescription& Desc) = 0;
    RENDERCORE_API IAllocatedVirtualTexture* AllocateVirtualTexture(const FAllocatedVTDescription& Desc);
 
    virtual void DestroyVirtualTexture(IAllocatedVirtualTexture* AllocatedVT) = 0;
 
    virtual IAdaptiveVirtualTexture* AllocateAdaptiveVirtualTexture(FRHICommandListBase& RHICmdList, const FAdaptiveVTDescription& AdaptiveVTDesc, const FAllocatedVTDescription& AllocatedVTDesc) = 0;
    RENDERCORE_API IAdaptiveVirtualTexture* AllocateAdaptiveVirtualTexture(const FAdaptiveVTDescription& AdaptiveVTDesc, const FAllocatedVTDescription& AllocatedVTDesc);
    virtual void DestroyAdaptiveVirtualTexture(IAdaptiveVirtualTexture* AdaptiveVT) = 0;
 
    virtual FVirtualTextureProducerHandle RegisterVirtualTextureProducer(FRHICommandListBase& RHICmdList, const FVTProducerDescription& Desc, IVirtualTexture* Producer) = 0;
    RENDERCORE_API FVirtualTextureProducerHandle RegisterVirtualTextureProducer(const FVTProducerDescription& Desc, IVirtualTexture* Producer);
 
    virtual void ReleaseVirtualTextureProducer(const FVirtualTextureProducerHandle& Handle) = 0;
    virtual void AddVirtualTextureProducerDestroyedCallback(const FVirtualTextureProducerHandle& Handle, FVTProducerDestroyedFunction* Function, void* Baton) = 0;
    virtual uint32 RemoveAllVirtualTextureProducerDestroyedCallbacks(const void* Baton) = 0;
    virtual void ReleaseVirtualTexturePendingResources() = 0;
 
    virtual IVirtualTexture* FindProducer(const FVirtualTextureProducerHandle& Handle) = 0;
 
    virtual void RequestVirtualTextureTiles(const FVector2D& InScreenSpaceSize, int32 InMipLevel) = 0;
    virtual void RequestVirtualTextureTiles(const FMaterialRenderProxy* InMaterialRenderProxy, const FVector2D& InScreenSpaceSize, ERHIFeatureLevel::Type InFeatureLevel) = 0;
 
    virtual void RequestVirtualTextureTiles(IAllocatedVirtualTexture* AllocatedVT, const FVector2D& InScreenSpaceSize, const FVector2D& InViewportPosition, const FVector2D& InViewportSize, const FVector2D& InUV0, const FVector2D& InUV1, int32 InMipLevel) = 0;
 
    virtual void LoadPendingVirtualTextureTiles(FRHICommandListImmediate& RHICmdList, ERHIFeatureLevel::Type FeatureLevel) = 0;
    
    virtual void LockVirtualTextureTiles(FVirtualTextureProducerHandle ProducerHandle, int32 InMipLevel) = 0;
 
    virtual void SetVirtualTextureRequestRecordBuffer(uint64 Handle) = 0;
    virtual uint64 GetVirtualTextureRequestRecordBuffer(TSet<uint64>& OutPageRequests) = 0;
    virtual void RequestVirtualTextureTiles(TArray<uint64>&& InPageRequests) = 0;
 
    virtual void FlushVirtualTextureCache() = 0;
    virtual void FlushVirtualTextureCache(IAllocatedVirtualTexture* AllocatedVT, const FVector2f& InUV0, const FVector2f& InUV1) = 0;
 
    virtual void SyncVirtualTextureUpdates(FRHICommandListImmediate& RHICmdList, ERHIFeatureLevel::Type FeatureLevel) = 0;
 
    virtual void SetNaniteRequestRecordBuffer(uint64 Handle) = 0;
    virtual uint64 GetNaniteRequestRecordBuffer(TArray<uint32>& OutRequestData) = 0;
    virtual void RequestNanitePages(TArrayView<uint32> InRequestData) = 0;
 
    virtual void PrefetchNaniteResource(const Nanite::FResources* Resource, uint32 NumFramesUntilRender) = 0;
 
    UE_DEPRECATED(5.4, "IPersistentViewUniformBufferExtension will be removed in a future version.")
    virtual void RegisterPersistentViewUniformBufferExtension(IPersistentViewUniformBufferExtension* Extension) = 0;
 
    virtual IScenePrimitiveRenderingContext* BeginScenePrimitiveRendering(FRDGBuilder& GraphBuilder, FSceneViewFamily* ViewFamily) = 0;
    virtual IScenePrimitiveRenderingContext* BeginScenePrimitiveRendering(FRDGBuilder& GraphBuilder, FSceneInterface& Scene) = 0;
 
    virtual void InvalidatePathTracedOutput(PathTracing::EInvalidateReason InvalidateReason = PathTracing::EInvalidateReason::Uncategorized) = 0;
 
    virtual void BeginRenderingViewFamilies(FCanvas* Canvas, TConstArrayView<FSceneViewFamily*> ViewFamilies) = 0;
 
    virtual void ResetSceneTextureExtentHistory() = 0;
 
    virtual const FViewMatrices& GetPreviousViewMatrices(const FSceneView& View) = 0;
    virtual const FGlobalDistanceFieldParameterData* GetGlobalDistanceFieldParameterData(const FSceneView& View) = 0;
    virtual void RequestStaticMeshUpdate(FPrimitiveSceneInfo* Info) = 0;
    virtual void AddMeshBatchToGPUScene(FGPUScenePrimitiveCollector* Collector, FMeshBatch& MeshBatch) = 0;
 
    virtual TUniquePtr<ISceneRenderBuilder> CreateSceneRenderBuilder(FSceneInterface* Scene) = 0;
};