RenderGraphResources.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Math/NumericLimits.h"
#include "Math/UnrealMathSSE.h"
#include "Misc/AssertionMacros.h"
#include "Misc/EnumClassFlags.h"
#include "PixelFormat.h"
#include "RHI.h"
#include "RHIDefinitions.h"
#include "RHIResources.h"
#include "RHITransientResourceAllocator.h"
#include "RenderGraphAllocator.h"
#include "RenderGraphDefinitions.h"
#include "RenderGraphParameter.h"
#include "RenderGraphTextureSubresource.h"
#include "RendererInterface.h"
#include "ShaderParameterMacros.h"
#include "Templates/Function.h"
#include "Templates/RefCounting.h"
#include "Templates/TypeHash.h"
#include "Templates/UnrealTemplate.h"
 
class FRDGBarrierBatchBegin;
class FRDGBarrierValidation;
class FRDGBuffer;
class FRDGBufferPool;
class FRDGBuilder;
class FRDGResourceDumpContext;
class FRDGTextureUAV;
class FRDGTrace;
class FRDGUserValidation;
class FRHITransientBuffer;
class FRHITransientTexture;
class FRenderTargetPool;
class FShaderParametersMetadata;
struct FPooledRenderTarget;
 
struct FRDGProducerState
{
    FRDGPass* Pass = nullptr;
    FRDGPass* PassIfSkipUAVBarrier = nullptr;
    FRDGPass* PassIfReadAccess = nullptr;
    ERHIAccess Access = ERHIAccess::Unknown;
    FRDGViewHandle NoUAVBarrierHandle;
};
 
enum class ERDGBarrierLocation : uint8
{
    Prologue,
 
    Epilogue
};
 
using FRDGProducerStatesByPipeline = TRHIPipelineArray<FRDGProducerState>;
 
struct FRDGSubresourceState
{
    static bool IsTransitionRequired(const FRDGSubresourceState& Previous, const FRDGSubresourceState& Next);
 
    static bool IsMergeAllowed(ERDGViewableResourceType ResourceType, const FRDGSubresourceState& Previous, const FRDGSubresourceState& Next);
 
    FRDGSubresourceState() = default;
 
    explicit FRDGSubresourceState(ERHIAccess InAccess)
        : Access(InAccess)
    {}
 
    explicit FRDGSubresourceState(ERHIPipeline Pipeline, FRDGPassHandle PassHandle)
    {
        SetPass(Pipeline, PassHandle);
    }
 
    void SetPass(ERHIPipeline Pipeline, FRDGPassHandle PassHandle);
 
    void Validate();
 
    bool IsUsedBy(ERHIPipeline Pipeline) const;
 
    FRDGPassHandle GetLastPass() const;
 
    FRDGPassHandle GetFirstPass() const;
 
    ERHIPipeline GetPipelines() const;
 
    ERHIAccess Access = ERHIAccess::Unknown;
 
    FRDGPassHandlesByPipeline FirstPass;
 
    FRDGPassHandlesByPipeline LastPass;
 
    FRDGViewUniqueFilter NoUAVBarrierFilter;
 
    FRDGBufferReservedCommitHandle ReservedCommitHandle;
 
    EResourceTransitionFlags Flags = EResourceTransitionFlags::None;
 
    ERDGBarrierLocation BarrierLocation = ERDGBarrierLocation::Prologue;
};
 
using FRDGTextureSubresourceState = TRDGTextureSubresourceArray<FRDGSubresourceState*, FRDGArrayAllocator>;
 
class FRDGResource
{
public:
    FRDGResource(const FRDGResource&) = delete;
    virtual ~FRDGResource() = default;
 
    // Name of the resource for debugging purpose.
    const TCHAR* const Name = nullptr;
 
 
#if RDG_ENABLE_DEBUG
    RENDERCORE_API virtual void MarkResourceAsUsed();
#else
    inline  void MarkResourceAsUsed() {}
#endif
 
    FRHIResource* GetRHI() const
    {
        IF_RDG_ENABLE_DEBUG(ValidateRHIAccess());
        return ResourceRHI;
    }
 
 
protected:
    FRDGResource(const TCHAR* InName)
        : Name(InName)
#if RDG_ENABLE_DEBUG
        , bAllowRHIAccess(0)
#endif
    {}
 
    FRHIResource* GetRHIUnchecked() const
    {
        return ResourceRHI;
    }
 
    bool HasRHI() const
    {
        return ResourceRHI != nullptr;
    }
 
    FRHIResource* ResourceRHI = nullptr;
 
#if RDG_ENABLE_DEBUG
    RENDERCORE_API void ValidateRHIAccess() const;
#endif
 
private:
#if RDG_ENABLE_DEBUG
    uint8 bAllowRHIAccess : 1;
#endif
 
    friend FRDGBuilder;
    friend FRDGUserValidation;
    friend FRDGBarrierValidation;
};
 
class FRDGUniformBuffer
    : public FRDGResource
{
public:
 
    RENDERCORE_API virtual ~FRDGUniformBuffer();
 
    inline const FRDGParameterStruct& GetParameters() const
    {
        return ParameterStruct;
    }
 
    inline const TCHAR* GetLayoutName() const
    {
        return *ParameterStruct.GetLayout().GetDebugName();
    }
 
#if RDG_ENABLE_DEBUG
    RENDERCORE_API void MarkResourceAsUsed() override;
#else
    inline void MarkResourceAsUsed() {}
#endif
 
 
    FRHIUniformBuffer* GetRHI() const
    {
        return static_cast<FRHIUniformBuffer*>(FRDGResource::GetRHI());
    }
 
 
protected:
    template <typename TParameterStruct>
    explicit FRDGUniformBuffer(const TParameterStruct* InParameters, const TCHAR* InName)
        : FRDGResource(InName)
        , ParameterStruct(InParameters, TParameterStruct::FTypeInfo::GetStructMetadata())
    {}
 
private:
    FRHIUniformBuffer* GetRHIUnchecked() const
    {
        return static_cast<FRHIUniformBuffer*>(FRDGResource::GetRHIUnchecked());
    }
 
    RENDERCORE_API void InitRHI();
 
    const FRDGParameterStruct ParameterStruct;
    TRefCountPtr<FRHIUniformBuffer> UniformBufferRHI;
    FRDGUniformBufferHandle Handle;
    bool bExternal = false;
 
    friend FRDGBuilder;
    friend FRDGUniformBufferRegistry;
    friend FRDGAllocator;
};
 
