vault backup: 2024-02-05 14:28:02

03-UnrealEngine/Rendering/RenderingPipeline/向往渲染系列文章阅读笔记/剖析虚幻渲染体系（11）- RDG.md

@@ -6,4 +6,212 @@ tags:
 rating: ⭐
 ---
 # 前言
-https://www.cnblogs.com/timlly/p/15217090.html
+https://www.cnblogs.com/timlly/p/15217090.html
+
+## RDG基础类型
+```c++
+enum class ERDGBuilderFlags
+{
+	None = 0,
+
+	/** Allows the builder to parallelize execution of passes. Without this flag, all passes execute on the render thread. */
+	AllowParallelExecute = 1 << 0
+};
+
+/** Flags to annotate a pass with when calling AddPass. */
+enum class ERDGPassFlags : uint16
+{
+	/** Pass doesn't have any inputs or outputs tracked by the graph. This may only be used by the parameterless AddPass function. */
+	None = 0,
+
+	/** Pass uses rasterization on the graphics pipe. */
+	Raster = 1 << 0,
+
+	/** Pass uses compute on the graphics pipe. */
+	Compute = 1 << 1,
+
+	/** Pass uses compute on the async compute pipe. */
+	AsyncCompute = 1 << 2,
+
+	/** Pass uses copy commands on the graphics pipe. */
+	Copy = 1 << 3,
+
+	/** Pass (and its producers) will never be culled. Necessary if outputs cannot be tracked by the graph. */
+	NeverCull = 1 << 4,
+
+	/** Render pass begin / end is skipped and left to the user. Only valid when combined with 'Raster'. Disables render pass merging for the pass. */
+	SkipRenderPass = 1 << 5,
+
+	/** Pass will never have its render pass merged with other passes. */
+	NeverMerge = 1 << 6,
+
+	/** Pass will never run off the render thread. */
+	NeverParallel = 1 << 7,
+
+	ParallelTranslate = 1 << 8,
+
+	/** Pass uses copy commands but writes to a staging resource. */
+	Readback = Copy | NeverCull
+};
+
+/** Flags to annotate a render graph buffer. */
+enum class ERDGBufferFlags : uint8
+{
+	None = 0,
+
+	/** Tag the buffer to survive through frame, that is important for multi GPU alternate frame rendering. */
+	MultiFrame = 1 << 0,
+
+	/** The buffer is ignored by RDG tracking and will never be transitioned. Use the flag when registering a buffer with no writable GPU flags.
+	 *  Write access is not allowed for the duration of the graph. This flag is intended as an optimization to cull out tracking of read-only
+	 *  buffers that are used frequently throughout the graph. Note that it's the user's responsibility to ensure the resource is in the correct
+	 *  readable state for use with RDG passes, as RDG does not know the exact state of the resource.
+	 */
+	SkipTracking = 1 << 1,
+
+	/** When set, RDG will perform its first barrier without splitting. Practically, this means the resource is left in its initial state
+	 *  until the first pass it's used within the graph. Without this flag, the resource is split-transitioned at the start of the graph.
+	 */
+	ForceImmediateFirstBarrier = 1 << 2,
+};
+
+/** Flags to annotate a render graph texture. */
+enum class ERDGTextureFlags : uint8
+{
+	None = 0,
+
+	/** Tag the texture to survive through frame, that is important for multi GPU alternate frame rendering. */
+	MultiFrame = 1 << 0,
+
+	/** The buffer is ignored by RDG tracking and will never be transitioned. Use the flag when registering a buffer with no writable GPU flags.
+	 *  Write access is not allowed for the duration of the graph. This flag is intended as an optimization to cull out tracking of read-only
+	 *  buffers that are used frequently throughout the graph. Note that it's the user's responsibility to ensure the resource is in the correct
+	 *  readable state for use with RDG passes, as RDG does not know the exact state of the resource.
+	 */
+	SkipTracking = 1 << 1,
+	
+	/** When set, RDG will perform its first barrier without splitting. Practically, this means the resource is left in its initial state
+	 *  until the first pass it's used within the graph. Without this flag, the resource is split-transitioned at the start of the graph.
+	 */
+	ForceImmediateFirstBarrier = 1 << 2,
+
+	/** Prevents metadata decompression on this texture. */
+	MaintainCompression = 1 << 3,
+};
+ENUM_CLASS_FLAGS(ERDGTextureFlags);
+
+/** Flags to annotate a view with when calling CreateUAV. */
+enum class ERDGUnorderedAccessViewFlags : uint8
+{
+	None = 0,
+
+	// The view will not perform UAV barriers between consecutive usage.
+	SkipBarrier = 1 << 0
+};
+ENUM_CLASS_FLAGS(ERDGUnorderedAccessViewFlags);
+
+/** The set of concrete parent resource types. */
+enum class ERDGViewableResourceType : uint8
+{
+	Texture,
+	Buffer,
+	MAX
+};
+
+/** The set of concrete view types. */
+enum class ERDGViewType : uint8
+{
+	TextureUAV,
+	TextureSRV,
+	BufferUAV,
+	BufferSRV,
+	MAX
+};
+
+inline ERDGViewableResourceType GetParentType(ERDGViewType ViewType)
+{
+	switch (ViewType)
+	{
+	case ERDGViewType::TextureUAV:
+	case ERDGViewType::TextureSRV:
+		return ERDGViewableResourceType::Texture;
+	case ERDGViewType::BufferUAV:
+	case ERDGViewType::BufferSRV:
+		return ERDGViewableResourceType::Buffer;
+	}
+	checkNoEntry();
+	return ERDGViewableResourceType::MAX;
+}
+
+enum class ERDGResourceExtractionFlags : uint8
+{
+	None = 0,
+
+	// Allows the resource to remain transient. Only use this flag if you intend to register the resource back
+	// into the graph and release the reference. This should not be used if the resource is cached for a long
+	// period of time.
+	AllowTransient = 1,
+};
+
+enum class ERDGInitialDataFlags : uint8
+{
+	/** Specifies the default behavior, which is to make a copy of the initial data for replay when
+	 *  the graph is executed. The user does not need to preserve lifetime of the data pointer.
+	 */
+	None = 0,
+
+	/** Specifies that the user will maintain ownership of the data until the graph is executed. The
+	 *  upload pass will only use a reference to store the data. Use caution with this flag since graph
+	 *  execution is deferred! Useful to avoid the copy if the initial data lifetime is guaranteed to
+	 *  outlive the graph.
+	 */
+	 NoCopy = 1 << 0
+};
+
+enum class ERDGPooledBufferAlignment : uint8
+{
+	// The buffer size is not aligned.
+	None,
+
+	// The buffer size is aligned up to the next page size.
+	Page,
+
+	// The buffer size is aligned up to the next power of two.
+	PowerOfTwo
+};
+
+/** Returns the equivalent parent resource type for a view type. */
+inline ERDGViewableResourceType GetViewableResourceType(ERDGViewType ViewType)
+{
+	switch (ViewType)
+	{
+	case ERDGViewType::TextureUAV:
+	case ERDGViewType::TextureSRV:
+		return ERDGViewableResourceType::Texture;
+	case ERDGViewType::BufferUAV:
+	case ERDGViewType::BufferSRV:
+		return ERDGViewableResourceType::Buffer;
+	default:
+		checkNoEntry();
+		return ERDGViewableResourceType::MAX;
+	}
+}
+
+using ERDGTextureMetaDataAccess = ERHITextureMetaDataAccess;
+
+/** Returns the associated FRHITransitionInfo plane index. */
+inline int32 GetResourceTransitionPlaneForMetadataAccess(ERDGTextureMetaDataAccess Metadata)
+{
+	switch (Metadata)
+	{
+	case ERDGTextureMetaDataAccess::CompressedSurface:
+	case ERDGTextureMetaDataAccess::HTile:
+	case ERDGTextureMetaDataAccess::Depth:
+		return FRHITransitionInfo::kDepthPlaneSlice;
+	case ERDGTextureMetaDataAccess::Stencil:
+		return FRHITransitionInfo::kStencilPlaneSlice;
+	default:
+		return 0;
+	}
+}
+```