template <typename ParameterStructType>
class TRDGUniformBuffer : public FRDGUniformBuffer
{
public:
    virtual ~TRDGUniformBuffer() {};
 
    inline const TRDGParameterStruct<ParameterStructType>& GetParameters() const
    {
        return static_cast<const TRDGParameterStruct<ParameterStructType>&>(FRDGUniformBuffer::GetParameters());
    }
 
    inline const ParameterStructType* GetContents() const
    {
        return Parameters;
    }
 
    inline TUniformBufferRef<ParameterStructType> GetRHIRef() const
    {
        return TUniformBufferRef<ParameterStructType>(GetRHI());
    }
 
    inline const ParameterStructType* operator->() const
    {
        return Parameters;
    }
 
private:
    explicit TRDGUniformBuffer(const ParameterStructType* InParameters, const TCHAR* InName)
        : FRDGUniformBuffer(InParameters, InName)
        , Parameters(InParameters)
    {}
 
    const ParameterStructType* Parameters;
 
    friend FRDGBuilder;
    friend FRDGUniformBufferRegistry;
    friend FRDGAllocator;
};
 
class FRDGViewableResource
    : public FRDGResource
{
public:
#if RHI_USE_RESOURCE_DEBUG_NAME
    virtual ~FRDGViewableResource()
    {
        if (bHeapAllocatedDebugName)
        {
            delete[] Name;
        }
    }
#endif
 
    const ERDGViewableResourceType Type;
 
    bool IsExternal() const
    {
        return bExternal;
    }
 
    bool IsExtracted() const
    {
        return bExtracted;
    }
 
    bool HasBeenProduced() const
    {
        return bProduced;
    }
 
    void SetOwnerName(const FName& InOwnerName)
    {
#if RHI_ENABLE_RESOURCE_INFO
        OwnerName = InOwnerName;
#endif
    }
 
#if RHI_USE_RESOURCE_DEBUG_NAME
    inline void SetDebugNameIsHeapAllocated()
    {
        bHeapAllocatedDebugName = 1;
    }
#endif
 
    inline bool IsDebugNameHeapAllocated() const
    {
#if RHI_USE_RESOURCE_DEBUG_NAME
        return bHeapAllocatedDebugName;
#else
        return false;
#endif
    }
 
protected:
    RENDERCORE_API FRDGViewableResource(const TCHAR* InName, ERDGViewableResourceType InType, bool bSkipTracking, bool bImmediateFirstBarrier);
 
    bool IsCullRoot() const
    {
        return bExternal || bExtracted;
    }
 
    static const ERHIAccess DefaultEpilogueAccess = ERHIAccess::SRVMask;
 
    enum class ETransientExtractionHint : uint8
    {
        None,
        Disable,
        Enable
    };
 
    enum class EAccessMode : uint8
    {
        Internal,
        External
    };
 
    uint8 bExternal : 1;
 
    uint8 bExtracted : 1;
 
    uint8 bProduced : 1;
 
    uint8 bTransient : 1;
 
    uint8 bForceNonTransient : 1;
 
    uint8 bSkipLastTransition : 1;
 
    uint8 bSplitFirstTransition : 1;
 
    uint8 bQueuedForUpload : 1;
 
    uint8 bCollectForAllocate : 1;
 
#if RHI_USE_RESOURCE_DEBUG_NAME
    uint8 bHeapAllocatedDebugName : 1;
#endif
 
#if RDG_ENABLE_DEBUG
    uint8 bClobbered : 1;
#endif
 
    ETransientExtractionHint TransientExtractionHint;
 
    struct FAccessModeState
    {
        bool IsExternalAccess() const { return ActiveMode == EAccessMode::External; }
 
        FAccessModeState()
            : Pipelines(ERHIPipeline::None)
            , Mode(EAccessMode::Internal)
            , bLocked(0)
            , bQueued(0)
        {}
 
        ERHIAccess          Access = ERHIAccess::None;
        ERHIPipeline        Pipelines : 2;
        EAccessMode         Mode : 1;
        uint8               bLocked : 1;
        uint8               bQueued : 1;
 
        EAccessMode ActiveMode = EAccessMode::Internal;
 
    } AccessModeState;
 
    FRDGPassHandle AcquirePass;
    FRDGPassHandle DiscardPass;
    FRDGPassHandle FirstPass;
    FRDGPassHandlesByPipeline LastPasses;
 
    uint32 ReferenceCount;
 
    uint32 PassStateIndex = 0;
 
    TArrayView<const FRHITransientAliasingOverlap> AliasingOverlaps;
 
    ERHIAccess EpilogueAccess = DefaultEpilogueAccess;
 
private:
    static const uint32 DeallocatedReferenceCount = ~0;
 
    void SetRHI(FRHIResource* Resource)
    {
        check(!ResourceRHI);
        ResourceRHI = Resource;
 
    #if RHI_ENABLE_RESOURCE_INFO
        ResourceRHI->SetOwnerName(OwnerName);
    #endif
    }
 
    void SetExternalAccessMode(ERHIAccess InAccess, ERHIPipeline InPipelines)
    {
        check(!AccessModeState.bLocked);
 
        AccessModeState.Mode = EAccessMode::External;
        AccessModeState.Access = InAccess;
        AccessModeState.Pipelines = InPipelines;
 
        EpilogueAccess = InAccess;
    }
 
#if RHI_ENABLE_RESOURCE_INFO
    FName OwnerName;    // For RHI resource tracking
#endif
 
#if RDG_ENABLE_TRACE
    TArray<FRDGPassHandle, FRDGArrayAllocator> TracePasses;
    uint32 TraceOrder = 0;
#endif
 
    friend bool IsExtendedLifetimeResource(FRDGViewableResource*);
 
    friend FRDGBuilder;
    friend FRDGUserValidation;
    friend FRDGBarrierBatchBegin;
    friend FRDGResourceDumpContext;
    friend FRDGTrace;
    friend FRDGPass;
};
 
class FRDGView
    : public FRDGResource
{
public:
    const ERDGViewType Type;
 
    virtual FRDGViewableResource* GetParent() const = 0;
 
    ERDGViewableResourceType GetParentType() const
    {
        return ::GetParentType(Type);
    }
 
    FRDGViewHandle GetHandle() const
    {
        return Handle;
    }
 
protected:
    FRDGView(const TCHAR* Name, ERDGViewType InType)
        : FRDGResource(Name)
        , Type(InType)
    {}
 
private:
    FRDGViewHandle Handle;
    FRDGPassHandle LastPass;
 
    friend FRDGBuilder;
    friend FRDGViewRegistry;
    friend FRDGAllocator;
};
 
inline FRDGTextureDesc Translate(const FPooledRenderTargetDesc& InDesc);
 
inline FPooledRenderTargetDesc Translate(const FRHITextureDesc& InDesc);
 
class FRDGPooledTexture final
    : public FRefCountBase
{
public:
    FRDGPooledTexture(FRHITexture* InTexture)
        : Texture(InTexture)
    {
        Fences.Emplace();
    }
 
    inline FRHIUnorderedAccessView* GetOrCreateUAV(FRHICommandListBase& RHICmdList, const FRHITextureUAVCreateInfo& UAVDesc) { return ViewCache.GetOrCreateUAV(RHICmdList, Texture, UAVDesc); }
 
    inline FRHIShaderResourceView* GetOrCreateSRV(FRHICommandListBase& RHICmdList, const FRHITextureSRVCreateInfo& SRVDesc) { return ViewCache.GetOrCreateSRV(RHICmdList, Texture, SRVDesc); }
 
    UE_DEPRECATED(5.3, "GetOrCreateUAV now requires a command list.")
    inline FRHIUnorderedAccessView* GetOrCreateUAV(const FRHITextureUAVCreateInfo& UAVDesc) { return ViewCache.GetOrCreateUAV(FRHICommandListImmediate::Get(), Texture, UAVDesc); }
 
    UE_DEPRECATED(5.3, "GetOrCreateSRV now requires a command list.")
    inline FRHIShaderResourceView* GetOrCreateSRV(const FRHITextureSRVCreateInfo& SRVDesc) { return ViewCache.GetOrCreateSRV(FRHICommandListImmediate::Get(), Texture, SRVDesc); }
 
    inline FRHITexture* GetRHI() const { return Texture; }
 
private:
    TRefCountPtr<FRHITexture> Texture;
    FRHITextureViewCache ViewCache;
    TOptional<FRHITransientAllocationFences> Fences;
 
    friend FRDGBuilder;
    friend FRenderTargetPool;
};
 
class FRDGTexture final
    : public FRDGViewableResource
{
public:
    static const ERDGViewableResourceType StaticType = ERDGViewableResourceType::Texture;
 
    const FRDGTextureDesc Desc;
    const ERDGTextureFlags Flags;
 
 
    inline FRHITexture* GetRHI() const
    {
        return static_cast<FRHITexture*>(FRDGResource::GetRHI());
    }
 
 
    inline FRDGTextureHandle GetHandle() const
    {
        return Handle;
    }
 
    inline FRDGTextureSubresourceLayout GetSubresourceLayout() const
    {
        return Layout;
    }
 
    inline FRDGTextureSubresourceRange GetSubresourceRange() const
    {
        return WholeRange;
    }
 
    inline uint32 GetSubresourceCount() const
    {
        return SubresourceCount;
    }
 
    inline FRDGTextureSubresource GetSubresource(uint32 SubresourceIndex) const
    {
        return Layout.GetSubresource(SubresourceIndex);
    }
 
    RENDERCORE_API FRDGTextureSubresourceRange GetSubresourceRangeSRV() const;
 
    bool IsCulled() const
    {
        return ReferenceCount == 0;
    }
 
private:
    RENDERCORE_API FRDGTexture(const TCHAR* InName, const FRDGTextureDesc& InDesc, ERDGTextureFlags InFlags);
 
    FRHITexture* GetRHIUnchecked() const
    {
        return static_cast<FRHITexture*>(FRDGResource::GetRHIUnchecked());
    }
 
    FRDGTextureHandle Handle;
 
    FRDGTextureHandle PreviousOwner;
    FRDGTextureHandle NextOwner;
 
    FRDGTextureSubresourceLayout Layout;
    FRDGTextureSubresourceRange  WholeRange;
    const uint16 SubresourceCount;
 
    FRDGTextureSubresourceState State;
 
    FRDGTextureSubresourceState FirstState;
 
    FRDGTextureSubresourceState MergeState;
 
    TRDGTextureSubresourceArray<FRDGProducerStatesByPipeline, FRDGArrayAllocator> LastProducers;
 
    IPooledRenderTarget* RenderTarget = nullptr;
 
    FRHITransientTexture* TransientTexture = nullptr;
 
    FRHITextureViewCache* ViewCache = nullptr;
 
    TRefCountPtr<IPooledRenderTarget> Allocation;
 
#if SUPPORTS_VISUALIZE_TEXTURE
    FIntPoint VisualizeTextureExtent = { 0, 0 };
public:
    inline void EncloseVisualizeExtent(const FIntPoint& Point)
    {
        VisualizeTextureExtent.X = FMath::Max(VisualizeTextureExtent.X, Point.X);
        VisualizeTextureExtent.Y = FMath::Max(VisualizeTextureExtent.Y, Point.Y);
    }
    inline FIntPoint GetVisualizeExtent() const
    {
        return VisualizeTextureExtent;
    }
private:
#else
public:
    inline void EncloseVisualizeExtent(const FIntPoint& Point) {}
private:
#endif
 
    friend FRDGBuilder;
    friend FRDGUserValidation;
    friend FRDGBarrierValidation;
    friend FRDGTextureRegistry;
    friend FRDGAllocator;
    friend FPooledRenderTarget;
    friend FRDGTrace;
    friend FRDGTextureUAV;
};
 
class FRDGShaderResourceView
    : public FRDGView
{
public:
    FRHIShaderResourceView* GetRHI() const
    {
        return static_cast<FRHIShaderResourceView*>(FRDGResource::GetRHI());
    }
 
protected:
    FRDGShaderResourceView(const TCHAR* InName, ERDGViewType InType)
        : FRDGView(InName, InType)
    {}
 
    FRHIShaderResourceView* GetRHIUnchecked() const
    {
        return static_cast<FRHIShaderResourceView*>(FRDGResource::GetRHIUnchecked());
    }
};
 
class FRDGUnorderedAccessView
    : public FRDGView
{
public:
    const ERDGUnorderedAccessViewFlags Flags;
 
    FRHIUnorderedAccessView* GetRHI() const
    {
        return static_cast<FRHIUnorderedAccessView*>(FRDGResource::GetRHI());
    }
 
protected:
    FRDGUnorderedAccessView(const TCHAR* InName, ERDGViewType InType, ERDGUnorderedAccessViewFlags InFlags)
        : FRDGView(InName, InType)
        , Flags(InFlags)
    {}
 
    FRHIUnorderedAccessView* GetRHIUnchecked() const
    {
        return static_cast<FRHIUnorderedAccessView*>(FRDGResource::GetRHIUnchecked());
    }
};
 
class FRDGTextureSRVDesc final
    : public FRHITextureSRVCreateInfo
{
public:
    FRDGTextureSRVDesc() = default;
 
    FRDGTextureSRVDesc(FRDGTexture* InTexture)
    {
        Texture = InTexture;
        NumMipLevels = InTexture->Desc.NumMips;
        if (InTexture->Desc.IsTextureArray())
        {
            NumArraySlices = InTexture->Desc.ArraySize;
        }
    }
 
    static FRDGTextureSRVDesc Create(FRDGTextureRef Texture)
    {
        return FRDGTextureSRVDesc(Texture);
    }
 
    static FRDGTextureSRVDesc CreateForMipLevel(FRDGTextureRef Texture, int32 MipLevel)
    {
        check(MipLevel >= -1 && MipLevel <= TNumericLimits<int8>::Max());
        FRDGTextureSRVDesc Desc = FRDGTextureSRVDesc::Create(Texture);
        Desc.MipLevel = (int8)MipLevel;
        Desc.NumMipLevels = 1;
        return Desc;
    }
 
    static FRDGTextureSRVDesc CreateForSlice(FRDGTextureRef Texture, int32 SliceIndex)
    {
        check(Texture);
        check(Texture->Desc.Dimension == ETextureDimension::Texture2DArray);
        check(SliceIndex >= 0 && SliceIndex < Texture->Desc.ArraySize);
        
        FRDGTextureSRVDesc Desc = FRDGTextureSRVDesc::Create(Texture);
        Desc.FirstArraySlice = (uint16)SliceIndex;
        Desc.NumArraySlices = 1;
        Desc.DimensionOverride = ETextureDimension::Texture2D;
        
        return Desc;
    }
 
    static FRDGTextureSRVDesc CreateWithPixelFormat(FRDGTextureRef Texture, EPixelFormat PixelFormat)
    {
        FRDGTextureSRVDesc Desc = FRDGTextureSRVDesc::Create(Texture);
        Desc.Format = PixelFormat;
        return Desc;
    }
 
    static FRDGTextureSRVDesc CreateForMetaData(FRDGTextureRef Texture, ERDGTextureMetaDataAccess MetaData)
    {
        FRDGTextureSRVDesc Desc = FRDGTextureSRVDesc::Create(Texture);
        Desc.MetaData = MetaData;
        return Desc;
    }
 
    bool operator == (const FRDGTextureSRVDesc& Other) const
    {
        return Texture == Other.Texture && FRHITextureSRVCreateInfo::operator==(Other);
    }
 
    bool operator != (const FRDGTextureSRVDesc& Other) const
    {
        return !(*this == Other);
    }
 
    friend uint32 GetTypeHash(const FRDGTextureSRVDesc& Desc)
    {
        return HashCombine(GetTypeHash(static_cast<const FRHITextureSRVCreateInfo&>(Desc)), GetTypeHash(Desc.Texture));
    }
 
    bool IsValid() const
    {
        if (!Texture)
        {
            return false;
        }
        return FRHITextureSRVCreateInfo::Validate(Texture->Desc, *this, Texture->Name, /* bFatal = */ false);
    }
 
    FRDGTextureRef Texture = nullptr;
};
 
class FRDGTextureSRV final
    : public FRDGShaderResourceView
{
public:
    static const ERDGViewType StaticType = ERDGViewType::TextureSRV;
 
    const FRDGTextureSRVDesc Desc;
 
    FRDGTextureRef GetParent() const override
    {
        return Desc.Texture;
    }
 
    FRDGTextureSubresourceRange GetSubresourceRange() const;
 
private:
    FRDGTextureSRV(const TCHAR* InName, const FRDGTextureSRVDesc& InDesc)
        : FRDGShaderResourceView(InName, ERDGViewType::TextureSRV)
        , Desc(InDesc)
    {}
 
    friend FRDGBuilder;
    friend FRDGViewRegistry;
    friend FRDGAllocator;
};
 
class FRDGTextureUAVDesc final
    : public FRHITextureUAVCreateInfo
{
public:
    FRDGTextureUAVDesc() = default;
 
    FRDGTextureUAVDesc(FRDGTextureRef InTexture, uint8 InMipLevel = 0, EPixelFormat InFormat = PF_Unknown, uint16 InFirstArraySlice = 0, uint16 InNumArraySlices = 0)
        : FRHITextureUAVCreateInfo(InMipLevel, InFormat != PF_Unknown ? InFormat : InTexture->Desc.UAVFormat, InFirstArraySlice, InNumArraySlices)
        , Texture(InTexture)
    {}
 
    static FRDGTextureUAVDesc CreateForMetaData(FRDGTextureRef Texture, ERDGTextureMetaDataAccess MetaData)
    {
        FRDGTextureUAVDesc Desc = FRDGTextureUAVDesc(Texture, 0);
        Desc.MetaData = MetaData;
        return Desc;
    }
 
    bool operator == (const FRDGTextureUAVDesc& Other) const
    {
        return Texture == Other.Texture && FRHITextureUAVCreateInfo::operator==(Other);
    }
 
    bool operator != (const FRDGTextureUAVDesc& Other) const
    {
        return !(*this == Other);
    }
 
    friend uint32 GetTypeHash(const FRDGTextureUAVDesc& Desc)
    {
        return HashCombine(GetTypeHash(static_cast<const FRHITextureUAVCreateInfo&>(Desc)), GetTypeHash(Desc.Texture));
    }
 
    FRDGTextureRef Texture = nullptr;
};
 
class FRDGTextureUAV final
    : public FRDGUnorderedAccessView
{
public:
    static const ERDGViewType StaticType = ERDGViewType::TextureUAV;
 
    const FRDGTextureUAVDesc Desc;
 
    FRDGTextureRef GetParent() const override
    {
        return Desc.Texture;
    }
 
    // Can be used instead of GetParent()->GetRHI() to access the underlying texture for a UAV resource in a Pass, without triggering
    // validation errors.  The RDG validation logic only flags the UAV as accessible, not the parent texture.
    FRHITexture* GetParentRHI() const
    {
        IF_RDG_ENABLE_DEBUG(ValidateRHIAccess());
        return Desc.Texture->GetRHIUnchecked();
    }
 
    FRDGTextureSubresourceRange GetSubresourceRange() const;
 
private:
    FRDGTextureUAV(const TCHAR* InName, const FRDGTextureUAVDesc& InDesc, ERDGUnorderedAccessViewFlags InFlags)
        : FRDGUnorderedAccessView(InName, ERDGViewType::TextureUAV, InFlags)
        , Desc(InDesc)
    {}
 
    friend FRDGBuilder;
    friend FRDGViewRegistry;
    friend FRDGAllocator;
};
 
struct FRDGBufferDesc
{
    static FRDGBufferDesc CreateByteAddressDesc(uint32 NumBytes)
    {
        check(NumBytes % 4 == 0);
        FRDGBufferDesc Desc;
        Desc.Usage = EBufferUsageFlags::Static | EBufferUsageFlags::UnorderedAccess | EBufferUsageFlags::ShaderResource | EBufferUsageFlags::StructuredBuffer | EBufferUsageFlags::ByteAddressBuffer;
        Desc.BytesPerElement = 4;
        Desc.NumElements = NumBytes / 4;
        return Desc;
    }
 
    template<typename ParameterStruct>
    static FRDGBufferDesc CreateByteAddressDesc(uint32 NumElements)
    {
        FRDGBufferDesc Desc = CreateByteAddressDesc(sizeof(ParameterStruct) * NumElements);
        Desc.Metadata = ParameterStruct::FTypeInfo::GetStructMetadata();
        return Desc;
    }
 
    static FRDGBufferDesc CreateIndirectDesc(uint32 BytesPerElement, uint32 NumElements)
    {
        FRDGBufferDesc Desc;
        Desc.Usage = EBufferUsageFlags::Static | EBufferUsageFlags::DrawIndirect | EBufferUsageFlags::UnorderedAccess | EBufferUsageFlags::ShaderResource | EBufferUsageFlags::VertexBuffer;
        Desc.BytesPerElement = BytesPerElement;
        Desc.NumElements = NumElements;
        return Desc;
    }
 
    static FRDGBufferDesc CreateRawIndirectDesc(uint32 NumBytes)
    {
        FRDGBufferDesc Desc = CreateByteAddressDesc(NumBytes);
        Desc.Usage |=  EBufferUsageFlags::DrawIndirect;
        return Desc;
    }
 
    template<typename IndirectParameterStruct>
    static FRDGBufferDesc CreateIndirectDesc(uint32 NumElements = 1)
    {
        return CreateIndirectDesc(sizeof(IndirectParameterStruct), NumElements);
    }
 
    static FRDGBufferDesc CreateIndirectDesc(uint32 NumElements = 1)
    {
        return CreateIndirectDesc(4u, NumElements);
    }
 
    static FRDGBufferDesc CreateStructuredDesc(uint32 BytesPerElement, uint32 NumElements)
    {
        FRDGBufferDesc Desc;
        Desc.Usage = EBufferUsageFlags::Static | EBufferUsageFlags::UnorderedAccess | EBufferUsageFlags::ShaderResource | EBufferUsageFlags::StructuredBuffer;
        Desc.BytesPerElement = BytesPerElement;
        Desc.NumElements = NumElements;
        return Desc;
    }
 
    template<typename ParameterStruct>
    static FRDGBufferDesc CreateStructuredDesc(uint32 NumElements)
    {
        FRDGBufferDesc Desc = CreateStructuredDesc(sizeof(ParameterStruct), NumElements);
        Desc.Metadata = ParameterStruct::FTypeInfo::GetStructMetadata();
        return Desc;
    }
 
    static FRDGBufferDesc CreateBufferDesc(uint32 BytesPerElement, uint32 NumElements)
    {
        FRDGBufferDesc Desc;
        Desc.Usage = EBufferUsageFlags::Static | EBufferUsageFlags::UnorderedAccess | EBufferUsageFlags::ShaderResource | EBufferUsageFlags::VertexBuffer;
        Desc.BytesPerElement = BytesPerElement;
        Desc.NumElements = NumElements;
        return Desc;
    }
 
    template<typename ParameterStruct>
    static FRDGBufferDesc CreateBufferDesc(uint32 NumElements)
    {
        FRDGBufferDesc Desc = CreateBufferDesc(sizeof(ParameterStruct), NumElements);
        Desc.Metadata = ParameterStruct::FTypeInfo::GetStructMetadata();
        return Desc;
    }
 
    static FRDGBufferDesc CreateUploadDesc(uint32 BytesPerElement, uint32 NumElements)
    {
        FRDGBufferDesc Desc;
        Desc.Usage = EBufferUsageFlags::ShaderResource | EBufferUsageFlags::VertexBuffer;
        Desc.BytesPerElement = BytesPerElement;
        Desc.NumElements = NumElements;
        return Desc;
    }
 
    template<typename ParameterStruct>
    static FRDGBufferDesc CreateUploadDesc(uint32 NumElements)
    {
        FRDGBufferDesc Desc = CreateUploadDesc(sizeof(ParameterStruct), NumElements);
        Desc.Metadata = ParameterStruct::FTypeInfo::GetStructMetadata();
        return Desc;
    }
 
    static FRDGBufferDesc CreateStructuredUploadDesc(uint32 BytesPerElement, uint32 NumElements)
    {
        FRDGBufferDesc Desc;
        Desc.Usage = EBufferUsageFlags::ShaderResource | EBufferUsageFlags::StructuredBuffer;
        Desc.BytesPerElement = BytesPerElement;
        Desc.NumElements = NumElements;
        return Desc;
    }
 
    template<typename ParameterStruct>
    static FRDGBufferDesc CreateStructuredUploadDesc(uint32 NumElements)
    {
        FRDGBufferDesc Desc = CreateStructuredUploadDesc(sizeof(ParameterStruct), NumElements);
        Desc.Metadata = ParameterStruct::FTypeInfo::GetStructMetadata();
        return Desc;
    }
 
    static FRDGBufferDesc CreateByteAddressUploadDesc(uint32 NumBytes)
    {
        check(NumBytes % 4 == 0);
        FRDGBufferDesc Desc;
        Desc.Usage = EBufferUsageFlags::ShaderResource | EBufferUsageFlags::ByteAddressBuffer | EBufferUsageFlags::StructuredBuffer;
        Desc.BytesPerElement = 4;
        Desc.NumElements = NumBytes / 4;
        return Desc;
    }
 
    template<typename ParameterStruct>
    static FRDGBufferDesc CreateByteAddressUploadDesc(uint32 NumElements)
    {
        FRDGBufferDesc Desc = CreateByteAddressUploadDesc(sizeof(ParameterStruct) * NumElements);
        Desc.Metadata = ParameterStruct::FTypeInfo::GetStructMetadata();
        return Desc;
    }
 
    uint32 GetSize() const
    {
        return BytesPerElement * NumElements;
    }
 
    friend uint32 GetTypeHash(const FRDGBufferDesc& Desc)
    {
        uint32 Hash = GetTypeHash(Desc.BytesPerElement);
        Hash = HashCombine(Hash, GetTypeHash(Desc.NumElements));
        Hash = HashCombine(Hash, GetTypeHash(Desc.Usage));
        Hash = HashCombine(Hash, GetTypeHash(Desc.Metadata));
        return Hash;
    }
 
    bool operator == (const FRDGBufferDesc& Other) const
    {
        return
            BytesPerElement == Other.BytesPerElement &&
            NumElements == Other.NumElements &&
            Usage == Other.Usage;
    }
 
    bool operator != (const FRDGBufferDesc& Other) const
    {
        return !(*this == Other);
    }
 
    uint32 BytesPerElement = 1;
 
    uint32 NumElements = 1;
 
    EBufferUsageFlags Usage = EBufferUsageFlags::None;
 
    const FShaderParametersMetadata* Metadata = nullptr;
};
 
struct FRDGBufferSRVDesc final
    : public FRHIBufferSRVCreateInfo
{
    FRDGBufferSRVDesc() = default;
 
    FRDGBufferSRVDesc(FRDGBufferRef InBuffer);
 
    FRDGBufferSRVDesc(FRDGBufferRef InBuffer, EPixelFormat InFormat)
        : FRHIBufferSRVCreateInfo(InFormat)
        , Buffer(InBuffer)
    {
    }
 
    FRDGBufferSRVDesc(FRDGBufferRef InBuffer, uint32 InStartOffsetBytes, uint32 InNumElements)
        : FRHIBufferSRVCreateInfo(InStartOffsetBytes, InNumElements)
        , Buffer(InBuffer)
    {}
 
    FRDGBufferSRVDesc(FRDGBufferRef InBuffer, FRHIRayTracingScene* InRayTracingScene, uint32 InStartOffsetBytes)
        : FRHIBufferSRVCreateInfo(InRayTracingScene, InStartOffsetBytes)
        , Buffer(InBuffer)
    {}
 
    bool operator == (const FRDGBufferSRVDesc& Other) const
    {
        return Buffer == Other.Buffer && FRHIBufferSRVCreateInfo::operator==(Other);
    }
 
    bool operator != (const FRDGBufferSRVDesc& Other) const
    {
        return !(*this == Other);
    }
 
    friend uint32 GetTypeHash(const FRDGBufferSRVDesc& Desc)
    {
        return HashCombine(GetTypeHash(static_cast<const FRHIBufferSRVCreateInfo&>(Desc)), GetTypeHash(Desc.Buffer));
    }
 
    FRDGBufferRef Buffer = nullptr;
};
 
struct FRDGBufferUAVDesc final
    : public FRHIBufferUAVCreateInfo
{
    FRDGBufferUAVDesc() = default;
 
    FRDGBufferUAVDesc(FRDGBufferRef InBuffer);
 
    FRDGBufferUAVDesc(FRDGBufferRef InBuffer, EPixelFormat InFormat)
        : FRHIBufferUAVCreateInfo(InFormat)
        , Buffer(InBuffer)
    {}
 
    bool operator == (const FRDGBufferUAVDesc& Other) const
    {
        return Buffer == Other.Buffer && FRHIBufferUAVCreateInfo::operator==(Other);
    }
 
    bool operator != (const FRDGBufferUAVDesc& Other) const
    {
        return !(*this == Other);
    }
 
    friend uint32 GetTypeHash(const FRDGBufferUAVDesc& Desc)
    {
        return HashCombine(GetTypeHash(static_cast<const FRHIBufferUAVCreateInfo&>(Desc)), GetTypeHash(Desc.Buffer));
    }
 
    FRDGBufferRef Buffer = nullptr;
};
 
inline FRHIBufferCreateInfo Translate(const FRDGBufferDesc& InDesc);
 
class FRDGPooledBuffer final
    : public FRefCountBase
{
public:
    FRDGPooledBuffer(FRHICommandListBase& RHICmdList, TRefCountPtr<FRHIBuffer> InBuffer, const FRDGBufferDesc& InDesc, uint32 InNumAllocatedElements, const TCHAR* InName)
        : Desc(InDesc)
        , Buffer(MoveTemp(InBuffer))
        , Name(InName)
        , NumAllocatedElements(InNumAllocatedElements)
    {
        if (EnumHasAnyFlags(InDesc.Usage, EBufferUsageFlags::StructuredBuffer | EBufferUsageFlags::ByteAddressBuffer))
        {
            CachedSRV = GetOrCreateSRV(RHICmdList, FRHIBufferSRVCreateInfo());
        }
 
        Fences.Emplace();
    }
 
    RENDERCORE_API FRDGPooledBuffer(TRefCountPtr<FRHIBuffer> InBuffer, const FRDGBufferDesc& InDesc, uint32 InNumAllocatedElements, const TCHAR* InName);
 
    const FRDGBufferDesc Desc;
 
    inline FRHIUnorderedAccessView* GetOrCreateUAV(FRHICommandListBase& RHICmdList, const FRHIBufferUAVCreateInfo& UAVDesc) { return ViewCache.GetOrCreateUAV(RHICmdList, Buffer, UAVDesc); }
 
    inline FRHIShaderResourceView* GetOrCreateSRV(FRHICommandListBase& RHICmdList, const FRHIBufferSRVCreateInfo& SRVDesc) { return ViewCache.GetOrCreateSRV(RHICmdList, Buffer, SRVDesc); }
 
    UE_DEPRECATED(5.3, "GetOrCreateUAV now requires a command list.")
    inline FRHIUnorderedAccessView* GetOrCreateUAV(const FRHIBufferUAVCreateInfo& UAVDesc) { return ViewCache.GetOrCreateUAV(FRHICommandListImmediate::Get(), Buffer, UAVDesc); }
 
    UE_DEPRECATED(5.3, "GetOrCreateSRV now requires a command list.")
    inline FRHIShaderResourceView* GetOrCreateSRV(const FRHIBufferSRVCreateInfo& SRVDesc) { return ViewCache.GetOrCreateSRV(FRHICommandListImmediate::Get(), Buffer, SRVDesc); }
 
    inline FRHIBuffer* GetRHI() const { return Buffer; }
 
    inline FRHIShaderResourceView* GetSRV()
    {
        checkf(CachedSRV, TEXT("Only byte address and structured buffers can use the default GetSRV call"));
        return CachedSRV;
    }
 
    UE_DEPRECATED(5.3, "GetSRV now requires a command list.")
    inline FRHIShaderResourceView* GetSRV(const FRHIBufferSRVCreateInfo& SRVDesc)
    {
        return GetOrCreateSRV(FRHICommandListImmediate::Get(), SRVDesc);
    }
 
    inline FRHIShaderResourceView* GetSRV(FRHICommandListBase& RHICmdList, const FRHIBufferSRVCreateInfo& SRVDesc)
    {
        return GetOrCreateSRV(RHICmdList, SRVDesc);
    }
 
    inline uint32 GetSize() const
    {
        return Desc.GetSize();
    }
 
    inline uint32 GetAlignedSize() const
    {
        return Desc.BytesPerElement * NumAllocatedElements;
    }
 
    inline uint64 GetCommittedSize() const
    {
        return FMath::Min<uint64>(CommittedSizeInBytes, GetSize());
    }
 
    const TCHAR* GetName() const
    {
        return Name;
    }
 
private:
    TRefCountPtr<FRHIBuffer> Buffer;
    FRHIShaderResourceView* CachedSRV = nullptr;
    FRHIBufferViewCache ViewCache;
 
    FRDGBufferDesc GetAlignedDesc() const
    {
        FRDGBufferDesc AlignedDesc = Desc;
        AlignedDesc.NumElements = NumAllocatedElements;
        return AlignedDesc;
    }
 
    void SetDebugLabelName(FRHICommandListBase& RHICmdList, const TCHAR* InName);
 
    // Used internally by FRDGBuilder::QueueCommitReservedBuffer(),
    // which is expected to be the only way to resize physical memory for FRDGPooledBuffer
    void SetCommittedSize(uint64 InCommittedSizeInBytes)
    {
        if (InCommittedSizeInBytes == UINT64_MAX)
        {
            InCommittedSizeInBytes = GetSize();
        }
 
        checkf(EnumHasAllFlags(Desc.Usage, EBufferUsageFlags::ReservedResource), TEXT("CommitReservedResource() may only be used on reserved buffers"));
        checkf(InCommittedSizeInBytes <= GetSize(), TEXT("Attempting to commit more memory than was reserved for this buffer during creation"));
 
        CommittedSizeInBytes = InCommittedSizeInBytes;
    }
 
    const TCHAR* Name = nullptr;
 
    // Size of the GPU physical memory committed to a reserved buffer.
    // May be UINT64_MAX for regular (non-reserved) buffers or when the entire resource is committed.
    uint64 CommittedSizeInBytes = UINT64_MAX;
 
#if RHI_USE_RESOURCE_DEBUG_NAME
    // Tracks the number of items in ViewCache when the debug Name was updated, so we know if items were added and we need to propagate the debug name to the new items
    int32 NameUpdatedViewCacheNum = 0;
#endif
 
    const uint32 NumAllocatedElements;
    uint32 LastUsedFrame = 0;
 
    TOptional<FRHITransientAllocationFences> Fences;
 
    friend FRDGBuilder;
    friend FRDGBufferPool;
};
 
class FRDGBuffer final
    : public FRDGViewableResource
{
public:
    static const ERDGViewableResourceType StaticType = ERDGViewableResourceType::Buffer;
 
    FRDGBufferDesc Desc;
    const ERDGBufferFlags Flags;
 
 
    FRHIBuffer* GetRHI() const
    {
        return static_cast<FRHIBuffer*>(FRDGViewableResource::GetRHI());
    }
 
    inline FRHIBuffer* GetIndirectRHICallBuffer() const
    {
        checkf(Desc.Usage & BUF_DrawIndirect, TEXT("Buffer %s was not flagged for indirect draw usage."), Name);
        return GetRHI();
    }
 
 
    FRDGBufferHandle GetHandle() const
    {
        return Handle;
    }
 
    inline uint32 GetSize() const
    {
        return Desc.GetSize();
    }
 
    inline uint32 GetStride() const
    {
        return Desc.BytesPerElement;
    }
 
    bool IsCulled() const
    {
        return ReferenceCount == 0 && PendingCommitSize == 0;
    }
 
private:
    RENDERCORE_API FRDGBuffer(const TCHAR* InName, const FRDGBufferDesc& InDesc, ERDGBufferFlags InFlags);
    RENDERCORE_API FRDGBuffer(const TCHAR* InName, const FRDGBufferDesc& InDesc, ERDGBufferFlags InFlags, FRDGBufferNumElementsCallback* InNumElementsCallback);
 
    RENDERCORE_API void FinalizeDesc();
 
    FRHIBuffer* GetRHIUnchecked() const
    {
        return static_cast<FRHIBuffer*>(FRDGResource::GetRHIUnchecked());
    }
 
    FRDGBufferHandle Handle;
 
    FRDGBufferHandle PreviousOwner;
    FRDGBufferHandle NextOwner;
 
    FRDGPooledBuffer* PooledBuffer = nullptr;
 
    FRHITransientBuffer* TransientBuffer = nullptr;
 
    FRHIBufferViewCache* ViewCache = nullptr;
 
    TRefCountPtr<FRDGPooledBuffer> Allocation;
 
    FRDGProducerStatesByPipeline LastProducer;
 
    FRDGBufferNumElementsCallback* NumElementsCallback = nullptr;
 
    uint64 PendingCommitSize = 0;
 
    FRDGSubresourceState* State = nullptr;
 
    FRDGSubresourceState* FirstState = nullptr;
 
    FRDGSubresourceState* MergeState = nullptr;
 
    friend FRDGBuilder;
    friend FRDGBarrierValidation;
    friend FRDGUserValidation;
    friend FRDGBufferRegistry;
    friend FRDGAllocator;
    friend FRDGTrace;
};
 
class FRDGBufferSRV final
    : public FRDGShaderResourceView
{
public:
    static const ERDGViewType StaticType = ERDGViewType::BufferSRV;
 
    const FRDGBufferSRVDesc Desc;
 
    FRDGBufferRef GetParent() const override
    {
        return Desc.Buffer;
    }
 
private:
    FRDGBufferSRV(const TCHAR* InName, const FRDGBufferSRVDesc& InDesc)
        : FRDGShaderResourceView(InName, ERDGViewType::BufferSRV)
        , Desc(InDesc)
    {}
 
    friend FRDGBuilder;
    friend FRDGViewRegistry;
    friend FRDGAllocator;
};
 
class FRDGBufferUAV final
    : public FRDGUnorderedAccessView
{
public:
    static const ERDGViewType StaticType = ERDGViewType::BufferUAV;
 
    const FRDGBufferUAVDesc Desc;
 
    FRDGBufferRef GetParent() const override
    {
        return Desc.Buffer;
    }
 
private:
    FRDGBufferUAV(const TCHAR* InName, const FRDGBufferUAVDesc& InDesc, ERDGUnorderedAccessViewFlags InFlags)
        : FRDGUnorderedAccessView(InName, ERDGViewType::BufferUAV, InFlags)
        , Desc(InDesc)
    {}
 
    friend FRDGBuilder;
    friend FRDGViewRegistry;
    friend FRDGAllocator;
};
 
template <typename ViewableResourceType>
inline ViewableResourceType* GetAs(FRDGViewableResource* Resource)
{
    check(ViewableResourceType::StaticType == Resource->Type);
    return static_cast<ViewableResourceType*>(Resource);
}
 
template <typename ViewType>
inline ViewType* GetAs(FRDGView* View)
{
    check(ViewType::StaticType == View->Type);
    return static_cast<ViewType*>(View);
}
 
inline FRDGBuffer* GetAsBuffer(FRDGViewableResource* Resource)
{
    return GetAs<FRDGBuffer>(Resource);
}
 
inline FRDGTexture* GetAsTexture(FRDGViewableResource* Resource)
{
    return GetAs<FRDGTexture>(Resource);
}
 
inline FRDGBufferUAV* GetAsBufferUAV(FRDGView* View)
{
    return GetAs<FRDGBufferUAV>(View);
}
 
inline FRDGBufferSRV* GetAsBufferSRV(FRDGView* View)
{
    return GetAs<FRDGBufferSRV>(View);
}
 
inline FRDGTextureUAV* GetAsTextureUAV(FRDGView* View)
{
    return GetAs<FRDGTextureUAV>(View);
}
 
inline FRDGTextureSRV* GetAsTextureSRV(FRDGView* View)
{
    return GetAs<FRDGTextureSRV>(View);
}
 
inline FGraphicsPipelineRenderTargetsInfo ExtractRenderTargetsInfo(const FRDGParameterStruct& ParameterStruct);
inline FGraphicsPipelineRenderTargetsInfo ExtractRenderTargetsInfo(const FRenderTargetBindingSlots& RenderTargets);
 
#include "RenderGraphResources.inl" // IWYU pragma: export