Home on wanfeng

游戏引擎开发实践（空间加速结构）

Fri, 20 Feb 2026 20:02:28 +0800

基础理论

均匀网格划分

把整个场景 AABB 均匀划分成 Nx × Ny × Nz 的三维网格，每个 cell 里存放与其相交的 primitive（如三角形）列表

但是实际场景中Mesh很容易是按簇分布的，此时如果击中左上角这个cell，会导致大量的相交计算

最容易的解决办法是提高grid的分辨率

四叉树/八叉树

这种方法是从顶向下划分，Root表示整个场景，先切4刀，检查每个区域是否Mesh数量小于阈值了，如果不小于，继续划分

如下图中区域1就需要继续划分，而234就不需要了

区域1中Mesh还是很多，继续划分

继续划分新的区域1

上述流程假定一个情况：每个三角形都能刚好划分到不同的区域，但实际上一个三角形可能分布在不同的区域内，所以每个涉及的区域都需要存储这个三角形，如下图

松散八叉树

扩大子节点的范围，这样可以保证这个结点是完全包含五角星

假设一条射线从上到下进行击中判断，正好落在左上角和右上角两个结点的中心偏右一点，那左图（如果只在左边存储五角星）只有右边结点会加入检测队列，导致五角星漏掉了，那五角星就会被误判，右边就能正常把左边结点加入判断流程

线性八叉树

TODO:具体使用流程还不太清除

Morton Code

将多维数据映射到一维，同时保留数据点的局部性

空间中相近的坐标，编码后的数值也相近

下图展示计算一个XYZ坐标的莫顿编码

如果把空间中XYZ从0-10都编码并排序后连起来会发现，一维编码表示的空间坐标，在3D空间中有了局部连续性

BSP树

递归的用一个超平面去划分场景为两半，划分可以是任意的

继续对AB两个区域进行划分

与四叉树类似，当一个区域内的Mesh数量小于阈值后停止分割

K-d Tree

是BSP树的一种特殊形式，横平竖直地进行分割，而不是随意分割

BVH

上述方法都是自顶向下对空间进行划分，看Mesh落在哪个区域，而BVH是从底向上，合并多个Mesh为一个结点，直到合并场景中所有结点

一个关键区别是：BVH运行划分重叠，所以mesh可以安心得只落在一个结点，不会出现一个Mesh落在两个子空间，需要额外处理的情况

构建BVH的关键在于，如果划分左右区间使得左右两个结点的AABB重叠最小

BVH在GPU是bottomUp来构建的

这里注意：以前理解的 BVH构建是自底向上是不全面的，分CPU和GPU两种情况，如下图文字所示

下面是TopDown的流程，Root表示所有三角形组成的AABB，每次都把大的AABB分成两个小的AABB，每个AABB表示一部分三角形组成的AABB

TopDown流程的问题是，怎么去划分呢？

可以选择沿着一条坐标轴进行，或者某个方向

划分可以使用空间的中心或者Mesh的中心

按照空间来划分流程如下，首先选择最长轴，找到终点，分析每个Mesh的中心在这个中点的左侧还是右侧，从而划分两个部分，计算两部分的AABB，这样就划分好了

如何与BVH进行求交运算呢，用一个递归代码就能完成

HitInfo TraverseBVH(Node* node, Ray ray) {
    if (!IntersectAABB(ray, node->aabb)) return HitInfo::miss();  // 剪枝
    
    if (node->isLeaf) {
        return IntersectTriangles(ray, node->triangles); // 真正的遍历求交
    } else {
        HitInfo hitLeft = TraverseBVH(node->left, ray);
        HitInfo hitRight = TraverseBVH(node->right, ray);
        return hitLeft.hitDistance < hitRight.hitDistance ? hitLeft : hitRight;
    }
}

从下图可以理解坐标中点划分并不是一种很好的方式（左图），AABB重叠了，右图是比较好的方式

BVH的SAH（表面积启发式的结点划分方法）

定义数学模型：

对一个Mesh求交的代价为t(x)，那一批Mesh不分区情况下的总代价为：

如果将Mesh分为两区，光线击中某个区域的概率为p(x),此时的代价为（ttrav是表示遍历树状结构的代价）：

结合BVH来看，AB分别表示划分后两个AABB的表面积，C是父结点的表面积，ab表示划分后各个区域的Mesh数量

从理论上理解：SAH目的是减少求交次数，首先Mesh越多，求交次数就越多，那Mesh所在的区域被击中的概率越大，进入区域去遍历这些Mesh的概率就越大，AABB的表面积越大，选择当前区域的概率越大，所以这两个因素相乘就是代价

八叉树实践

总体上就是递归构建，基本思路不难，估计难得是适配实际情况

#pragma once
#include "collision.h"
/*
	八叉树(目前这个代码跑不了，只是伪代码)：
	构建: 把所有物体分配给Root，如果Root的物体数量大于MAX_LEAF_OBJECT_COUNT，就创建它的8个孩子，并且把所有物体按照位置分配给孩子（如果没法精确分配给某个孩子，就还是存在Root上），再遍历8个孩子，如果某个孩子物体数量大于MAX_LEAF_OBJECT_COUNT，继续递归构建
	添加：判断物体是否包含在Root，包含的话，就判断8个孩子是否完美包含它，如果包含，就递归给孩子去添加，如果都不包含。就存储在当前Root
	更新物体位置：判断是否还在同一个结点，如果不在就删除后重写插入，或者有一些论文去查询邻近结点

	松散八叉树：


	八叉树的用途：（加速遍历Mesh的判断，如果对某个结点的判断失败了，那这个结点以下的Mesh的判断可以完全跳过）
	视锥裁剪：用视锥体和Root进行相交判断，如果AABB完全在视锥外，直接剔除Root（剪枝），如果视锥完全包含当前AABB，直接添加当前Root下所有Mesh，如果只是相交，递归检查8个孩子，递归到孩子结点，如果还相交，就添加到可见物体数组
*/
namespace GameEngine {

#define MAX_LEAF_OBJECT_COUNT 4

	template<class T>
	class OctreeNode {
	public:
		OctreeNode(BoundingBox& Box) {
			AABB = Box;
		}
		std::vector<T> Objects;
		BoundingBox AABB;
		std::array<OctreeNode<T>*, 8> children{nullptr};


		bool IsStrictContain(T& Object) {
			return AABB.IsContains(Object.box);
		}
	};

	template<class T>
	class Octree
	{
	public:
		Octree(std::vector<T>& Objects, BoundingBox& Box) {
			Root = std::make_shared<OctreeNode<T>>(Box);
			CreateChildNode(Root);
			GenOctree(Root, Objects);
		}

		void CreateChildNode(std::shared_ptr<OctreeNode<T>> Root)
		{
			// TODO: 八个子空间生成，规划每个子空间的范围
			// Root->children[0] = new OctreeNode({ xxxx});
		}

		void GenOctree(std::shared_ptr<OctreeNode<T>> Root,std::vector<T> &Objects) {
			// 1. 每个物体划分到当前Root的8个子空间或Root空间中
			for (T& obj : Objects) {
				bool isPushed = false;
				for (OctreeNode<T>* CurSpace : Root->children) {
					if(CurSpace->AABB.IsContains(obj.aabb))
					{
						CurSpace->Objects.push_back(obj);
						isPushed = true;
					}
				}
				if (!isPushed)	// 没有一个子空间能够完全包住物体，放在父空间中
				{
					Root->Objects.push_back(obj);
				}
				isPushed = false;
			}

			// 2. 判断子空间是否需要继续划分
			for (OctreeNode<T>* CurSpace : Root->children)
			{
				if (CurSpace->Objects.size() > MAX_LEAF_OBJECT_COUNT)
				{
					CreateChildNode(CurSpace);
					GenOctree(CurSpace,CurSpace->Objects);
					CurSpace->Objects.clear(); // TODO:如果有物体存在Root上，这行代码就把他删了。。。。
				}
			}
		}
		

		void AddObject(T& Object) {
			AddObjectInner(Object, Root);
		}
		bool AddObjectInner(T& Object, std::shared_ptr<OctreeNode<T>> Root) {
			if (!Root) return false;
			if (!Root->AABB.IsContains(Object.aabb)) {
				return false;
			}
			bool isHandled = false;
			for (OctreeNode<T>* CurSpace : Root->children) {
				if (CurSpace && CurSpace->AABB.IsContains(obj.aabb))
				{
					// 说明子结点插入失败,交给当前结点处理
					isHandled = AddObjectInner(object, CurSpace);
				}
			}
			if (!isHandled) {
				Root->Objects.push_back(object);
			}
			return true;
		}


	private:
		std::shared_ptr<OctreeNode<T>> Root = nullptr;
	};
}

BVH + SAH实践(TODO)

CPU（自顶向下）

CPU上构建BVH主要是TopDown的，SAH用来划分区间

为了减少SAH的计算量，在最长轴上均匀分成若干桶，来减少计算,最终划分只会出现在桶内

另外插入新结点时插入到哪个叶子结点也是根据SAH，如下图插入L的Cost = 新增的11结点的表面积 + 沿路向上的父结点表面积变化的和

#pragma once
#include "collision.h"
/*
	BVH:（TODO：目前是伪代码，SAH未完成）
	构建方式： 计算所有Mesh的AABB在哪个轴上最宽，在这个轴上对Mesh进行排序,根据某种划分算法把Mesh数组分成两部分，分别递归构建子树，直到叶子结点
	添加Mesh：首先插入一定发生在叶子结点，依据SAH，判断依哪一个节点的插入会有“最小表面积”的变化，具体计算公式看Blog
*/
namespace GameEngine 
{
	template<typename T>
	class BVHNode {
	public:
		BVHNode* left = nullptr;
		BVHNode* right = nullptr;
		BVHNode* parent = nullptr;
		std::vector<T> objects;
		BoundingBox AABB;
	};


	template<typename T>
	class BVH
	{
	public:
		BVHNode<T>* BuildBVHInner(std::vector<T>&objects, BVHNode<T>* Root) {
			// 1. 计算Root的AABB
			for (auto& object : objects) {
				Root->AABB.Merge(object.aabb);
			}

			// 创建Root
			if(!Root) Root = new BVHNode<T>();
			if (objects.size() <= 1) {
                Root->objects = objects;
                return Root;
			}
			// 2. 利用SAH算法，对Root进行划分
			int lefeMaxIndex = SAHSplit(Root, objects,int left, int right);

			// 3. 递归构建左右子树
			BVHNode<T>* left = BuildBVHInner(objects.begin() + left, objects.begin() + lefeMaxIndex, Root);
            BVHNode<T>* right = BuildBVHInner(objects.begin() + left + lefeMaxIndex, objects.begin() + right, Root);
			Root->left = left;
            Root->right = right;
            left->parent = right->parent = Root;
            return Root;
		}


		// SAH算法，返回划分后left的最大Index
		int SAHSplit(BVHNode<T>* node, std::vector<T>& objects, int left, int right) {

		}
		BVHNode<T>* Root = nullptr;
	};


}

GPU(自底向上，线性BVH)

以二维坐标和三维坐标为例，对于每一个点计算其对应的莫顿码，然后利用莫顿码对其进行排序，再将排序后的点按照顺序连接起来就会得到如下图所示的Z形曲线z-order curve

构建莫顿码就是把多维数组成的坐标的每个维度交错排布

比如二维平面上[0-3]范围内的点，全部编码为莫顿编码后，排序连线如下

主要观察一点，用最高位0或1就可以把区域划分为上下两部分！

只看第二位，又可以左右划分，这样就划分成了四个区域

所以莫顿编码第一位为1，第二位为0的区域一定在左上角！

对于三角形图元，编码它的方式为 xyzmin表示整个场景的最小点，lwh是场景的宽度

按这种方式计算后P就代表这个三角形在AABB盒中的位置，接下来对P进行莫顿编码

构建BVH时，按照上边方法生成所有图元的编码，然后进行基数排序

这里基数排序回忆一下

排序完成后，再按照最长公共前缀来进行切分

切分就是按照当前位是0还是1（其实不是看一位，而是最长公共前缀，比如前几个都是00），同样是0的说明在空间上是接近的

这种方式仍然是自顶向下的，下面介绍从底向上的GPU的构建办法

首先第一点：一个二叉树，叶子结点有N个时，非叶子结点一定有N-1个

游戏引擎开发实践（FXAA TODO）

Sun, 25 Jan 2026 16:21:06 +0800

FXAA（fast approximate antialiasing）的思路是检测图像的边界，只在边界处进行滤波，达到抗锯齿的效果，确实锯齿效果就是发生在边界

这种思路被称为形变抗锯齿，SMAA也是这个类型

FXAA只需要一个Pass，是一种快速抗锯齿

FXAA 的流程：

边缘检测：比较当前像素上下左右四个方向上的亮度差，过大才进行抗锯齿操作

确定混合系数：计算当前像素与周围一圈像素的平均亮度（考虑距离，斜角距离更大）与当前像素亮度的差作为依据来确定混合系数

确定锯齿方向，判断垂直和水平四个方向上的变化，取最大变化的方向

在锯齿方向上进行左右搜素直到锯齿边界，离得越近的边界贡献应该越大

用上边的混合系数和第四步的边界距离来指导最终的混合系数，得到采样时的偏移量（在采样时偏移像素中心，就相当于混合其他像素了～）

边缘检测

计算当前处理的像素点和周围像素点的亮度对比值，FXAA 通过确定水平和垂直方向上像素点的亮度差，来计算对比值。当对比度值较大时，我们认为需要进行抗锯齿处理。

实现比较容易，计算上下左右中间五个像素，求亮度，之后取最大值和最小值，如果差距过小，就当作不是边界，直接返回原数据

//////////////////////////////////////////// 1. 求亮度差 ////////////////////////////////////////////
vec2 texCoords = (vec2(invocID) + 0.5f) / vec2(textureSize);
float up = RGBtoLuminance(texture(sampler2D(historyTexture, SAMPLER[0]), texCoords + stepUV * Kernel_Map[1]).xyz);
float down = RGBtoLuminance(texture(sampler2D(historyTexture, SAMPLER[0]), texCoords + stepUV * Kernel_Map[7]).xyz);
float left = RGBtoLuminance(texture(sampler2D(historyTexture, SAMPLER[0]), texCoords + stepUV * Kernel_Map[3]).xyz);
float right = RGBtoLuminance(texture(sampler2D(historyTexture, SAMPLER[0]), texCoords + stepUV * Kernel_Map[5]).xyz);
float center = RGBtoLuminance(texture(sampler2D(historyTexture, SAMPLER[0]), texCoords).xyz);

float maxLum = max(center, max(max(up, down), max(left, right)));
float minLum = min(center, min(min(up, down), min(left, right)));
float Contrast =  maxLum - minLum;
if(Contrast < max(EDGE_THRESHOLD_MIN, maxLum * EDGE_THRESHOLD_MAX)) {
    vec4 outcolor = texture(sampler2D(historyTexture, SAMPLER[0]), texCoords);
    return;
}    
imageStore(out_texture, invocID, vec4(1,0,0,1));

看看效果，可以看到大部分点都认为是不需要进行处理的地方

基于亮度的混合系数计算

一方面考虑亮度差，另一方面考虑距离（对角线上的像素距离中心像素远一些）

//////////////////////////////////////////// 2. 计算基于亮度的混合系数计算 ////////////////////////////////////////////

float Filter = 2.0 * (N + E + S + W) + NE + NW + SE + SW;
Filter = Filter / 12.0;

Filter = abs(Filter - M);
Filter = saturate(Filter / Contrast);

float PixelBlend = smoothstep(0.0, 1.0, Filter);
PixelBlend = PixelBlend * PixelBlend;

计算混合方向与混合

锯齿的方向不一定一样，通过亮度差异来计算锯齿方向

计算完偏移方向后，最终采样点就往锯齿方向偏移，偏移量就是上一步获得的权重

    //////////////////////////////////////////// 3. 计算锯齿方向并混合 ////////////////////////////////////////////
    float Vertical = abs(N + S - 2 * M) * 2+ abs(NE + SE - 2 * E) + abs(NW + SW - 2 * W);
    float Horizontal = abs(E + W - 2 * M) * 2 + abs(NE + NW - 2 * N) + abs(SE + SW - 2 * S);
    bool IsHorizontal = Vertical > Horizontal;  // 垂直方向上亮度变化大，说明锯齿是水平的
    vec2 PixelStep = IsHorizontal ? vec2(0, stepUV.y) : vec2(stepUV.x, 0);
    float Positive = abs((IsHorizontal ? N : E) - M);
    float Negative = abs((IsHorizontal ? S : W) - M);
    if(Positive < Negative) PixelStep = -PixelStep;   // PixelStep往亮度大方向移动

    vec4 outcolor = texture(sampler2D(historyTexture, SAMPLER[0]), texCoords + PixelStep * PixelBlend);

更准确的混合系数

上述简化的方法是有问题的：

如下图1是要进行抗锯齿的图片

图2是上述方法的结果，在边界上很多像素结果都是一致的，因为在9宫格范围内他们的表现一致，但实际上考虑到这个锯齿是斜向的，所以越靠右的像素（第二排应该越靠近黑色去采样，而不是白色）

图三效果就好了

计算混合时，在锯齿方向上左右采样，直到找到锯齿的边界

看左右两边到达锯齿边界的距离远近，像素的混合系数应该更趋向于离得更近的锯齿边界的颜色

锯齿的边界其实可以理解为上下像素差距不大的地方，如上图的左右边界，他们要么是全红了，要么是全白了，

所以离全红更近，就偏向红，否则偏向白色

如下图点离右侧锯齿边界更近，那它应该更黑一点（假设三角形内部是黑色）

游戏引擎开发实践（基础架构）

Fri, 09 Jan 2026 17:16:11 +0800

渲染架构

RHI

RHI相关的资源全部被封装位RHIResource

enum RHIResourceType : uint32_t
{
    // 基础资源
    RHI_BUFFER = 0,
    RHI_TEXTURE,
    RHI_TEXTURE_VIEW,
    RHI_SAMPLER,
    RHI_SHADER,

    // 光追
    RHI_SHADER_BINDING_TABLE,
    RHI_TOP_LEVEL_ACCELERATION_STRUCTURE,
    RHI_BOTTOM_LEVEL_ACCELERATION_STRUCTURE,

    // 资源描述符
    RHI_ROOT_SIGNATURE,
    RHI_DESCRIPTOR_SET,

    // 渲染Pass
    RHI_RENDER_PASS,
    RHI_GRAPHICS_PIPELINE,
    RHI_COMPUTE_PIPELINE,
    RHI_RAY_TRACING_PIPELINE,

    // 底层相关
    RHI_QUEUE,
    RHI_SURFACE,
    RHI_SWAPCHAIN,
    RHI_COMMAND_POOL,

    RHI_COMMAND_CONTEXT,
    RHI_COMMAND_CONTEXT_IMMEDIATE,

    // 同步
    RHI_FENCE,
    RHI_SEMAPHORE,

    RHI_RESOURCE_TYPE_MAX_CNT,	//
};

RHIResource基类

class RHIResource
{
public:
    RHIResource() = delete;
    RHIResource(RHIResourceType resourceType) : resourceType(resourceType) {};
    virtual ~RHIResource() {};

    inline RHIResourceType GetType() { return resourceType; }

    virtual void* RawHandle() { return nullptr; };		// 底层资源的裸指针，仅debug时使用
    void printRawHandle();
private:
    RHIResourceType resourceType;
    uint32_t lastUseTick = 0;

    virtual void Destroy() {};

    friend class DynamicRHI;
};

每个RHI资源都拥有自己的类来管理

class RHITexture : public RHIResource
{
public:
	RHITexture(const RHITextureInfo& info): RHIResource(RHI_TEXTURE), info(info){}

	Extent3D MipExtent(uint32_t mipLevel);

	inline const TextureSubresourceRange& GetDefaultSubresourceRange() const { return defaultRange; }
	inline const TextureSubresourceLayers& GetDefaultSubresourceLayers() const { return defaultLayers; }

	inline const RHITextureInfo& GetInfo() const { return info; }

protected:
	RHITextureInfo info;

	TextureSubresourceRange defaultRange = {};
	TextureSubresourceLayers defaultLayers = {};
};

class RHIBuffer : public RHIResource
{
public:
    RHIBuffer(const RHIBufferInfo& info)
        : RHIResource(RHI_BUFFER)
        , info(info)
    {
    }

    virtual void* Map() = 0;
    virtual void UnMap() = 0;

    inline const RHIBufferInfo& GetInfo() const { return info; }

protected:
    RHIBufferInfo info;
};

DynamicRHI

负责不需要Context的RHI命令，比如创建纹理、Buffer、Fence等
负责API Context的创建

class DynamicRHI {
private:
	static DynamicRHIRef s_DynamicRHI;
public:
    static DynamicRHIRef Init(RHIConfig config);
	static DynamicRHIRef Get(){return s_DynamicRHI;}

	virtual void Tick();    // 更新资源计数，清理无引用且长时间未使用资源
	virtual void InitImGui(GLFWwindow* window) = 0;
	virtual RHIDescriptorSetRef GetImGuiTextId(RHITextureViewRef textureView) = 0;
	virtual void Destroy();
	virtual RHIComputePipelineRef CreateComputePipeline(const RHIComputePipelineInfo& info) = 0;
	virtual RHITopLevelAccelerationStructureRef CreateTopLevelAccelerationStructure(const RHITopLevelAccelerationStructureInfo& info) = 0;
	virtual RHIShaderBindingTableRef CreateShaderBindingTable(const RHIShaderBindingTableInfo& info) = 0;

	virtual RHIRayTracingPipelineRef CreateRayTracingPipeline(const RHIRayTracingPipelineInfo& info) = 0;

	virtual RHIBottomLevelAccelerationStructureRef CreateBottomLevelAccelerationStructure(const RHIBottomLevelAccelerationStructureInfo& info) = 0;
	virtual RHIQueueRef GetQueue(const RHIQueueInfo& info) = 0;
	virtual RHISurfaceRef CreateSurface(GLFWwindow* window) = 0;
	virtual RHISwapchainRef CreateSwapChain(const RHISwapchainInfo& info) = 0;
	virtual RHICommandPoolRef CreateCommandPool(const RHICommandPoolInfo& info) = 0;
	virtual RHICommandContextRef CreateCommandContext(RHICommandPoolRef pool) = 0;
	virtual RHITextureRef CreateTexture(const RHITextureInfo& info) = 0;
	virtual RHITextureViewRef CreateTextureView(const RHITextureViewInfo& info) = 0;
	virtual RHISamplerRef CreateSampler(const RHISamplerInfo& info) = 0;
	virtual RHIShaderRef CreateShader(const RHIShaderInfo& info) = 0;
	virtual RHIBufferRef CreateBuffer(const RHIBufferInfo& info) = 0;
	virtual RHIGraphicsPipelineRef CreateGraphicsPipeline(const RHIGraphicsPipelineInfo& info) = 0;
	virtual RHIRenderPassRef CreateRenderPass(const RHIRenderPassInfo& info) = 0;
	virtual RHIRootSignatureRef CreateRootSignature(const RHIRootSignatureInfo& info) = 0;

	// 同步
	virtual RHIFenceRef CreateFence(bool signaled) = 0;
	virtual RHISemaphoreRef CreateSemaphore() = 0;
	virtual RHICommandListImmediateRef GetImmediateCommandList() = 0;
	void RegisterResource(RHIResourceRef resource) { resourceMap[resource->GetType()].push_back(resource); }
	RHIConfig& GetConfig() { return m_Config; }
	bool isEnableRayTracing() { return m_Config.enableRayTracing; }
protected:
	DynamicRHI(const RHIConfig& config) : m_Config(config) {};

	std::array<std::vector<RHIResourceRef>, RHI_RESOURCE_TYPE_MAX_CNT> resourceMap;
    RHIConfig m_Config;
};

另外他还维护一个resourceMap（每种资源一个Vector），每帧Tick

void DynamicRHI::Tick()
{
    for (auto& resources : resourceMap)
    {
        bool needClean = false;
        for (RHIResourceRef& resource : resources)
        {
            if (resource)
            {
                if (resource.use_count() == 1)   resource->lastUseTick++;
                else                            resource->lastUseTick = 0;

                if (resource->lastUseTick > 6)  //析构资源6帧后销毁
                {
                    needClean = true;
                     //if(resource->GetType() != RHI_RENDER_PASS) 
                         // std::cout << "RHI resource [" << resource.get() << "] of type [" << resource->GetType() << "] destroied" << std::endl;
                    resource->Destroy();
                    resource = nullptr;
                }
            }
        }

        // 删除空指针
        if (needClean) {
            resources.erase(std::remove_if(resources.begin(), resources.end(), [](RHIResourceRef x) {
                return x == nullptr;
                }), resources.end());
        }
    }
}

RHICommandContext，用于定义需要Commandbuffer的命令，内部持有RHICommandBuffer对象

	class RHICommandContext : public RHIResource {
	public:
		RHICommandContext(RHICommandPoolRef pool): RHIResource(RHI_COMMAND_CONTEXT), pool(pool){}
		virtual void BeginCommand() = 0;
		virtual void EndCommand() = 0;
		virtual void Execute(RHIFenceRef waitFence, RHISemaphoreRef waitSemaphore, RHISemaphoreRef signalSemaphore) = 0;
		virtual void TextureBarrier(const RHITextureBarrier& barrier) = 0;
		virtual void BufferBarrier(const RHIBufferBarrier& barrier) = 0;
		virtual void BeginRenderPass(RHIRenderPassRef renderPass) = 0;   //也可以运行时FindOrCreate相应的renderpass和framebuffer等，很多东西可以做中心化的查找表统一管理状态
		virtual void CopyTexture(RHITextureRef src, TextureSubresourceLayers srcSubresource, RHITextureRef dst, TextureSubresourceLayers dstSubresource) = 0;
		virtual void GenerateMips(RHITextureRef src) = 0;
		virtual void SetViewport(Offset2D min, Offset2D max) = 0;

		virtual void SetScissor(Offset2D min, Offset2D max) = 0;

		virtual void SetDepthBias(float constantBias, float slopeBias, float clampBias) = 0;
		virtual void SetLineWidth(float width) = 0;

		virtual void SetGraphicsPipeline(RHIGraphicsPipelineRef graphicsPipeline) = 0;

		virtual void SetComputePipeline(RHIComputePipelineRef computePipeline) = 0;
		virtual void PushLabel(const std::string& name, Color3 color = { 1.0f, 1.0f, 1.0f }) = 0;

		virtual void PopLabel() = 0;
		virtual void SetRayTracingPipeline(RHIRayTracingPipelineRef rayTracingPipeline) = 0;

		virtual void PushConstants(void* data, uint16_t size, ShaderFrequency frequency) = 0;

		virtual void BindDescriptorSet(RHIDescriptorSetRef descriptor, uint32_t set) = 0;

		virtual void BindVertexBuffer(RHIBufferRef vertexBuffer, uint32_t streamIndex, uint32_t offset) = 0;

		virtual void BindIndexBuffer(RHIBufferRef indexBuffer, uint32_t offset) = 0;

		virtual void Dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) = 0;

		virtual void DispatchIndirect(RHIBufferRef argumentBuffer, uint32_t argumentOffset) = 0;

		virtual void TraceRays(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) = 0;

		virtual void Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) = 0;

		virtual void DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, uint32_t vertexOffset, uint32_t firstInstance) = 0;

		virtual void DrawIndirect(RHIBufferRef argumentBuffer, uint32_t offset, uint32_t drawCount) = 0;

		virtual void DrawIndexedIndirect(RHIBufferRef argumentBuffer, uint32_t offset, uint32_t drawCount) = 0;
		virtual void EndRenderPass() = 0;
		virtual std::vector<RHIGPUTimeInfo> GetGPUTime() = 0;
		virtual void ImGuiRenderDrawData() = 0;

	protected:
		RHICommandPoolRef pool;
	};

VulkanRHICommandContextImmediate负责临时命令执行和提交

class RHICommandContextImmediate : public RHIResource
{
public:
    RHICommandContextImmediate(): RHIResource(RHI_COMMAND_CONTEXT_IMMEDIATE){}

    virtual void Flush() = 0;
    virtual void GenerateMips(RHITextureRef src) = 0;
    virtual void TextureBarrier(const RHITextureBarrier& barrier) = 0;
    virtual void CopyBufferToTexture(RHIBufferRef src, uint64_t srcOffset, RHITextureRef dst, TextureSubresourceLayers dstSubresource) = 0;
    virtual void ImGuiUploadFonts() = 0;
};

RHICommandList负责为上层（RDG）提供服务

class RHICommandList {
public:
	RHICommandList(const CommandListInfo& info) : info(info) {}
	void BeginCommand();
	void EndCommand();
	void TextureBarrier(const RHITextureBarrier& barrier);
	void BeginRenderPass(RHIRenderPassRef renderPass);
	void CopyTexture(RHITextureRef src, TextureSubresourceLayers srcSubresource, RHITextureRef dst, TextureSubresourceLayers dstSubresource);

	void GenerateMips(RHITextureRef src);
	void EndRenderPass();
	void BufferBarrier(const RHIBufferBarrier& barrier);
	void Execute(RHIFenceRef fence = nullptr, RHISemaphoreRef waitSemaphore = nullptr, RHISemaphoreRef signalSemaphore = nullptr);
	void SetViewport(Offset2D min, Offset2D max);

	void SetScissor(Offset2D min, Offset2D max);

	void SetDepthBias(float constantBias, float slopeBias, float clampBias);
	void PushLabel(const std::string& name, Color3 color = { 1.0f, 1.0f, 1.0f });
	void PopLabel();
	void SetLineWidth(float width);

	void SetGraphicsPipeline(RHIGraphicsPipelineRef graphicsPipeline);
	void SetRayTracingPipeline(RHIRayTracingPipelineRef rayTracingPipeline);
	void SetComputePipeline(RHIComputePipelineRef computePipeline);
	void PushConstants(void* data, uint16_t size, ShaderFrequency frequency);

	void BindDescriptorSet(RHIDescriptorSetRef descriptor, uint32_t set = 0);

	void BindVertexBuffer(RHIBufferRef vertexBuffer, uint32_t streamIndex = 0, uint32_t offset = 0);

	void BindIndexBuffer(RHIBufferRef indexBuffer, uint32_t offset = 0);

	void Dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);

	void DispatchIndirect(RHIBufferRef argumentBuffer, uint32_t argumentOffset = 0);

	void TraceRays(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);

	void Draw(uint32_t vertexCount, uint32_t instanceCount = 1, uint32_t firstVertex = 0, uint32_t firstInstance = 0);

	void DrawIndexed(uint32_t indexCount, uint32_t instanceCount = 1, uint32_t firstIndex = 0, uint32_t vertexOffset = 0, uint32_t firstInstance = 0);

	void DrawIndirect(RHIBufferRef argumentBuffer, uint32_t offset, uint32_t drawCount);

	void DrawIndexedIndirect(RHIBufferRef argumentBuffer, uint32_t offset, uint32_t drawCount);
	void ImGuiRenderDrawData();

public:
	std::vector<RHIGPUTimeInfo> GetGPUTime();
	uint32_t GetDrawCallCount() { return drawCallCount; }
	void ClearDrawCallCount() { drawCallCount = 0; }
protected:
	inline void AddCommand(RHICommand* command) { commands.push_back(command); }
private:
	std::vector<RHICommand*> commands;
	CommandListInfo info;
	uint32_t drawCallCount = 0;
};

他的各个函数其实和RHICommandContext是一致的，但是实现上是可以直接执行底层函数，也可以缓存

void RHICommandList::BeginCommand()
{
	COMMANDLIST_DEBUG_OUTPUT();
	if (info.byPass) info.context->BeginCommand();
	else ADD_COMMAND(BeginCommand);
}

命令的缓存是通过ADD_COMMAND

#define ADD_COMMAND(commandName, ...) do { \
    RHICommand* command = new RHICommand##commandName(__VA_ARGS__);  \
    AddCommand(command); \
} while (0)

// commands的指针存在一个Vector，最终执行依次执行即可
    std::vector<RHICommandImmediate*> commands;

所以说每个命令都是一个类

struct RHICommandBeginCommand : public RHICommand
{
    RHICommandBeginCommand() {}
    virtual void Execute(RHICommandContextRef context) override final;
};

执行CommandList

void RHICommandList::Execute(RHIFenceRef fence, RHISemaphoreRef waitSemaphore, RHISemaphoreRef signalSemaphore)
{
    if (!info.byPass)
    {
        // LOG_DEBUG("Recording command list in delay mode.");
        for (int32_t i = 0; i < commands.size(); i++)
        {
            commands[i]->Execute(info.context);
            delete commands[i];
        }
        commands.clear();
    }

    info.context->Execute(fence, waitSemaphore, signalSemaphore);
}

RDG

RDFNode: 分为资源Node和PassNode

资源Node分为BufferNode和TextureNode，PassNode有图形、计算、光追、Copy、呈现五种

enum RDGPassNodeType
{
    RDG_PASS_NODE_TYPE_RENDER = 0,
    RDG_PASS_NODE_TYPE_COMPUTE,
    RDG_PASS_NODE_TYPE_RAY_TRACING,
    RDG_PASS_NODE_TYPE_PRESENT,
    RDG_PASS_NODE_TYPE_COPY,

    RDG_PASS_NODE_TYPE_MAX_ENUM,    //
};

enum RDGResourceNodeType
{
    RDG_RESOURCE_NODE_TYPE_TEXTURE = 0,
    RDG_RESOURCE_NODE_TYPE_BUFFER,

    RDG_RESOURCE_NODE_TYPE_MAX_ENUM,    //
};

// PassNode需要的Context
typedef struct RDGPassContext
{
    RHICommandListRef command;
    RDGBuilder* builder;
    std::array<RHIDescriptorSetRef, MAX_DESCRIPTOR_SETS> descriptors;
    uint32_t passIndex[3] = { 0, 0, 0 };
} RDGPassContext;

// Node基类
class RDGNode : public DependencyGraph::Node
{
public:
    RDGNode(std::string name)
        : name(name)
    {
    }

    const std::string& Name() { return name; }

private:
    std::string name;
};
typedef RDGNode* RDGNodeRef;


 // 资源节点/////////////////////////////////////////////////////////////////////////////////////
 class RDGResourceNode : public RDGNode
 {
 public:
     RDGResourceNode(std::string name, RDGResourceNodeType nodeType)
         : RDGNode(name)
         , nodeType(nodeType)
     {
     }

     inline bool IsImported() { return isImported; }

     RDGResourceNodeType NodeType() { return nodeType; }

 protected:
     RDGResourceNodeType nodeType;
     bool isImported = false;
 };
 typedef RDGResourceNode* RDGResourceNodeRef;

 class RDGTextureNode : public RDGResourceNode
 {
 public:
     RDGTextureNode(std::string name): RDGResourceNode(name, RDG_RESOURCE_NODE_TYPE_TEXTURE){}

     void ForEachPass(const std::function<void(RDGTextureEdgeRef, class RDGPassNode*)>& func);

     RDGTextureHandle GetHandle() { return RDGTextureHandle(ID()); }

     const RHITextureInfo& GetInfo() { return info; }
     RHITextureRef GetRHITexture() { return texture; }
 private:
     RHITextureInfo info;
     RHIResourceState initState; // 从池中/外部引用时的最初状态

     RHITextureRef texture;      // 执行时分配和绑定，会动态更新，在最后一个依赖pass完成后返回资源池

     friend class RDGTextureBuilder;
     friend class RDGBuilder;
 };
 typedef RDGTextureNode* RDGTextureNodeRef;

 class RDGBufferNode : public RDGResourceNode
 {
 public:
     RDGBufferNode(std::string name): RDGResourceNode(name, RDG_RESOURCE_NODE_TYPE_BUFFER){}

     void ForEachPass(const std::function<void(RDGBufferEdgeRef, class RDGPassNode*)>& func);

     RDGBufferHandle GetHandle() { return RDGBufferHandle(ID()); }

     const RHIBufferInfo& GetInfo() { return info; }

 private:
     RHIBufferInfo info;
     RHIResourceState initState; // 从池中/外部引用时的最初状态

     RHIBufferRef buffer;        // 执行时分配和绑定，会动态更新，在最后一个依赖pass完成后返回资源池

     friend class RDGBufferBuilder;
     friend class RDGBuilder;
 };
 typedef RDGBufferNode* RDGBufferNodeRef;


// pass节点/////////////////////////////////////////////////////////////////////////////////////

class RDGPassNode : public RDGNode
{
public:
    RDGPassNode(std::string name, RDGPassNodeType nodeType)
        : RDGNode(name)
        , nodeType(nodeType)
    {
    }

    inline bool Before(RDGPassNode* other) { return ID() < other->ID(); }    // 假定所有pass的添加顺序就是执行顺序
    inline bool After(RDGPassNode* other) { return ID() > other->ID(); }

    void ForEachTexture(const std::function<void(RDGTextureEdgeRef, RDGTextureNodeRef)>& func);
    void ForEachBuffer(const std::function<void(RDGBufferEdgeRef, RDGBufferNodeRef)>& func);
    Color3 GetLabelColor() { return LabelColor; }
    void SetLabelColor(Color3 color) { LabelColor = color; }
    RDGPassNodeType NodeType() { return nodeType; }

protected:
    RDGPassNodeType nodeType;
    bool isCulled = false;
    Color3 LabelColor = { 1.0f, 1.0f, 1.0f };

    RHIRootSignatureRef rootSignature;
    std::array<RHIDescriptorSetRef, MAX_DESCRIPTOR_SETS> descriptorSets;

    std::vector<RHITextureViewRef> pooledViews;             // 动态分配的池化资源，执行完毕后返回资源池
    std::vector<std::pair<RHIDescriptorSetRef, uint32_t>> pooledDescriptorSets;

    friend class RDGBuilder;
};
typedef RDGPassNode* RDGPassNodeRef;


class RDGRenderPassNode : public RDGPassNode
{
public:
    RDGRenderPassNode(std::string name)
        : RDGPassNode(name, RDG_PASS_NODE_TYPE_RENDER)
    {
    }

    RDGRenderPassHandle GetHandle() { return RDGRenderPassHandle(ID()); }
private:
    uint32_t passIndex[3] = { 0, 0, 0 };
    RDGPassExecuteFunc execute;
    friend class RDGRenderPassBuilder;
    friend class RDGBuilder;
};
typedef RDGRenderPassNode* RDGRenderPassNodeRef;

class RDGComputePassNode : public RDGPassNode
{
public:
    RDGComputePassNode(std::string name)
        : RDGPassNode(name, RDG_PASS_NODE_TYPE_COMPUTE)
    {
    }

    RDGComputePassHandle GetHandle() { return RDGComputePassHandle(ID()); }
private:
    uint32_t passIndex[3] = { 0, 0, 0 };
    RDGPassExecuteFunc execute;

    friend class RDGComputePassBuilder;
    friend class RDGBuilder;
};
typedef RDGComputePassNode* RDGComputePassNodeRef;

class RDGRayTracingPassNode : public RDGPassNode
{
public:
    RDGRayTracingPassNode(std::string name)
        : RDGPassNode(name, RDG_PASS_NODE_TYPE_RAY_TRACING)
    {
    }

    RDGRayTracingPassHandle GetHandle() { return RDGRayTracingPassHandle(ID()); }
private:
    uint32_t passIndex[3] = { 0, 0, 0 };
    RDGPassExecuteFunc execute;

    friend class RDGRayTracingPassBuilder;
    friend class RDGBuilder;
};
typedef RDGRayTracingPassNode* RDGRayTracingPassNodeRef;

class RDGPresentPassNode : public RDGPassNode
{
public:
    RDGPresentPassNode(std::string name)
        : RDGPassNode(name, RDG_PASS_NODE_TYPE_PRESENT)
    {
    }

    RDGPresentPassHandle GetHandle() { return RDGPresentPassHandle(ID()); }
private:
    friend class RDGPresentPassBuilder;
    friend class RDGBuilder;
};
typedef RDGPresentPassNode* RDGPresentPassNodeRef;

class RDGCopyPassNode : public RDGPassNode
{
public:
    RDGCopyPassNode(std::string name)
        : RDGPassNode(name, RDG_PASS_NODE_TYPE_COPY)
    {
    }

    RDGCopyPassHandle GetHandle() { return RDGCopyPassHandle(ID()); }
private:
    bool generateMip = false;

    friend class RDGCopyPassBuilder;
    friend class RDGBuilder;
};
typedef RDGCopyPassNode* RDGCopyPassNodeRef;

RDGEdge 定义Pass如何访问某个资源,分为TextureEdge和BufferEdge

边用于定义一个Pass如何访问一个资源，并且标识了资源在资源描述符集的位置（Set Binding），另外需要知道Pass访问这个资源需要这个资源处于哪种状态

 enum RDGEdgeType
 {
     RDG_EDGE_TYPE_TEXTURE = 0,
     RDG_EDGE_TYPE_BUFFER,

     RDG_EDGE_TYPE_MAX_ENUM,    //
 };

class RDGEdge : public DependencyGraph::Edge
{
public:
    RDGEdge(RDGEdgeType edgeType, RHIResourceState state = RESOURCE_STATE_UNDEFINED): state(state), edgeType(edgeType){}

    virtual bool IsOutput() { return false; }

    RDGEdgeType EdgeType() { return edgeType; }

    RHIResourceState state; // 在对应的pass处要求的状态（若作为pass输入，pass不应在内部改变状态）

protected:
    RDGEdgeType edgeType;
};
typedef RDGEdge* RDGEdgeRef;

class RDGTextureEdge : public RDGEdge
{
public:
    RDGTextureEdge()
        : RDGEdge(RDG_EDGE_TYPE_TEXTURE)
    {
    }

    TextureSubresourceRange subresource = {};
    TextureSubresourceLayers subresourceLayer = {};  // 单层mip，多层layer

    // 下面这些每种标记都对应一种用法
    bool asColor = false;   // 颜色缓冲标记
    bool asDepthStencil = false; // 深度缓冲标记
    bool asShaderRead = false;
    bool asShaderReadWrite = false;
    bool asOutputRead = false;
    bool asOutputReadWrite = false;
    bool asPresent = false;
    bool asTransferSrc = false;
    bool asTransferDst = false;

    virtual bool IsOutput() override { return asOutputRead || asOutputReadWrite; }

    uint32_t set = 0; 
    uint32_t binding = 0;
    uint32_t index = 0;
    ResourceType type = RESOURCE_TYPE_TEXTURE;
    TextureViewType viewType = VIEW_TYPE_2D;

    AttachmentLoadOp 	loadOp = ATTACHMENT_LOAD_OP_DONT_CARE; 
    AttachmentStoreOp	storeOp = ATTACHMENT_STORE_OP_DONT_CARE;

    Color4				clearColor = { 0.0f, 0.0f, 0.0f, 0.0f };
    float				clearDepth = 1.0f;
    uint32_t			clearStencil = 0;
};

class RDGBufferEdge : public RDGEdge
{
public:
    RDGBufferEdge()
        : RDGEdge(RDG_EDGE_TYPE_BUFFER)
    {
    }

    uint32_t offset = 0;
    uint32_t size = 0;
    bool asShaderRead = false;   // Shader会读取
    bool asShaderReadWrite = false;
    bool asOutputRead = false;
    bool asOutputReadWrite = false;
    bool asOutputIndirectDraw = false;

    virtual bool IsOutput() override { return asOutputRead || asOutputReadWrite || asOutputIndirectDraw; }

    uint32_t set = 0;       // 描述符使用
    uint32_t binding = 0;
    uint32_t index = 0;
    ResourceType type = RESOURCE_TYPE_UNIFORM_BUFFER;
};
typedef RDGBufferEdge* RDGBufferEdgeRef;

RDGResoruceHandle 给每个Node一个ID

using NodeID = DependencyGraph::NodeID;

class RDGResoruceHandle
{
public:
    RDGResoruceHandle(NodeID id) : id(id) {}

    bool operator< (const RDGResoruceHandle& other) const noexcept {
        return id < other.id;
    }

    bool operator== (const RDGResoruceHandle& other) const noexcept {
        return (id == other.id);
    }

    bool operator!= (const RDGResoruceHandle& other) const noexcept {
        return !operator==(other);
    }

    inline NodeID ID() { return id; }

protected:
    NodeID id = UINT32_MAX;
};

class RDGPassHandle : public RDGResoruceHandle
{
public:
    RDGPassHandle(NodeID id) : RDGResoruceHandle(id) {};
};

class RDGRenderPassHandle : public RDGPassHandle
{
public:
    RDGRenderPassHandle(NodeID id) : RDGPassHandle(id) {};
};

class RDGComputePassHandle : public RDGPassHandle
{
public:
    RDGComputePassHandle(NodeID id) : RDGPassHandle(id) {};
};

class RDGRayTracingPassHandle : public RDGPassHandle
{
public:
    RDGRayTracingPassHandle(NodeID id) : RDGPassHandle(id) {};
};

class RDGPresentPassHandle : public RDGPassHandle
{
public:
    RDGPresentPassHandle(NodeID id) : RDGPassHandle(id) {};
};

class RDGCopyPassHandle : public RDGPassHandle
{
public:
    RDGCopyPassHandle(NodeID id) : RDGPassHandle(id) {};
};

class RDGTextureHandle : public RDGResoruceHandle
{
public:
    RDGTextureHandle(NodeID id) : RDGResoruceHandle(id) {};
};

class RDGBufferHandle : public RDGResoruceHandle
{
public:
    RDGBufferHandle(NodeID id) : RDGResoruceHandle(id) {};
};

RDGPool 负责资源的复用

被池化的资源有：Buffer、Texture、ImageView、DescriptorSet

    class RDGBufferPool
    {
    public:
        struct PooledBuffer
        {
            RHIBufferRef buffer;
            RHIResourceState state;
        };

        struct Key
        {
            Key(const RHIBufferInfo& info)
                : memoryUsage(info.memoryUsage)
                , type(info.type)
                , creationFlag(info.creationFlag)
            {
            }
            MemoryUsage memoryUsage;
            ResourceType type;
            BufferCreationFlags creationFlag;

            friend bool operator== (const Key& a, const Key& b)
            {
                return  a.memoryUsage == b.memoryUsage &&
                    a.type == b.type &&
                    a.creationFlag == b.creationFlag;
            }

            struct Hash {
                size_t operator()(const Key& a) const {
                    return MurmurHash64A(&a, sizeof(Key), 0);
                }
            };
        };

        PooledBuffer Allocate(const RHIBufferInfo& info);
        void Release(const PooledBuffer& pooledBuffer);

        inline uint32_t PooledSize() { return pooledSize; }
        inline uint32_t AllocatedSize() { return allocatedSize; }
        void Clear() { pooledBuffers.clear(); pooledSize = 0; }

        static std::shared_ptr<RDGBufferPool> Get()
        {
            static std::shared_ptr<RDGBufferPool> pool;
            if (pool == nullptr) pool = std::make_shared<RDGBufferPool>();
            return pool;
        }

    private:
        std::unordered_map<Key, std::list<PooledBuffer>, Key::Hash> pooledBuffers;  // Key一样的Buffer也有一个List（双向链表）
        uint32_t pooledSize = 0;
        uint32_t allocatedSize = 0;
    };


    class RDGTexturePool
    {
    public:
        struct PooledTexture
        {
            RHITextureRef texture;
            RHIResourceState state;
        };

        struct Key
        {
            Key(const RHITextureInfo& info)
                : info(info)
            {
            }

            RHITextureInfo info;

            friend bool operator== (const Key& a, const Key& b)
            {
                return  a.info == b.info;
            }

            struct Hash {
                size_t operator()(const Key& a) const {
                    return MurmurHash64A(&a, sizeof(Key), 0);
                }
            };
        };

        PooledTexture Allocate(const RHITextureInfo& info);
        void Release(const PooledTexture& pooledTexture);

        inline uint32_t PooledSize() { return pooledSize; }
        inline uint32_t AllocatedSize() { return allocatedSize; }
        void Clear() { pooledTextures.clear(); pooledSize = 0; }

        static std::shared_ptr<RDGTexturePool> Get()
        {
            static std::shared_ptr<RDGTexturePool> pool;
            if (pool == nullptr) pool = std::make_shared<RDGTexturePool>();
            return pool;
        }

    private:
        std::unordered_map<Key, std::list<PooledTexture>, Key::Hash> pooledTextures;   // 每个Key对应一个List而不是一个Texture
        uint32_t pooledSize = 0;
        uint32_t allocatedSize = 0;
    };


    class RDGTextureViewPool
    {
    public:
        struct PooledTextureView
        {
            RHITextureViewRef textureView;
        };

        struct Key
        {
            Key(const RHITextureViewInfo& info)
                : info(info)
            {
            }

            RHITextureViewInfo info;

            friend bool operator== (const Key& a, const Key& b)
            {
                return  a.info == b.info;
            }

            struct Hash {
                size_t operator()(const Key& a) const {
                    return MurmurHash64A(&a.info, sizeof(RHITextureViewInfo), 0);
                }
            };
        };

        PooledTextureView Allocate(const RHITextureViewInfo& info);
        void Release(const PooledTextureView& pooledTextureView);

        inline uint32_t PooledSize() { return pooledSize; }
        inline uint32_t AllocatedSize() { return allocatedSize; }
        void Clear() { pooledTextureViews.clear(); pooledSize = 0; }

        static std::shared_ptr<RDGTextureViewPool> Get()
        {
            static std::shared_ptr<RDGTextureViewPool> pool;
            if (pool == nullptr) pool = std::make_shared<RDGTextureViewPool>();
            return pool;
        }

    private:
        std::unordered_map<Key, std::list<PooledTextureView>, Key::Hash> pooledTextureViews;
        uint32_t pooledSize = 0;
        uint32_t allocatedSize = 0;
    };

    class RDGDescriptorSetPool
    {
    public:
        struct PooledDescriptor
        {
            RHIDescriptorSetRef descriptor;
        };

        struct Key  // 根签名和Set一致就可以复用
        {
            Key(const RHIRootSignatureInfo& info, uint32_t set)
                : entries(info.GetEntries())
                , set(set)
            {
            }

            std::vector<ShaderResourceEntry> entries;
            uint32_t set;

            friend bool operator== (const Key& a, const Key& b)
            {
                return  a.entries == b.entries &&
                    a.set == b.set;
            }

            struct HashEntries {
                size_t operator()(std::vector<ShaderResourceEntry> entries) const {
                    return MurmurHash64A(entries.data(), entries.size() * sizeof(ShaderResourceEntry), 0);
                }
            };

            struct Hash {
                size_t operator()(const Key& a) const {
                    return  std::hash<uint32_t>()(a.set) ^
                        (HashEntries()(a.entries) << 1);
                }
            };
        };

        PooledDescriptor Allocate(const RHIRootSignatureRef& rootSignature, uint32_t set);
        void Release(const PooledDescriptor& pooledDescriptor, const RHIRootSignatureRef& rootSignature, uint32_t set);

        inline uint32_t PooledSize() { return pooledSize; }
        inline uint32_t AllocatedSize() { return allocatedSize; }
        void Clear() { pooledDescriptors.clear(); pooledSize = 0; }

        static std::shared_ptr<RDGDescriptorSetPool> Get(uint32_t index)    // 描述符池需要FRAMES_IN_FLIGHT每帧一个，不然下一帧修改可能影响上一帧还未完成的渲染！！！
        {
            static std::shared_ptr<RDGDescriptorSetPool> pool[3];
            if (pool[index] == nullptr) pool[index] = std::make_shared<RDGDescriptorSetPool>();
            return pool[index];
        }

    private:
        std::unordered_map<Key, std::list<PooledDescriptor>, Key::Hash> pooledDescriptors;
        uint32_t pooledSize = 0;
        uint32_t allocatedSize = 0;
    };

RDGBuilder 负责构建图

#pragma once
#include "DependencyGraph.h"
#include "RDGHandle.h"
#include "RDGNode.h"
#include "Hazel/Renderer/RHI/RHICommandList.h"

#include <cstdint>
#include <memory>
#include <string>
#include <vector>
// #define RDG_DEBUG
/*
    RDGNode分为PassNode(RenderPass, ComputePass, RayTracingPass, CopyPass, PresentPass)和ResourceNode(TextureNode, BufferNode)
    RDGEdge用于存储 资源->Pass的View，用于在Pass时创建对应的view
*/
namespace GameEngine {

    // name->node
    class RDGBlackBoard
    {
    public:
        RDGPassNodeRef Pass(std::string name);
        RDGBufferNodeRef Buffer(std::string name);
        RDGTextureNodeRef Texture(std::string name);
#ifdef RDG_DEBUG
        std::string PassName(RDGPassNodeRef pass);
        std::string BufferName(RDGBufferNodeRef buffer);
        std::string TextureName(RDGTextureNodeRef texture);
#endif
        void AddPass(RDGPassNodeRef pass);
        void AddBuffer(RDGBufferNodeRef buffer);
        void AddTexture(RDGTextureNodeRef texture);

        void Clear() { passes.clear(); buffers.clear(); textures.clear(); }

    private:
        std::unordered_map<std::string, RDGPassNodeRef> passes;
        std::unordered_map<std::string, RDGBufferNodeRef> buffers;
        std::unordered_map<std::string, RDGTextureNodeRef> textures;
#ifdef RDG_DEBUG
        std::unordered_map<RDGPassNodeRef,std::string> passeNames;
        std::unordered_map<RDGTextureNodeRef,std::string> textureNames;
        std::unordered_map<RDGBufferNodeRef,std::string> bufferNames;
#endif

    };

    class RDGBuilder
    {
    public:
        RDGBuilder() = default;
        RDGBuilder(RHICommandListRef command): command(command){}  // 给一个commandList

        ~RDGBuilder() {};

        RDGTextureBuilder CreateTexture(std::string name);
        RDGBufferBuilder CreateBuffer(std::string name);
        RDGRenderPassBuilder CreateRenderPass(std::string name);    // 假定所有pass的添加顺序就是执行顺序，方便处理排序和依赖关系等
        RDGComputePassBuilder CreateComputePass(std::string name);
        RDGRayTracingPassBuilder CreateRayTracingPass(std::string name);
        RDGPresentPassBuilder CreatePresentPass(std::string name);
        RDGCopyPassBuilder CreateCopyPass(std::string name);

        RDGTextureHandle GetTexture(std::string name);
        RDGBufferHandle GetBuffer(std::string name);
        RDGRenderPassHandle GetRenderPass(std::string name) { return GetPass<RDGRenderPassNodeRef, RDGRenderPassHandle>(name); }
        RDGComputePassHandle GetComputePass(std::string name) { return GetPass<RDGComputePassNodeRef, RDGComputePassHandle>(name); }
        RDGRayTracingPassHandle GetRayTracingPass(std::string name) { return GetPass<RDGRayTracingPassNodeRef, RDGRayTracingPassHandle>(name); }
        RDGPresentPassHandle GetPresentPass(std::string name) { return GetPass<RDGPresentPassNodeRef, RDGPresentPassHandle>(name); }
        RDGCopyPassHandle GetCopyPass(std::string name) { return GetPass<RDGCopyPassNodeRef, RDGCopyPassHandle>(name); }

        RHITextureRef GetRHITexture(std::string name) { return blackBoard.Texture(name)->GetRHITexture(); }
        DependencyGraphRef GetGraph() { return graph; }

        void Execute();

    private:
        void CreateInputBarriers(RDGPassNodeRef pass);
        void CreateOutputBarriers(RDGPassNodeRef pass);
        void PrepareDescriptorSet(RDGPassNodeRef pass);
        void PrepareRenderTarget(RDGRenderPassNodeRef pass, RHIRenderPassInfo& renderPassInfo);
        void ReleaseResource(RDGPassNodeRef pass);

        void ExecutePass(RDGRenderPassNodeRef pass);
        void ExecutePass(RDGComputePassNodeRef pass);
        void ExecutePass(RDGRayTracingPassNodeRef pass);
        void ExecutePass(RDGPresentPassNodeRef pass);
        void ExecutePass(RDGCopyPassNodeRef pass);

        template<typename Type, typename Handle>
        Handle GetPass(std::string name)
        {
            auto node = blackBoard.Pass(name);
            if (node == nullptr)
            {
                LOG_TRACE("Unable to find RDG resource, please check name!");
                return Handle(UINT32_MAX);
            }
            return dynamic_cast<Type>(node)->GetHandle();
        }
        // Resolve 创建真正的资源
        RHITextureRef Resolve(RDGTextureNodeRef textureNode);
        RHIBufferRef Resolve(RDGBufferNodeRef bufferNode);
        void Release(RDGTextureNodeRef textureNode, RHIResourceState state);
        void Release(RDGBufferNodeRef bufferNode, RHIResourceState state);

        RHIResourceState PreviousState(RDGTextureNodeRef textureNode, RDGPassNodeRef passNode, TextureSubresourceRange subresource = {}, bool output = false);    // 获取当前pass（在执行顺序上）的资源的前序状态
        RHIResourceState PreviousState(RDGBufferNodeRef bufferNode, RDGPassNodeRef passNode, uint32_t offset = 0, uint32_t size = 0, bool output = false);      // output用于标记是相对于输入还是输出资源
        bool IsLastUsedPass(RDGTextureNodeRef textureNode, RDGPassNodeRef passNode, bool output = false);
        bool IsLastUsedPass(RDGBufferNodeRef bufferNode, RDGPassNodeRef passNode, bool output = false);

        std::vector<RDGPassNodeRef> passes; // 创建的全部pass，按照创建顺序执行

        DependencyGraphRef graph = std::make_shared<DependencyGraph>();
        RDGBlackBoard blackBoard;

        RHICommandListRef command;
    };

    class RDGTextureBuilder
    {
    public:
        RDGTextureBuilder(RDGBuilder* builder, RDGTextureNodeRef texture)
            : builder(builder)
            , texture(texture) {
        };

        RDGTextureBuilder& Import(RHITextureRef texture, RHIResourceState initState);
        RDGTextureBuilder& Exetent(Extent3D extent);
        RDGTextureBuilder& Format(RHIFormat format);
        RDGTextureBuilder& MemoryUsage(MemoryUsage memoryUsage);
        RDGTextureBuilder& AllowReadWrite();
        RDGTextureBuilder& AllowRenderTarget();
        RDGTextureBuilder& AllowDepthStencil();
        RDGTextureBuilder& MipLevels(uint32_t mipLevels);
        RDGTextureBuilder& ArrayLayers(uint32_t arrayLayers);
        RDGTextureBuilder& CubeMap();

        RDGTextureHandle Finish() { return texture->GetHandle(); }

    private:
        RDGBuilder* builder;
        RDGTextureNodeRef texture;
    };

    class RDGBufferBuilder
    {
    public:
        RDGBufferBuilder(RDGBuilder* builder, RDGBufferNodeRef buffer)
            : builder(builder)
            , buffer(buffer) {
        };

        RDGBufferBuilder& Import(RHIBufferRef buffer, RHIResourceState initState);
        RDGBufferBuilder& Size(uint32_t size);
        RDGBufferBuilder& MemoryUsage(MemoryUsage memoryUsage);
        RDGBufferBuilder& AllowVertexBuffer();
        RDGBufferBuilder& AllowIndexBuffer();
        RDGBufferBuilder& AllowReadWrite();
        RDGBufferBuilder& AllowRead();

        RDGBufferHandle Finish() { return buffer->GetHandle(); }

    private:
        RDGBuilder* builder;
        RDGBufferNodeRef buffer;
    };

    class RDGRenderPassBuilder
    {
    public:
        RDGRenderPassBuilder(RDGBuilder* builder, RDGRenderPassNodeRef pass)
            : builder(builder)
            , pass(pass)
            , graph(builder->GetGraph()) {
        };

        RDGRenderPassBuilder& PassIndex(uint32_t x = 0, uint32_t y = 0, uint32_t z = 0);        // 给一个index设置函数方便给Execute传参
        RDGRenderPassBuilder& RootSignature(RHIRootSignatureRef rootSignature);                 // 若提供根签名未提供描述符，使用池化创建
        RDGRenderPassBuilder& DescriptorSet(uint32_t set, RHIDescriptorSetRef descriptorSet);   // 若提供了描述符，直接用相应的描述符
        
        // 创建边  默认View都是2D，如果需要cubeView，需要手动指定
        RDGRenderPassBuilder& Read(uint32_t set, uint32_t binding, uint32_t index, RDGBufferHandle buffer, uint32_t offset = 0, uint32_t size = 0);
        RDGRenderPassBuilder& Read(uint32_t set, uint32_t binding, uint32_t index, RDGTextureHandle texture, TextureViewType viewType = VIEW_TYPE_2D, TextureSubresourceRange subresource = {});
        RDGRenderPassBuilder& ReadWrite(uint32_t set, uint32_t binding, uint32_t index, RDGBufferHandle buffer, uint32_t offset = 0, uint32_t size = 0);   // 好像和read也没什么区别？
        RDGRenderPassBuilder& ReadWrite(uint32_t set, uint32_t binding, uint32_t index, RDGTextureHandle texture, TextureViewType viewType = VIEW_TYPE_2D, TextureSubresourceRange subresource = {});
        RDGRenderPassBuilder& LabelColor(Color3 color);
        RDGRenderPassBuilder& Color(uint32_t binding, RDGTextureHandle texture,
            AttachmentLoadOp load = ATTACHMENT_LOAD_OP_DONT_CARE,
            AttachmentStoreOp store = ATTACHMENT_STORE_OP_DONT_CARE,
            Color4 clearColor = { 0.0f, 0.0f, 0.0f, 0.0f },
            TextureSubresourceRange subresource = {});
        RDGRenderPassBuilder& DepthStencil(RDGTextureHandle texture,
            AttachmentLoadOp load = ATTACHMENT_LOAD_OP_DONT_CARE,
            AttachmentStoreOp store = ATTACHMENT_STORE_OP_DONT_CARE,
            float clearDepth = 1.0f,
            uint32_t clearStencil = 0,
            TextureSubresourceRange subresource = {});

        // 标识后续还会使用的资源，会用PassNode->ResourceNode
        RDGRenderPassBuilder& OutputRead(RDGBufferHandle buffer, uint32_t offset = 0, uint32_t size = 0);             // 在执行完Pass后作为输出，自动屏障，可能还会在其他地方使用
        RDGRenderPassBuilder& OutputRead(RDGTextureHandle texture, TextureSubresourceRange subresource = {});
        RDGRenderPassBuilder& OutputReadWrite(RDGBufferHandle buffer, uint32_t offset = 0, uint32_t size = 0);
        RDGRenderPassBuilder& OutputReadWrite(RDGTextureHandle texture, TextureSubresourceRange subresource = {});
        RDGRenderPassBuilder& Execute(const RDGPassExecuteFunc& execute);

        RDGRenderPassHandle Finish() { return pass->GetHandle(); }

    private:
        RDGBuilder* builder;
        RDGRenderPassNodeRef pass;

        DependencyGraphRef graph;
    };

    class RDGComputePassBuilder
    {
    public:
        RDGComputePassBuilder(RDGBuilder* builder, RDGComputePassNodeRef pass)
            : builder(builder)
            , pass(pass)
            , graph(builder->GetGraph()) {
        };

        RDGComputePassBuilder& PassIndex(uint32_t x = 0, uint32_t y = 0, uint32_t z = 0);        // 给一个index设置函数方便给Execute传参
        RDGComputePassBuilder& RootSignature(RHIRootSignatureRef rootSignature);                 // 若提供根签名未提供描述符，使用池化创建
        RDGComputePassBuilder& DescriptorSet(uint32_t set, RHIDescriptorSetRef descriptorSet);   // 若提供了描述符，直接用相应的描述符
        RDGComputePassBuilder& Read(uint32_t set, uint32_t binding, uint32_t index, RDGBufferHandle buffer, uint32_t offset = 0, uint32_t size = 0);
        RDGComputePassBuilder& Read(uint32_t set, uint32_t binding, uint32_t index, RDGTextureHandle texture, TextureViewType viewType = VIEW_TYPE_2D, TextureSubresourceRange subresource = {});
        RDGComputePassBuilder& ReadWrite(uint32_t set, uint32_t binding, uint32_t index, RDGBufferHandle buffer, uint32_t offset = 0, uint32_t size = 0);   // 好像和read也没什么区别？
        RDGComputePassBuilder& ReadWrite(uint32_t set, uint32_t binding, uint32_t index, RDGTextureHandle texture, TextureViewType viewType = VIEW_TYPE_2D, TextureSubresourceRange subresource = {});
        RDGComputePassBuilder& OutputRead(RDGBufferHandle buffer, uint32_t offset = 0, uint32_t size = 0);             // 在执行完Pass后作为输出，自动屏障，可能还会在其他地方使用
        RDGComputePassBuilder& OutputRead(RDGTextureHandle texture, TextureSubresourceRange subresource = {});
        RDGComputePassBuilder& OutputReadWrite(RDGBufferHandle buffer, uint32_t offset = 0, uint32_t size = 0);
        RDGComputePassBuilder& OutputReadWrite(RDGTextureHandle texture, TextureSubresourceRange subresource = {});
        RDGComputePassBuilder& OutputIndirectDraw(RDGBufferHandle buffer, uint32_t offset = 0, uint32_t size = 0);


        RDGComputePassBuilder& Execute(const RDGPassExecuteFunc& execute);

        RDGComputePassHandle Finish() { return pass->GetHandle(); }

    private:
        RDGBuilder* builder;
        RDGComputePassNodeRef pass;

        DependencyGraphRef graph;
    };

    class RDGRayTracingPassBuilder
    {
    public:
        RDGRayTracingPassBuilder(RDGBuilder* builder, RDGRayTracingPassNodeRef pass)
            : builder(builder)
            , pass(pass)
            , graph(builder->GetGraph()) {
        };

        RDGRayTracingPassBuilder& PassIndex(uint32_t x = 0, uint32_t y = 0, uint32_t z = 0);        // 给一个index设置函数方便给Execute传参
        RDGRayTracingPassBuilder& RootSignature(RHIRootSignatureRef rootSignature);                 // 若提供根签名未提供描述符，使用池化创建
        RDGRayTracingPassBuilder& DescriptorSet(uint32_t set, RHIDescriptorSetRef descriptorSet);   // 若提供了描述符，直接用相应的描述符
        RDGRayTracingPassBuilder& Read(uint32_t set, uint32_t binding, uint32_t index, RDGBufferHandle buffer, uint32_t offset = 0, uint32_t size = 0);
        RDGRayTracingPassBuilder& Read(uint32_t set, uint32_t binding, uint32_t index, RDGTextureHandle texture, TextureViewType viewType = VIEW_TYPE_2D, TextureSubresourceRange subresource = {});
        RDGRayTracingPassBuilder& ReadWrite(uint32_t set, uint32_t binding, uint32_t index, RDGBufferHandle buffer, uint32_t offset = 0, uint32_t size = 0);   // 好像和read也没什么区别？
        RDGRayTracingPassBuilder& ReadWrite(uint32_t set, uint32_t binding, uint32_t index, RDGTextureHandle texture, TextureViewType viewType = VIEW_TYPE_2D, TextureSubresourceRange subresource = {});
        RDGRayTracingPassBuilder& OutputRead(RDGBufferHandle buffer, uint32_t offset = 0, uint32_t size = 0);             // 在执行完Pass后作为输出，自动屏障，可能还会在其他地方使用
        RDGRayTracingPassBuilder& OutputRead(RDGTextureHandle texture, TextureSubresourceRange subresource = {});
        RDGRayTracingPassBuilder& OutputReadWrite(RDGBufferHandle buffer, uint32_t offset = 0, uint32_t size = 0);
        RDGRayTracingPassBuilder& OutputReadWrite(RDGTextureHandle texture, TextureSubresourceRange subresource = {});


        RDGRayTracingPassBuilder& Execute(const RDGPassExecuteFunc& execute);

        RDGRayTracingPassHandle Finish() { return pass->GetHandle(); }

    private:
        RDGBuilder* builder;
        RDGRayTracingPassNodeRef pass;

        DependencyGraphRef graph;
    };

    class RDGPresentPassBuilder
    {
    public:
        RDGPresentPassBuilder(RDGBuilder* builder, RDGPresentPassNodeRef pass)
            : builder(builder)
            , pass(pass)
            , graph(builder->GetGraph()) {
        };

        RDGPresentPassHandle Finish() { return pass->GetHandle(); }

        RDGPresentPassBuilder& Texture(RDGTextureHandle texture, TextureSubresourceLayers subresource = {});
        RDGPresentPassBuilder& PresentTexture(RDGTextureHandle texture);

    private:
        RDGBuilder* builder;
        RDGPresentPassNodeRef pass;

        DependencyGraphRef graph;
    };

    class RDGCopyPassBuilder
    {
    public:
        RDGCopyPassBuilder(RDGBuilder* builder, RDGCopyPassNodeRef pass)
            : builder(builder)
            , pass(pass)
            , graph(builder->GetGraph()) {
        };

        RDGCopyPassHandle Finish() { return pass->GetHandle(); }

        RDGCopyPassBuilder& From(RDGTextureHandle texture, TextureSubresourceLayers subresource = {});
        RDGCopyPassBuilder& To(RDGTextureHandle texture, TextureSubresourceLayers subresource = {});
        RDGCopyPassBuilder& GenerateMips();
        RDGCopyPassBuilder& OutputRead(RDGTextureHandle texture, TextureSubresourceLayers subresource = {});
        RDGCopyPassBuilder& OutputReadWrite(RDGTextureHandle texture, TextureSubresourceLayers subresource = {});

    private:
        RDGBuilder* builder;
        RDGCopyPassNodeRef pass;

        DependencyGraphRef graph;
    };
}

RDG下定义一个Pass的流程

创建/获取资源节点Handler

// 创建资源
RDGTextureBuilder RDGBuilder::CreateTexture(std::string name)
{
	RDGTextureNodeRef textureNode = graph->CreateNode<RDGTextureNode>(name);
	blackBoard.AddTexture(textureNode);
	return RDGTextureBuilder(this, textureNode);
}

RDGBufferBuilder RDGBuilder::CreateBuffer(std::string name)
{
	RDGBufferNodeRef bufferNode = graph->CreateNode<RDGBufferNode>(name);
	blackBoard.AddBuffer(bufferNode);
	return RDGBufferBuilder(this, bufferNode);
}

// 获取资源
RDGTextureHandle RDGBuilder::GetTexture(std::string name)
{
    auto node = blackBoard.Texture(name);
    if (node == nullptr)
    {
        return RDGTextureHandle(UINT32_MAX);
    }
    return node->GetHandle();
}
RDGBufferHandle RDGBuilder::GetBuffer(std::string name)
{
    auto node = blackBoard.Buffer(name);
    if (node == nullptr)
    {
        return RDGBufferHandle(UINT32_MAX);
    }
    return node->GetHandle();
}

创建Pass结点，并挂载需要的资源

Read资源：资源 -> Pass

ReadWrite资源： Pass-> 资源

// 创建图形PassNode
RDGRenderPassBuilder RDGBuilder::CreateRenderPass(std::string name)
{
    RDGRenderPassNodeRef passNode = graph->CreateNode<RDGRenderPassNode>(name);
    blackBoard.AddPass(passNode);
    passes.push_back(passNode);
    return RDGRenderPassBuilder(this, passNode);
}

// 绑定只读资源（此时需要指定 资源描述符位置、 viewType 和 subresource）
RDGComputePassBuilder& RDGComputePassBuilder::Read(uint32_t set, uint32_t binding, uint32_t index, RDGTextureHandle texture, TextureViewType viewType, TextureSubresourceRange subresource)
{
    RDGTextureEdgeRef edge = graph->CreateEdge<RDGTextureEdge>();
    edge->state = RESOURCE_STATE_SHADER_RESOURCE;   // 因为是Read，所以指定为SRV
    edge->subresource = subresource;
    edge->asShaderRead = true;
    edge->set = set;
    edge->binding = binding;
    edge->index = index;
    edge->type = RESOURCE_TYPE_TEXTURE;
    edge->viewType = viewType;
    graph->Link(graph->GetNode(texture.ID()), pass, edge);
    return *this;
}

// 绑定读写资源
RDGComputePassBuilder& RDGComputePassBuilder::ReadWrite(uint32_t set, uint32_t binding, uint32_t index, RDGBufferHandle buffer, uint32_t offset, uint32_t size)
{
    RDGBufferEdgeRef edge = graph->CreateEdge<RDGBufferEdge>();
    edge->state = RESOURCE_STATE_UNORDERED_ACCESS;
    edge->offset = offset;
    edge->size = size;
    edge->asShaderReadWrite = true;
    edge->set = set;
    edge->binding = binding;
    edge->index = index;
    edge->type = RESOURCE_TYPE_RW_BUFFER;
    graph->Link(pass, graph->GetNode(buffer.ID()), edge);
  	return *this;
}

定义Pass执行流程 RDGPassContext

typedef std::function<void(RDGPassContext)> RDGPassExecuteFunc;

RDGComputePassBuilder& RDGComputePassBuilder::Execute(const RDGPassExecuteFunc& execute)
{
    pass->execute = execute;
    return *this;
}

也可以指定Output资源，用于在Pass执行完成后，修改资源的状态，这有助于一个Pass有很多个PassNode时（比如Hiz）在Pass内部资源屏障

RDGComputePassBuilder& RDGComputePassBuilder::OutputRead(RDGTextureHandle texture, TextureSubresourceRange subresource)
{
	RDGTextureEdgeRef edge = graph->CreateEdge<RDGTextureEdge>();
	edge->state = RESOURCE_STATE_SHADER_RESOURCE;
	edge->subresource = subresource;
	edge->asOutputReadWrite = true;
	edge->type = RESOURCE_TYPE_TEXTURE;

	graph->Link(pass, graph->GetNode(texture.ID()), edge);

	return *this;
}

RDGComputePassBuilder& RDGComputePassBuilder::OutputReadWrite(RDGBufferHandle buffer, uint32_t offset, uint32_t size)
{
	RDGBufferEdgeRef edge = graph->CreateEdge<RDGBufferEdge>();
	edge->state = RESOURCE_STATE_UNORDERED_ACCESS;
	edge->offset = offset;
	edge->size = size;
	edge->asOutputReadWrite = true;
	edge->type = RESOURCE_TYPE_RW_BUFFER;

	graph->Link(pass, graph->GetNode(buffer.ID()), edge);

	return *this;
}

RDG执行

RDGBuilder rdgBuilder = RDGBuilder(CurCommandList); // 传入CommandList
// 构建图结构
for (auto& pass : passes) { if (pass) pass->Build(rdgBuilder); }
// 执行RDG
rdgBuilder.Execute();

RDG执行内部流程

遍历PassNode，根据类型，执行Pass对应的执行流程

void RDGBuilder::Execute()
{
    std::string currentPrefix;

    for (size_t i = 0; i < passes.size(); ++i) {
        auto& pass = passes[i];
        if (!pass || pass->isCulled) continue;
        std::string name = pass->Name();
        size_t pos = name.find('_');
        std::string prefix = (pos != std::string::npos) ? name.substr(0, pos) : name;
        if (!currentPrefix.empty() && currentPrefix != prefix) {
            command->PopLabel();
            currentPrefix.clear();
        }
        if (currentPrefix.empty()) {
            command->PushLabel(prefix, pass->GetLabelColor());
            currentPrefix = prefix;
        }
#ifdef RDG_DEBUG
        LOG_INFO("RDG Pass Begin: [{}]", name);
#endif
        // 执行 pass
        switch (pass->NodeType()) {
        case RDG_PASS_NODE_TYPE_RENDER:         ExecutePass(dynamic_cast<RDGRenderPassNodeRef>(pass)); break;
        case RDG_PASS_NODE_TYPE_COMPUTE:        ExecutePass(dynamic_cast<RDGComputePassNodeRef>(pass)); break;
        case RDG_PASS_NODE_TYPE_RAY_TRACING:    ExecutePass(dynamic_cast<RDGRayTracingPassNodeRef>(pass)); break;
        case RDG_PASS_NODE_TYPE_PRESENT:        ExecutePass(dynamic_cast<RDGPresentPassNodeRef>(pass)); break;
        case RDG_PASS_NODE_TYPE_COPY:           ExecutePass(dynamic_cast<RDGCopyPassNodeRef>(pass)); break;
        default:                                LOG_ERROR("Unsupported RDG pass type!");
        }
#ifdef RDG_DEBUG
        LOG_INFO("RDG Pass End: [{}]", name);
#endif
        // 检查下一个 pass 前缀，如果变化或者是最后一个 pass，pop
        size_t nextIndex = i + 1;
        std::string nextPrefix;
        while (nextIndex < passes.size() && (!passes[nextIndex] || passes[nextIndex]->isCulled)) {
            ++nextIndex;
        }
        if (nextIndex < passes.size()) {
            std::string nextName = passes[nextIndex]->Name();
            size_t nextPos = nextName.find('_');
            nextPrefix = (nextPos != std::string::npos) ? nextName.substr(0, nextPos) : nextName;
        }

        if (nextIndex == passes.size() || nextPrefix != prefix) {
            command->PopLabel();
            currentPrefix.clear();
        }
    }



    for (auto& pass : passes)   // 释放池化资源
    {
        //ReleaseResource(pass);
        for (auto& descriptor : pass->pooledDescriptorSets)
        {
            RDGDescriptorSetPool::Get(APP_FRAMEINDEX)->Release({ descriptor.first }, pass->rootSignature, descriptor.second);
        }
    }
}

图形渲染Pass内部流程

创建和更新资源描述符集
创建RenderPass、FrameBuffer（pooled）
根据DAG自动进行输入屏障
BeginRenderPass
执行Pass
根据DAG自动进行输入屏障
回收Pass使用的资源，用于资源复用

void RDGBuilder::ExecutePass(RDGRenderPassNodeRef pass)
{
	PrepareDescriptorSet(pass);
	RHIRenderPassInfo renderPassInfo = {};
	PrepareRenderTarget(pass, renderPassInfo);
	RHIRenderPassRef renderPass = APP_DYNAMICRHI->CreateRenderPass(renderPassInfo); // 根据图创建RenderPass和FranmeBuffer，因为有pool其实无所谓把RenderPass和FrameBuffer放在一起创建
	CreateInputBarriers(pass);
	command->BeginRenderPass(renderPass); // Begin的是RenderPass，把实际的FrameBuffer当作参数传递进去了
	RDGPassContext context;
	context.command = command;
	context.builder = this;
	context.descriptors = pass->descriptorSets;
	context.passIndex[0] = pass->passIndex[0];
	context.passIndex[1] = pass->passIndex[1];
	context.passIndex[2] = pass->passIndex[2];
	pass->execute(context);
	command->EndRenderPass();
	CreateOutputBarriers(pass);
	ReleaseResource(pass);
}

自动创建屏障的过程：

遍历一个Texture的所有Pass，如果这个Pass在当前Pass之前，就根据逻辑找这个Pass与这个纹理如何交互的，就得到了Pass

从这里看目前的流程还是比较简单了，因为Pass都是一条线的顺序

多线程渲染

设计是：Tick一开始会先让渲染线程渲染上一帧的数据，之后主线程同步执行下一帧的收集

RenderCommandQueue用于在主线程收集命令

#pragma once
#include <cstdint>
#include <vector>
namespace GameEngine {
	struct RenderCommandDebugInfo
	{
		const char* file;
		int line;
		const char* function;
	};
	class RenderCommandQueue
	{
	public:
		typedef void(*RenderCommandFn)(void*);

		RenderCommandQueue();
		~RenderCommandQueue();

		void* Allocate(RenderCommandFn func, uint32_t size); // 收集命令
		std::vector<RenderCommandDebugInfo> m_DebugInfos; // 调试信息

		void Execute();
	private:
		uint8_t* m_CommandBuffer;
		uint8_t* m_CommandBufferPtr;
		uint32_t m_CommandCount = 0;

	};
}

// 分配一个10mb的Buffer
RenderCommandQueue::RenderCommandQueue()
{
    m_CommandBuffer = new uint8_t[10 * 1024 * 1024]; // 10mb buffer
    m_CommandBufferPtr = m_CommandBuffer;
    memset(m_CommandBuffer, 0, 10 * 1024 * 1024); // 填充0
}

Submit的流程

传入一段Lambda表达式或一个函数指针，Submit内部会统一封装为一个参数为void*的lambda,内部会调用原函数，并进行销毁
在Queue中分配内存，存储统一封装好的lambda的指针 + 指针大小记录 + 真正的调用函数内容（即需要的void*）

// 暴漏的接口
template<typename FuncT>
static void Submit(FuncT&& func, const char* file = nullptr, int line = 0, const char* function = nullptr)
{
    auto& queue = GetRenderCommandQueue();  // 有两个CommandQueue交替工作，一个在主线程收集指令，一个在渲染线程执行指令，每帧都会交替一次
#ifdef RTDEBUG
    queue.m_DebugInfos.push_back({ file, line, function });
#endif
    // 把传入的函数指针或lambda统一封装为一个参数为void*的lambda，这里lambda用于转换void*指针到真正的对象指针，然后执行它
    auto renderCmd = [](void* ptr) {
        auto pFunc = (FuncT*)ptr;
        (*pFunc)();
        pFunc->~FuncT();
        };

    auto storageBuffer = queue.Allocate(renderCmd, sizeof(FuncT));
    new (storageBuffer) FuncT(std::forward<FuncT>(func));  // placement New 最近刚学的 原地创建对象，不分配新内存
}
using RenderCommandFn = void(*)(void*);
// Submit可以传递一个lambda表达式，也可以是一个函数的地址，但必须都是无参的，为了统一
// 	Submit([]() {
//		cout << "hello world" << endl;
// 	});
//	Submit(&test);


void* RenderCommandQueue::Allocate(RenderCommandFn fn, uint32_t size)
 {
     *(RenderCommandFn*)m_CommandBufferPtr = fn;
     m_CommandBufferPtr += sizeof(RenderCommandFn);

     *(uint32_t*)m_CommandBufferPtr = size;
     m_CommandBufferPtr += sizeof(uint32_t);

     void* memory = m_CommandBufferPtr;
     m_CommandBufferPtr += size;

     m_CommandCount++;
     return memory;
 }

Queue执行流程：就是按照上边封装数据的流程读取数据，然后依次执行

void RenderCommandQueue::Execute()
{
    uint8_t* buffer = m_CommandBuffer;

    for (uint32_t i = 0; i < m_CommandCount; i++)
    {
        RenderCommandFn function = *(RenderCommandFn*)buffer;
        buffer += sizeof(RenderCommandFn);

        uint32_t size = *(uint32_t*)buffer;
        buffer += sizeof(uint32_t);
        // 执行命令
        function(buffer);
        buffer += size;
    }

    m_CommandBufferPtr = m_CommandBuffer;
    m_CommandCount = 0;
}

以上架构就完成了Queue如何收集指令和执行指令

下面还要看渲染线程和主线程如何同步

渲染线程封装，使用状态机模型 Idle Busy Kick三个状态流转，通过win的线程同步API来进行控制

// 简单封装一个线程对象，Dispathc用于开启并执行一个线程，Join表示阻塞等待该线程结束
class Thread
{
public:
    Thread(const std::string& name);

    // 线程执行
    template<typename Fn, typename... Args>
    void Dispatch(Fn&& func, Args&&... args)
    {
        m_Thread = std::thread(func, std::forward<Args>(args)...); // 这行会立即新线程执行传入的函数
        SetName(m_Name);
        LOG_INFO("Thread [{0}] Dispatch and Run!", m_Name);
    }

    void SetName(const std::string& name);

    // 阻塞等待线程结束
    void Join();

    std::thread::id GetID() const;
private:
    std::string m_Name;
    std::thread m_Thread;
};

enum class ThreadingPolicy
{
	// MultiThreaded will create a Render Thread
	None = 0, SingleThreaded, MultiThreaded
};

// 渲染线程的封装
class RenderThread
{
public:
	enum class State
	{
		Idle = 0,
		Busy,
		Kick
	};
public:
	RenderThread(ThreadingPolicy coreThreadingPolicy);
	~RenderThread();

	void Run();
	bool IsRunning() const { return m_IsRunning; }
	void Terminate();

	void Wait(State waitForState);
	void WaitAndSet(State waitForState, State setToState);
	void Set(State setToState);

	void NextFrame();
	void BlockUntilRenderComplete();
	void Kick();
	void Pump();
	static uint32_t RT_GetFrameIndex();
	static bool IsCurrentThreadRT();
private:
	RenderThreadData* m_Data;
	ThreadingPolicy m_ThreadingPolicy;

	Thread m_RenderThread;

	bool m_IsRunning = false;

	std::atomic<uint32_t> m_AppThreadFrame = 0;
};

渲染线程内部

创建流程

RenderThread::RenderThread(ThreadingPolicy coreThreadingPolicy)
    : m_RenderThread("Render Thread"), m_ThreadingPolicy(coreThreadingPolicy)
{
    m_Data = new RenderThreadData();

    if (m_ThreadingPolicy == ThreadingPolicy::MultiThreaded)
    {
        InitializeCriticalSection(&m_Data->m_CriticalSection); // 创建临界区
        InitializeConditionVariable(&m_Data->m_ConditionVariable); // 创建条件变量配套
    }
}

渲染线程运行：渲染线程While等待Kick信号，收到信号后，转为Busy状态，进一步就是拿Queue的执行，执行完成后设置为Idle状态

void RenderThread::Run()
{
    m_IsRunning = true;
    if (m_ThreadingPolicy == ThreadingPolicy::MultiThreaded) {
        m_RenderThread.Dispatch(RenderManager::RenderThreadFunc, this);
    }
    s_RenderThreadID = m_RenderThread.GetID();
}

// 挂在渲染线程的函数
void RenderManager::RenderThreadFunc(RenderThread* renderThread)
{
    while (renderThread->IsRunning())
    {
        WaitAndRender(renderThread);
    }
}

// 具体渲染线程的函数
void RenderManager::WaitAndRender(RenderThread* renderThread)
{
    // Wait for kick, then set render thread to busy
    {
        // 渲染线程循环等待Kick信号，收到信号后，设置为Busy信号并开始工作
        renderThread->WaitAndSet(RenderThread::State::Kick, RenderThread::State::Busy);
    }
    // 工作就是把缓存命令全部执行
    s_CommandQueue[GetRenderQueueIndex()]->Execute();

    // Rendering has completed, set state to idle
    renderThread->Set(RenderThread::State::Idle);
}

信号流转

void RenderThread::WaitAndSet(State waitForState, State setToState)
{
    if (m_ThreadingPolicy == ThreadingPolicy::SingleThreaded)
        return;

    EnterCriticalSection(&m_Data->m_CriticalSection);
    while (m_Data->m_State != waitForState)
    {
        SleepConditionVariableCS(&m_Data->m_ConditionVariable, &m_Data->m_CriticalSection, INFINITE);
    }
    m_Data->m_State = setToState;
    WakeAllConditionVariable(&m_Data->m_ConditionVariable);
    LeaveCriticalSection(&m_Data->m_CriticalSection);
}

来捋一下主线程的工作

主线程等待渲染线程执行完毕
主线程交换Queue
主线程通知渲染线程开始工作（渲染上一帧）

// 1. 主线程等待渲染线程执行完毕
void RenderThread::BlockUntilRenderComplete()
{
    if (m_ThreadingPolicy == ThreadingPolicy::SingleThreaded)
        return;

    Wait(State::Idle);
}

// 2. 主线程交换Queue
void RenderManager::SwapRenderCommandQueue()
{
    s_RenderCommandQueueSubmissionIndex = (s_RenderCommandQueueSubmissionIndex + 1) % s_RenderCommandQueueCount;
}

// 3. 主线程通知渲染线程开始工作（渲染上一帧）
void RenderThread::Kick()
{
    if (m_ThreadingPolicy == ThreadingPolicy::MultiThreaded)
    {
        Set(State::Kick);
    }
}

主线程和渲染线程都需要访问临界区资源，主线程为了把状态设置为Kick，等待Idle状态，渲染线程等待Kick信号，转为Busy状态，执行完成后转为Idle状态

两个线程对于状态的修改通过进入和离开临界区代码来互斥，它会自动加锁和解锁

1
2

EnterCriticalSection(&m_Data->m_CriticalSection);
LeaveCriticalSection(&m_Data->m_CriticalSection);

条件变量用于防止CPU轮询，比如一个线程进入临界区后发现当前状态不是想要的状态，于是退出，还是在外部写一个while来轮询

有了条件变量的话，发现状态不对，就会让线程进入休眠，并且释放锁，当满足条件时，重新上锁开始切换状态

1
2

SleepConditionVariableCS(&m_CondVar, &m_CriticalSection, INFINITE);
WakeAllConditionVariable(&m_CondVar);

所以条件变量的目的是让上锁的线程临时释放锁，等满足条件后，重新再获得锁

渲染Tick执行

// 在渲染最后执行  CurCommandList中已经收集了当前帧的所有渲染指令，这个提交到渲染线程后，会在下一帧的开始处执行这些函数
RENDER_SUBMIT([this]() {
	//LOG_INFO("渲染第{}帧", APP_FRAMEINDEX_RT);
	auto& CurResource = m_PerFrameBaseResources[APP_FRAMEINDEX_RT];
	CurResource.fence->Wait(); // 先等待这个飞行帧上一帧渲染结束
	m_SwapChain->GetNewFrame(nullptr, CurResource.startSemaphore);
	RHICommandListRef CurCommandList = CurResource.commandList;
	CurCommandList->Execute(CurResource.fence, CurResource.startSemaphore, CurResource.finishSemaphore);
	m_GPUTimeInfos[APP_FRAMEINDEX_RT] = CurCommandList->GetGPUTime();
	m_SwapChain->Present(CurResource.finishSemaphore);
	m_RenderThread.NextFrame();
});

渲染资源管理

全局资源描述符布局

创建一个Set=0的根签名，填充常用的各种资源类型，其中一部分绑定点是bindless的

		// 创建一个全局的资源描述符集来挂载各种全局资源
		RHIRootSignatureInfo info = {};
		// set binding count frequency type
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_POSITION, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_NORMAL, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_TANGENT, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_TEXCOORD, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_COLOR, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_BONE_INDEX, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_BONE_WEIGHT, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_ANIMATION, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_INDEX, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });

		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_SAMPLER, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_SAMPLER });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_TEXTURE_1D, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_TEXTURE });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_TEXTURE_1D_ARRAY, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_TEXTURE });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_TEXTURE_2D, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_TEXTURE });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_TEXTURE_2D_ARRAY, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_TEXTURE });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_TEXTURE_CUBE, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_TEXTURE }); // 就是得设置Texture，设置Cube不对
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_BINDLESS_TEXTURE_3D, MAX_BINDLESS_RESOURCE_SIZE, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_TEXTURE });

		// 下面这些需要手动去绑定buffer和preFrame资源描述符
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_MESHINSTANCEINFO, 1, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_MATERIALINFO, 1, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_MESHINFO, 1, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });

		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_SETTING, 1, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_CAMERA, 2, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_LIGHTINFO, 1, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });
		info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_GIZMO, 1, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RW_BUFFER });
		if (RENDER_ENABLE_RAY_TRACING) {
			info.AddEntry({ 0, GLORBAL_RESOURCE_BINDING_TLAS, 1, SHADER_FREQUENCY_ALL, RESOURCE_TYPE_RAY_TRACING });
		}

		m_GlobalResourcePreFrameRootSignature = APP_DYNAMICRHI->CreateRootSignature(info);
		for (auto& resource : m_PerFrameGlobalResources) resource.descriptorSet = m_GlobalResourcePreFrameRootSignature->CreateDescriptorSet(0);

提前创建好一些资源，绑定到这个资源描述符集中

// 挂载默认全局资源
for (auto& resource : m_PerFrameGlobalResources) {
	// camera
	{
		// 0号位是当前摄像机， 1号位存储Scene自带的默认摄像机
		RHIDescriptorUpdateInfo cameraUpdateInfo = {};
		cameraUpdateInfo.resourceType = RESOURCE_TYPE_RW_BUFFER;
		cameraUpdateInfo.buffer = resource.activeCameraDataBuffer.GetRHIBuffer();
		cameraUpdateInfo.index = 0;
		cameraUpdateInfo.binding = GLORBAL_RESOURCE_BINDING_CAMERA;
		resource.descriptorSet->UpdateDescriptor(cameraUpdateInfo);

		cameraUpdateInfo.buffer = resource.defalutCameraDataBuffer.GetRHIBuffer();
		cameraUpdateInfo.index = 1;
		resource.descriptorSet->UpdateDescriptor(cameraUpdateInfo);
	}

	// Setting
	{
		RHIDescriptorUpdateInfo settingUpdateInfo = {};
		settingUpdateInfo.resourceType = RESOURCE_TYPE_RW_BUFFER;
		settingUpdateInfo.buffer = m_MultiFrameGlobalResources.globalSettingInfoBuffer.GetRHIBuffer();
		settingUpdateInfo.index = 0;
		settingUpdateInfo.binding = GLORBAL_RESOURCE_BINDING_SETTING;
		resource.descriptorSet->UpdateDescriptor(settingUpdateInfo);
	}

	// meshInstanceInfo
	{
		RHIDescriptorUpdateInfo meshInfoUpdateInfo = {};
		meshInfoUpdateInfo.resourceType = RESOURCE_TYPE_RW_BUFFER;
		meshInfoUpdateInfo.buffer = m_MultiFrameGlobalResources.meshInfoBuffer.GetRHIBuffer();
		meshInfoUpdateInfo.index = 0;
		meshInfoUpdateInfo.binding = GLORBAL_RESOURCE_BINDING_MESHINSTANCEINFO;
		resource.descriptorSet->UpdateDescriptor(meshInfoUpdateInfo);
	}

	// materialInfo
	{
		RHIDescriptorUpdateInfo materialInfoUpdateInfo = {};
		materialInfoUpdateInfo.resourceType = RESOURCE_TYPE_RW_BUFFER;
		materialInfoUpdateInfo.buffer = m_MultiFrameGlobalResources.materialBuffer.GetRHIBuffer();
		materialInfoUpdateInfo.index = 0;
		materialInfoUpdateInfo.binding = GLORBAL_RESOURCE_BINDING_MATERIALINFO;
		resource.descriptorSet->UpdateDescriptor(materialInfoUpdateInfo);
	}

	// MeshInfo
	{
		RHIDescriptorUpdateInfo vertexInfoUpdateInfo = {};
		vertexInfoUpdateInfo.resourceType = RESOURCE_TYPE_RW_BUFFER;
		vertexInfoUpdateInfo.buffer = m_MultiFrameGlobalResources.vertexBuffer.GetRHIBuffer();
		vertexInfoUpdateInfo.index = 0;
		vertexInfoUpdateInfo.binding = GLORBAL_RESOURCE_BINDING_MESHINFO;
		resource.descriptorSet->UpdateDescriptor(vertexInfoUpdateInfo);
	}

	// sampler
	{
		RHIDescriptorUpdateInfo samplerUpdateInfo = {};
		samplerUpdateInfo.resourceType = RESOURCE_TYPE_SAMPLER;
		samplerUpdateInfo.sampler = m_MultiFrameGlobalResources.samplers[0]->sampler;
		samplerUpdateInfo.index = 0;
		samplerUpdateInfo.binding = GLORBAL_RESOURCE_BINDING_BINDLESS_SAMPLER;
		resource.descriptorSet->UpdateDescriptor(samplerUpdateInfo);
		samplerUpdateInfo.sampler = m_MultiFrameGlobalResources.samplers[1]->sampler;
		samplerUpdateInfo.index = 1;
		samplerUpdateInfo.binding = GLORBAL_RESOURCE_BINDING_BINDLESS_SAMPLER;
		resource.descriptorSet->UpdateDescriptor(samplerUpdateInfo);
		samplerUpdateInfo.sampler = m_MultiFrameGlobalResources.samplers[2]->sampler;
		samplerUpdateInfo.index = 2;
		samplerUpdateInfo.binding = GLORBAL_RESOURCE_BINDING_BINDLESS_SAMPLER;
		resource.descriptorSet->UpdateDescriptor(samplerUpdateInfo);
		samplerUpdateInfo.sampler = m_MultiFrameGlobalResources.samplers[3]->sampler;
		samplerUpdateInfo.index = 3;
		samplerUpdateInfo.binding = GLORBAL_RESOURCE_BINDING_BINDLESS_SAMPLER;
		resource.descriptorSet->UpdateDescriptor(samplerUpdateInfo);
	}

	// lightInfo
	{
		RHIDescriptorUpdateInfo lightUpdateInfo = {};
		lightUpdateInfo.resourceType = RESOURCE_TYPE_RW_BUFFER;
		lightUpdateInfo.buffer = resource.lightInfoBuffer.GetRHIBuffer();
		lightUpdateInfo.index = 0;
		lightUpdateInfo.binding = GLORBAL_RESOURCE_BINDING_LIGHTINFO;
		resource.descriptorSet->UpdateDescriptor(lightUpdateInfo);
	}

	// gizmoDrawData
	{
		RHIDescriptorUpdateInfo gizmoUpdateInfo = {};
		gizmoUpdateInfo.resourceType = RESOURCE_TYPE_RW_BUFFER;
		gizmoUpdateInfo.buffer = resource.gizmoBuffer.GetRHIBuffer();
		gizmoUpdateInfo.index = 0;
		gizmoUpdateInfo.binding = GLORBAL_RESOURCE_BINDING_GIZMO;
		resource.descriptorSet->UpdateDescriptor(gizmoUpdateInfo);
	}
}

在RDG Build时绑定这个布局到Set=0

`1`	`command->BindDescriptorSet(RENDER_RESOURCEMANAGER->GetGlobalResourcePerFrameDescriptorSet(), 0);`

Bindless资源管理

申请一个对应bindless槽位内的ID，并绑定资源描述符集的对应binding的对应index

	uint32_t RenderResourceManager::AllocateBindlessID(const BindlessResourceInfo& resoruceInfo, BindlessSlot slot)
	{
		// 给这个资源分配一个ID
		uint32_t index = m_BindlessIDAlloctor[slot].Allocate();

		// 构建更新信息
		RHIDescriptorUpdateInfo updateInfo = {};
		updateInfo.binding = BindlessSlotToPerFrameBinding(slot);
		updateInfo.index = index;  // bindless数组的index
		updateInfo.resourceType = resoruceInfo.resourceType;
		updateInfo.buffer = resoruceInfo.buffer;
		updateInfo.textureView = resoruceInfo.textureView;
		updateInfo.sampler = resoruceInfo.sampler;
		updateInfo.bufferOffset = resoruceInfo.bufferOffset;
		updateInfo.bufferRange = resoruceInfo.bufferRange;

		// 实时更新会因为一些问题报错，暂时不更新本帧，只更新其他帧
		for (size_t i = 0; i < m_PerFrameGlobalResources.size(); ++i) {
			if (i == APP_FRAMEINDEX) {
				auto& resource = m_PerFrameGlobalResources[i];
				resource.isNeedUpdate = true;
				resource.updateInfos.push_back(updateInfo);
			}
			else {
				m_PerFrameGlobalResources[i].descriptorSet->UpdateDescriptor(updateInfo);
			}
		}

		return index;
	}

Mesh渲染架构（Bindless + 间接渲染）

所有的Mesh相关数据，全部由Bindless管理

enum BindlessSlot
{
	BINDLESS_SLOT_POSITION = 0,
	BINDLESS_SLOT_NORMAL,
	BINDLESS_SLOT_TANGENT,
	BINDLESS_SLOT_TEXCOORD,
	BINDLESS_SLOT_COLOR,
	BINDLESS_SLOT_BONE_INDEX,
	BINDLESS_SLOT_BONE_WEIGHT,
	BINDLESS_SLOT_ANIMATION,
	BINDLESS_SLOT_INDEX,

	BINDLESS_SLOT_SAMPLER,
	BINDLESS_SLOT_TEXTURE_1D,
	BINDLESS_SLOT_TEXTURE_1D_ARRAY,
	BINDLESS_SLOT_TEXTURE_2D,
	BINDLESS_SLOT_TEXTURE_2D_ARRAY,
	BINDLESS_SLOT_TEXTURE_CUBE,
	BINDLESS_SLOT_TEXTURE_3D,
	BINDLESS_SLOT_MAX_ENUM,     //
};

加载模型时，上传对应数据到对应槽位，并范围ID值，另外有一个Buffer专门存储所有顶点数据的各项（位置、法线、颜色）的ID，组成一个MeshInfo，也作为一个ArrayBuffer上传

 void VertexBuffer::SetBufferData(void* data, uint32_t size, RHIBufferRef& buffer, uint32_t& id, uint32_t slot)
 {
     if (size == 0) return;
     if (!buffer || buffer->GetInfo().size < size)  // 创建buffer
     {
         RHIBufferInfo rHIBufferInfo;
         rHIBufferInfo.type = RESOURCE_TYPE_RW_BUFFER | RESOURCE_TYPE_VERTEX_BUFFER;
         rHIBufferInfo.size = size;
         rHIBufferInfo.memoryUsage = MEMORY_USAGE_CPU_TO_GPU;
         rHIBufferInfo.creationFlag = BUFFER_CREATION_PERSISTENT_MAP;
         buffer = APP_DYNAMICRHI->CreateBuffer(rHIBufferInfo);

         if (id != 0) RENDER_RESOURCEMANAGER->ReleaseBindlessID(id, (BindlessSlot)slot);
         BindlessResourceInfo bindlessResourceInfo;
         bindlessResourceInfo.buffer = buffer;
         bindlessResourceInfo.resourceType = RESOURCE_TYPE_RW_BUFFER;
         bindlessResourceInfo.bufferOffset = 0;
         bindlessResourceInfo.bufferRange = size;

         id = RENDER_RESOURCEMANAGER->AllocateBindlessID(bindlessResourceInfo, (BindlessSlot)slot);
     }

     memcpy(buffer->Map(), data, size);

     RENDER_RESOURCEMANAGER->SetMeshInfo(vertexInfo, vertexID);
 }

另外每个Mesh实例也会有一个ID，用于存储这个实例对应的MeshInfo的ID以及材质的ID，也作为ArrayBuffer上传

所以每个实例在GPU层只是一些底层资源的ID集合（再加一个Model矩阵）

// Mesh的实例信息
typedef struct MeshInstanceInfo {
    glm::mat4 modelMatrix;
    glm::mat4 prevModelMatrix;
    uint32_t animationID;           //TODO:动画索引
    uint32_t materialID;
    uint32_t vertexID;
    uint32_t indexID;
}MeshInstanceInfo;

渲染时,DrawCall指定起始实例为对应的实例ID，在Shader内就能拿到这个ID，然后去全局资源中拿到关于这个实例的所有信息

for (auto& batch : meshBatch) { // 收集这个PSO的绘制命令到m_IndirectCommands（最终一并上传）
    RHIIndirectCommand meshDrawCommand;
    meshDrawCommand.firstInstance = batch.instanceID;   // 在Shader中通过这个拿到实例ID
    meshDrawCommand.vertexCount = batch.indexCount;
    meshDrawCommand.instanceCount = 1;
    meshDrawCommand.firstVertex = 0;

    m_IndirectCommands.push_back(meshDrawCommand);
}

这样设计下配合间接渲染，可以一口气上传所有实例的DrawCall，因为中间并不涉及顶点缓冲的切换

可以做到Pipeline一致的所有Mesh只需要一个DrawCall

void MeshPassProcessor::Draw(RHICommandListRef command) {
    for (auto& drawCommand : m_MeshDrawCommands)
    {
        auto [w, h] = APP_WINDOWSIZE;

        command->SetGraphicsPipeline(drawCommand.pipeline);

        if (drawCommand.meshCommandRange.size > 0)
        {
            command->DrawIndirect(
                m_MeshIndirectDrawDataBuffer[APP_FRAMEINDEX]->GetRHIBuffer(),
                4 * sizeof(uint32_t) + drawCommand.meshCommandRange.begin * sizeof(RHIIndirectCommand),
                drawCommand.meshCommandRange.size);
        }
    }
}

序列化

定义各种序列化规则以及一些好用的宏

cereal库的使用就是定义好一个类或结构体的序列化和反序列化如何进行即可

#pragma once
#include <cereal/access.hpp>
#include <cereal/types/utility.hpp>
#include <cereal/types/string.hpp>
#include <cereal/types/polymorphic.hpp>
#include <cereal/types/vector.hpp>
#include <cereal/types/map.hpp>
#include <cereal/types/list.hpp>
#include <cereal/types/array.hpp>
#include <cereal/types/queue.hpp>
#include <cereal/archives/json.hpp>
#include <cereal/archives/binary.hpp>
#include <Hazel/Renderer/RHI/RHIBase.h>
namespace cereal {
	// 指定各种类型的序列化规则
	template<class Archive> void serialize(Archive& ar, GameEngine::Extent2D& e) { ar(cereal::make_nvp("width", e.width), cereal::make_nvp("height", e.height)); }
	template<class Archive> void serialize(Archive& ar, GameEngine::Extent3D& e) { ar(cereal::make_nvp("width", e.width), cereal::make_nvp("height", e.height), cereal::make_nvp("depth", e.depth)); }
    template<class Archive> void serialize(Archive& ar, glm::vec3& e) { ar(cereal::make_nvp("x", e.x), cereal::make_nvp("y", e.y), cereal::make_nvp("z", e.z)); }
    template<class Archive> void serialize(Archive& ar, glm::vec2& e) { ar(cereal::make_nvp("x", e.x), cereal::make_nvp("y", e.y)); }
    template<class Archive> void serialize(Archive& ar, glm::vec4& e) { ar(cereal::make_nvp("x", e.x), cereal::make_nvp("y", e.y), cereal::make_nvp("z", e.z),cereal::make_nvp("w", e.w)); }
    template<class Archive> void serialize(Archive& ar, glm::ivec4& e) { ar(cereal::make_nvp("x", e.x), cereal::make_nvp("y", e.y), cereal::make_nvp("z", e.z),cereal::make_nvp("w", e.w)); }
	template<class Archive> void serialize(Archive& ar, glm::uvec3& e) { ar(cereal::make_nvp("x", e.x), cereal::make_nvp("y", e.y), cereal::make_nvp("z", e.z)); }
	template<class Archive> void serialize(Archive& ar, glm::ivec3& e) { ar(cereal::make_nvp("x", e.x), cereal::make_nvp("y", e.y), cereal::make_nvp("z", e.z)); }
	template<class Archive> void serialize(Archive& ar, glm::quat& e) { ar(cereal::make_nvp("x", e.x), cereal::make_nvp("y", e.y), cereal::make_nvp("z", e.z), cereal::make_nvp("w", e.w)); }
	template<class Archive> void serialize(Archive& ar, std::filesystem::path& e) { ar(cereal::make_nvp("path", e.string())); }
    template<class Archive>
    void serialize(Archive& ar, glm::mat4& m)
    {
        ar(
            cereal::make_nvp("c0", m[0]),
            cereal::make_nvp("c1", m[1]),
            cereal::make_nvp("c2", m[2]),
            cereal::make_nvp("c3", m[3])
        );
    }

#define BeginSerailize               	\
friend class cereal::access;            	\
template<class Archive>                 	\
void serialize(Archive& ar)             	\
{
#define SerializeBaseClass(className) \
try { \
    ar(cereal::make_nvp(#className, cereal::base_class<className>(this))); \
} catch (const std::exception& e) { \
    LOG_WARN("{}: failed to serialize base class '{}', reason: {}", __FUNCTION__, #className, e.what()); \
}


#define SerailizeEntry(entry) \
try { \
    ar(cereal::make_nvp(#entry, entry)); \
} catch (const std::exception& e) { \
    LOG_WARN("{}: failed to serialize entry '{}', reason: {}", __FUNCTION__, #entry, e.what()); \
}


#define SerailizeComponent(COMPONENT_TYPE) \
if (HasComponent<COMPONENT_TYPE>()) { \
    ar(cereal::make_nvp("Has" #COMPONENT_TYPE, true)); \
    ar(cereal::make_nvp(#COMPONENT_TYPE, GetComponentConst<COMPONENT_TYPE>())); \
} else { \
    ar(cereal::make_nvp("Has" #COMPONENT_TYPE, false)); \
}

#define DeserializeComponent(COMPONENT_TYPE) \
do { \
    bool hasComponent_##COMPONENT_TYPE = false; \
    try { \
        ar(cereal::make_nvp("Has" #COMPONENT_TYPE, hasComponent_##COMPONENT_TYPE)); \
    } catch (const cereal::Exception&) { \
        hasComponent_##COMPONENT_TYPE = false; \
    } \
    \
    if (hasComponent_##COMPONENT_TYPE) { \
        AddComponent<COMPONENT_TYPE>(); \
        try { \
            ar(cereal::make_nvp(#COMPONENT_TYPE, GetComponent<COMPONENT_TYPE>())); \
        } catch (const cereal::Exception&) { \
            LOG_INFO("Old file missing data for {} component, using default values", #COMPONENT_TYPE); \
        } \
    } \
} while(0)

#define BeginIfSave    if constexpr (Archive::is_saving::value) {
#define EndIfSave }

#define BeginIfLoad    if constexpr (Archive::is_loading::value) {
#define EndIfLoad }

#define SerailizeAssetEntry(entry)          \
ar(cereal::make_nvp(#entry, entry));		\
if(entry) entry->OnLoadAsset();


#define EndSerailize }
	}


#define SerailizeAssetParent         ar(cereal::base_class<Asset>(this));

比如Model,每个被序列化的对象都必须有序列化规则，否则就会报错，而且还不好找是哪个不存在导致的报错。。。

	class Model : public Asset {
    public:
        Model() = default;
		Model(std::string path, ModelSpec m_ModelSpec);
        void LoadFromFile(std::string path);
        virtual std::string GetAssetTypeName() override { return "Asset_Model"; }
        virtual AssetType GetAssetType() override { return ASSET_TYPE_MODEL; }
        virtual void OnLoadAsset() override;
        virtual void OnSaveAsset() override;
        bool hasBone() {return findBone;}
        std::vector<SubmeshData>& GetSubmeshes() { return submeshes; }
        SubmeshData& GetSubmeshData(uint32_t index) { return submeshes[index]; }
        MeshRef GetSubMesh(uint32_t index) { return submeshes[index].mesh; }
        std::vector<MaterialRef>& GetMaterials() { return materials; }
        MaterialRef GetMaterial(uint32_t index) { return materials[index]; }
        std::string GetPath() { return path; }
        VertexBufferRef GetVertexBuffer(int index){return submeshes[index].vertexBuffer;}
        IndexBufferRef GetIndexBuffer(int index){return submeshes[index].indexBuffer;}
    private:
        void ProcessNode(aiNode* node, const aiScene* scene, std::vector<aiMesh*>& processMeshes);
        void ProcessMesh(aiMesh* mesh, const aiScene* scene, int index);
        void ExtractBoneWeights(Mesh* submesh, aiMesh* mesh, const aiScene* scene);
        std::shared_ptr<Texture> Model::LoadMaterialTexture(std::string texturePath);
    private:
        std::string path;
        ModelSpec m_ModelSpec;
        uint64_t totalIndex = 0; 
        uint64_t totalVertex = 0;
        uint32_t totalClusterCnt = 0;
        uint32_t totalClusterMaxMip = 0;
        std::vector<SubmeshData> submeshes;
        std::vector<MaterialRef> materials;
        std::unordered_map<std::string, TextureRef> textureMap;

        bool findBone = false;
    private:
        BeginSerailize
            SerailizeAssetParent
            SerailizeEntry(path)
            SerailizeEntry(m_ModelSpec)
            SerailizeEntry(totalIndex)
            SerailizeEntry(totalVertex)
            SerailizeEntry(totalClusterCnt)
            SerailizeEntry(totalClusterMaxMip)
            SerailizeEntry(submeshes)
            SerailizeEntry(materials)
        EndSerailize
    };

如果序列化和反序列化操作不一致，比如要上传到GPU 用写好的BeginIfLoad BeginIfSave 来区分这是在加载还是在保存

 struct SubmeshData
 {
     std::shared_ptr<Mesh> mesh;                                
     VertexBufferRef vertexBuffer;
     IndexBufferRef indexBuffer;
     RHIBottomLevelAccelerationStructureRef blas;

     BeginSerailize
         SerailizeEntry(mesh)
      
         BeginIfLoad //加载时需要把顶点数据上传到GPU
         LOG_TRACE("  - Vertex Count: {}", mesh->position.size());
         LOG_TRACE("  - Index Count: {}", mesh->index.size());
         // 上传到GPU
         vertexBuffer = std::make_shared<VertexBuffer>();
         vertexBuffer->SetPosition(mesh->position);
         vertexBuffer->SetNormal(mesh->normal);
         vertexBuffer->SetTangent(mesh->tangent);
         vertexBuffer->SetTexCoord(mesh->texCoord);
         vertexBuffer->SetColor(mesh->color);
         vertexBuffer->SetBoneIndex(mesh->boneIndex);
         vertexBuffer->SetBoneWeight(mesh->boneWeight);
         vertexBuffer->SetBoundingBox(mesh->box);

         const MeshInfo& vi = vertexBuffer->vertexInfo;
         LOG_TRACE("  - Vertex Buffer Info:");
         LOG_TRACE("    positionID:    {}", vi.positionID);
         LOG_TRACE("    normalID:      {}", vi.normalID);
         LOG_TRACE("    tangentID:     {}", vi.tangentID);
         LOG_TRACE("    texCoordID:    {}", vi.texCoordID);
         LOG_TRACE("    colorID:       {}", vi.colorID);
         LOG_TRACE("    boneIndexID:   {}", vi.boneIndexID);
         LOG_TRACE("    boneWeightID:  {}", vi.boneWeightID);
         indexBuffer = std::make_shared<IndexBuffer>();
         indexBuffer->SetIndex(mesh->index);
         LOG_TRACE("    IndexBufferID: {}", indexBuffer->indexID);

         // RayTracing
         if (RENDER_ENABLE_RAY_TRACING) {
             RHIBottomLevelAccelerationStructureInfo blasInfo = {};
             blasInfo.vertexBuffer = vertexBuffer->positionBuffer;
             blasInfo.indexBuffer = indexBuffer->buffer;
             blasInfo.triangleCount = mesh->TriangleNum();

             blasInfo.vertexStride = sizeof(glm::vec3);
             blasInfo.indexOffset = 0;
             blasInfo.vertexOffset = 0;
             blas = APP_DYNAMICRHI->CreateBottomLevelAccelerationStructure(blasInfo);
         }
         EndIfLoad

     EndSerailize
 };

使用时比较麻烦的一点是如果一个类成员是第三方库，那就需要很多的trick来解决这个问题，比如Entity底层用的entt，那就很麻烦

序列化场景时就需要手动处理逻辑，而不能直接序列化Entity

    template<class Archive>
    void serialize(Archive& ar)
    {
        if constexpr (Archive::is_saving::value)
        {
            ar(cereal::make_nvp("EntityCount", m_EntityIDMap.size())); 
            for (auto& [uuid, entity] : m_EntityIDMap)
            {
                ar(cereal::make_nvp("Entity", entity));
            }
        }
        else {
            m_EntityIDMap.clear();
            size_t entityCount = 0;
            ar(cereal::make_nvp("EntityCount", entityCount));
            for (size_t i = 0; i < entityCount; ++i) {
                Entity entity;
                ar(cereal::make_nvp("Entity", entity));
                m_EntityIDMap[entity.GetUUID()] = entity;
            }
        }

    }

基础功能

摄像机系统

分为两种模式 FPS和轨迹球

enum class CameraMode
{
    NONE, FLYCAM, ARCBALL
};

Tick函数，主要就是设计两种模式下如何响应鼠标移动和键盘移动来更新 Position 和 YawPitch（间接更新朝向）

另外m_IsCapturing设计是为了防止两次操作方向时鼠标位置不一致导致的屏幕突然旋转（感觉可以设计的更简洁。。。TODO）

void EditorCamera::OnUpdate(const Timestep ts)
{
	bool isMouseInViewport = m_IsMouseInViewport;
	bool isButtonPressed = Input::IsMouseButtonDown(MouseButton::Right) || Input::IsMouseButtonDown(MouseButton::Middle) || (Input::IsMouseButtonDown(MouseButton::Left) && Input::IsKeyDown(KeyCode::LeftAlt));

	// 鼠标开始控制的第一帧，初始化Delta资源
	if (isButtonPressed && isMouseInViewport && !m_IsCapturing) {
		m_IsCapturing = true;
		m_InitialMousePosition = { Input::GetMouseX(), Input::GetMouseY() };
		m_YawDelta = 0.0f;
		m_PitchDelta = 0.0f;
		m_PositionDelta = glm::vec3(0.0f);
	}

	// 结束鼠标控制
	if (!isButtonPressed)
		m_IsCapturing = false;


	if (!m_IsCapturing)
	{
		EnableMouse();
	}else {
		// 鼠标控制中的一帧
		const glm::vec2 mouse{ Input::GetMouseX(), Input::GetMouseY() };
		const glm::vec2 delta = (mouse - m_InitialMousePosition) * 0.002f;
		if (Input::IsMouseButtonDown(MouseButton::Right) && !Input::IsKeyDown(KeyCode::LeftAlt))
		{
			m_CameraMode = CameraMode::FLYCAM;
			DisableMouse();

			const float yawSign = GetUpDirection().y < 0 ? -1.0f : 1.0f;
			const float speed = GetCameraSpeed();
			// 位置调整 Position
			if (Input::IsKeyDown(KeyCode::Q))
				m_PositionDelta -= ts.GetMilliseconds() * speed * glm::vec3{ 0.f, yawSign, 0.f };
			if (Input::IsKeyDown(KeyCode::E))
				m_PositionDelta += ts.GetMilliseconds() * speed * glm::vec3{ 0.f, yawSign, 0.f };
			if (Input::IsKeyDown(KeyCode::S))
				m_PositionDelta -= ts.GetMilliseconds() * speed * m_Direction;
			if (Input::IsKeyDown(KeyCode::W))
				m_PositionDelta += ts.GetMilliseconds() * speed * m_Direction;
			if (Input::IsKeyDown(KeyCode::A))
				m_PositionDelta -= ts.GetMilliseconds() * speed * m_RightDirection;
			if (Input::IsKeyDown(KeyCode::D))
				m_PositionDelta += ts.GetMilliseconds() * speed * m_RightDirection;

			// 旋转调整Direction
			constexpr float maxRate{ 0.12f };
			// Yaw * yawSign是为了相机倒置的时候，偏航角和鼠标的移动还是一致的
			m_YawDelta += glm::clamp(yawSign * delta.x * RotationSpeed(), -maxRate, maxRate);
			m_PitchDelta += glm::clamp(delta.y * RotationSpeed(), -maxRate, maxRate);
			m_RightDirection = glm::cross(m_Direction, glm::vec3{ 0.f, yawSign, 0.f });

			// 重新调整焦点
			const float distance = glm::distance(m_FocalPoint, m_Position);
			m_FocalPoint = m_Position + GetForwardDirection() * distance;
			m_Distance = distance;
		}
		else if (Input::IsKeyDown(KeyCode::LeftAlt))
		{
			m_CameraMode = CameraMode::ARCBALL;

			if (Input::IsMouseButtonDown(MouseButton::Middle))
			{
				DisableMouse();
				MousePan(delta);
			}
			else if (Input::IsMouseButtonDown(MouseButton::Left))
			{
				DisableMouse();
				MouseRotate(delta);
			}
			else if (Input::IsMouseButtonDown(MouseButton::Right))
			{
				DisableMouse();
				MouseZoom((delta.x + delta.y) * 0.1f);
			}
			else
				EnableMouse();
		}
		else
		{
			EnableMouse();
		}

		m_InitialMousePosition = mouse;
		m_Position += m_PositionDelta;
		m_Yaw += m_YawDelta;
		m_Pitch += m_PitchDelta;

		if (m_CameraMode == CameraMode::ARCBALL)
			m_Position = CalculatePosition();
		UpdateCameraView();
	}
}

好像别的基础功能也没啥需要专门记录的了。。。。

游戏引擎开发实践（切比雪夫不等式的应用）

Wed, 31 Dec 2025 21:34:50 +0800

随机变量X大于t的概率可以用随机变量X的均值和方差进行估计

这个是单边切比雪夫不等式，它给出的是概率上限，也就是X大于t的概率不会大于这个

VSM

软阴影需要在shadowMap上多次采样才行，采样点越多越软，但是并不能提前模糊光源深度图，模糊深度图后只是改变了比较的深度值，最终采样结果还是0-1，而VSM的思想就是通过概率论的公式直接估计一片区域内ShadowMap的深度比着色点深度更大的概率，只需要采样深度图一次即可（不过多了一个对深度图进行模糊的Pass）

流程很简单

操作简单，但是效果非常好。但是！漏光了！头盔左侧

如果直接用的话问题还是很大的

网上对漏光的解释是当我算C的阴影时，应该按照B的深度来估计，但是A也参与了，AB深度差距大，方差大，估算不准确

大概理解一下就是一片区域进行采样的filter时，这片区域的深度变化非常大，不能称之为类似一个正态分布的情况，这就会导致你用切比雪夫不等式估算不准确。

实际测试下来就是发现深度变化大的地方就容易漏光

解决漏光可以使用ESVM，用指数函数$e^{kd}$对深度做变换，将多峰分布拉成单峰，压缩方差

改完之后确实有效果

但是并不能完全消除阴影，有些视角下还是有漏光的

游戏引擎开发实践（降噪算法 SVGF）

Fri, 26 Dec 2025 15:26:32 +0800

降噪算法

高斯滤波器

很简单就是拿一个高斯滤波核遍历一遍像素

高斯公式回顾一下

双边滤波

这张图是高斯滤波的结果，它任何地方都会被均等的糊掉

下面是双边滤波器的公式 (i,j)(k,l)两个点的之间的权重计算，前半部分就是高斯分布，后半部分（也是一个高斯分布，颜色越相近，越接近最高点）表示：如果两个点颜色差距越大，权重越小

这个式子可以拆成两个指数函数的乘积，第二项如果颜色一致就=1，颜色不一致程度越大，越小，这样就达到了根据颜色差异调整权重的能力

这个算法的问题是分不清是边界还是噪声

联合双边滤波

高斯滤波的标准：距离

双边滤波的标准：距离+颜色差异

联合双边滤波思想就是用更多的指标，比如GBuffer那些信息

比如量化深度差异，法线差异来指导权重，这里并没有说具体公式

大滤波器优化

如果滤波核很大，如何进行优化

拆分2个Pass

水平一遍，竖直一遍，经典

再配合groupshared，减少ComputeShader的采样次数

原理上来讲二维高斯就可以拆成两个一维高斯的乘积，卷积写成二重积分后，对于高斯滤波核来说可以拆成内部x积分完成后，再y积分

但是复杂的滤波核不适用

小波变换卷积\空洞卷积 À-Trous wavelet

思路也是多个Pass进行卷积，比如5x5的核，每次都是5x5但是采样点的间距变了，变成$2^i$

复杂度从n2变成卷积核的平方 * 卷积次数

处理过亮像素

噪声中很亮的点如果做滤波，会变成一片亮

亮点探测:

处理亮点

SVGF （Spatiotemporal Variance-Guided Filter）时空方差引导滤波

SVGF就是融合了上边介绍的这些技术点，从时间和空间上都进行了滤波

3个因素引导的联合双边滤波

深度

它的深度指数衰减不仅仅是考虑空间深度，还会考虑法线投影上的深度大小（分母），这样建模是为了表达虽然空间上深度差异较大，但是xxxx(TODO:其实没懂为什么这样)

法线

两个法线的点乘来控制，并用指数控制衰减速度

另外一点不要用法线贴图的数据，直接用模型原始法线

Luminance

颜色差异会被噪声干扰，比如一个点在阴影里，但是因为噪声，它变得特别亮，解决办法就是利用方差来指导，方差信息会先计算一次空间上的方差，再时域累积，再空间滤波

SVGF解决不掉的问题是，场景没有变化也就是MotionVector没有数据，但是阴影一直在移动，这时候的阴影就会有噪声

再后来出现了A-SVGF,处理场景突变的延迟问题

RAE

利用神经网络来滤波，目前没兴趣

SVGF实践

参考文刀秋二大佬的https://zhuanlan.zhihu.com/p/28288053，与https://zhuanlan.zhihu.com/p/699706592

Demodulate Albedo

第一步要存储SPP=1的情况下，直接光照和间接光照的结果，并且在存储时要/albedo来保存，过滤过后再乘回来，文刀秋二的解释是（纹理的细节并不会因为Filter的强度过于大而丢失掉）目前不太理解，先做出来再说。另外这样做的前提应该是当前场景是Diffuse的

这张（右侧）表示直接光照/albedo

这张（右侧）表示间接光照/albedo

Reconstruction Filter

先实现空洞滤波

#version 450 core
#include "../common/common.glsl"
#include "../common/math.glsl"
#ifdef COMPUTE_SHADER
layout(set = 1, binding = 0, rgba32f) uniform image2D OUT_COLOR;
layout(set = 1, binding = 1, rgba32f) uniform image2D IN_COLOR;
layout(set = 1,binding = 2, rgba32f) uniform image2D velocityTexture;
layout(push_constant) uniform Uniforms
{
    int curPassIndex; // 当前 Atrous pass 索引
};

layout(local_size_x = 16, local_size_y = 16, local_size_z = 1) in;

void main(){
    ivec2 invocID = ivec2(gl_GlobalInvocationID.xy);
    ivec2 imgSize = ivec2(imageSize(OUT_COLOR));
    if (invocID.x >= imgSize.x || invocID.y >= imgSize.y) 
        return;

    vec3 colorSum = vec3(0.0);
    float weightSum = 0.0;


    // 5x5 Atrous 核心 做了空洞滤波，相当于64*64的卷积核
    int curStep = 1 << curPassIndex;
    for (int dy = -2; dy <= 2; ++dy) {
        for (int dx = -2; dx <= 2; ++dx) {
            ivec2 samplePos = invocID + ivec2(dx, dy) * curStep;

            // 边界检查
            samplePos = clamp(samplePos, ivec2(0), imgSize - 1);

            vec3 sampleColor = imageLoad(IN_COLOR, samplePos).xyz;

            // Atrous 权重，这里先用 1.0，之后可以换成高斯或 bilateral 权重
            float weight = 1.0;

            colorSum += sampleColor * weight;
            weightSum += weight;
        }
    }

    vec3 result = colorSum / weightSum;
    imageStore(OUT_COLOR, invocID, vec4(result, 1.0));
}
#endif

#include "hzpch.h"
#include "SVGFPass.h"
#include "Hazel/Core/Application.h"
#include "Hazel/Scene/SceneManager.h"
#include "Hazel/Renderer/RenderResource/RenderResourceManager.h"
#include "Hazel/Renderer/RenderResource/PipelineCache.h"
#include <Hazel/Renderer/RenderResource/Shader.h>
namespace GameEngine {
	void SVGFPass::Init()
	{
		m_Shader = std::make_shared<Shader>("postprocess/SVGF", SHADER_FREQUENCY_COMPUTE)->GetRHIShader();
		RHIRootSignatureInfo info = {};
		info.AddEntryFromReflect(m_Shader);
		info.AddEntry(RENDER_RESOURCEMANAGER->GetGlobalResourcePreFrameRootSignature()->GetInfo())
			.AddPushConstant({4,SHADER_FREQUENCY_COMPUTE });
		m_RootSignature = APP_DYNAMICRHI->CreateRootSignature(info);
		RHIComputePipelineInfo pipelineInfo = {};
		pipelineInfo.computeShader = m_Shader;
		pipelineInfo.rootSignature = m_RootSignature;
		m_Pipeline = APP_DYNAMICRHI->CreateComputePipeline(pipelineInfo);
	}

	void SVGFPass::Build(RDGBuilder& builder)
	{
		auto& [w, h] = APP_WINDOWSIZE;
		RDGTextureHandle pathTracingDirectRes = builder.GetTexture("PathTracingdirectRes");
		if (pathTracingDirectRes.ID() == UINT32_MAX) { return; }
		RDGTextureHandle pathTracingIndirectRes = builder.GetTexture("PathTracingIndirectRes");
		RDGTextureHandle velocity = builder.GetTexture("GBufferVelocity");
		RDGBufferHandle exposureData = builder.GetBuffer("ExposureData");

		RDGTextureHandle directFilterRes = builder.CreateTexture("PathTracing_SVGF_directFilterRes")
			.Exetent({ w, h ,1 })
			.Format(FORMAT_R32G32B32A32_SFLOAT)
			.AllowRenderTarget()
			.AllowReadWrite()
			.Finish();

		RDGTextureHandle forPinpongTexture = builder.CreateTexture("PathTracing_SVGF_forPinpongTexture")
			.Exetent({ w, h ,1 })
			.Format(FORMAT_R32G32B32A32_SFLOAT)
			.AllowRenderTarget()
			.AllowReadWrite()
			.Finish();


		RDGTextureHandle inDirectFilterRes = builder.CreateTexture("PathTracing_SVGF_inDirectFilterRes")
			.Exetent({ w, h ,1 })
			.Format(FORMAT_R32G32B32A32_SFLOAT)
			.AllowRenderTarget()
			.AllowReadWrite()
			.Finish();



		// 直接光
		for (int i = 0; i < 5; i++) {
			builder.CreateComputePass(GetName() + "_DirectRes" + std::to_string(i))
				.RootSignature(m_RootSignature)
				.PassIndex(i)
				.ReadWrite(1, 0, 0, i == 0 ? directFilterRes : i % 2 == 1 ? forPinpongTexture : directFilterRes)
				.ReadWrite(1, 1, 0, i == 0 ? pathTracingDirectRes : i % 2 == 1 ? directFilterRes : forPinpongTexture)
				.ReadWrite(1, 2, 0, velocity)
				.Execute([&](RDGPassContext context) {
				auto& [w, h] = APP_WINDOWSIZE;
				RHICommandListRef command = context.command;
				command->SetComputePipeline(m_Pipeline);
				command->BindDescriptorSet(context.descriptors[1], 1);
				uint32_t curIndex = context.passIndex[0];
				command->PushConstants(&curIndex, sizeof(uint32_t), SHADER_FREQUENCY_COMPUTE);
				command->BindDescriptorSet(RENDER_RESOURCEMANAGER->GetGlobalResourcePerFrameDescriptorSet(), 0);
				command->Dispatch((w + 15) / 16, (h + 15) / 16, 1);
					})
				.Finish();
		}



		// 间接光
		for (int i = 0; i < 5; i++) {
			builder.CreateComputePass(GetName() + "_DirectRes" + std::to_string(i))
				.RootSignature(m_RootSignature)
				.PassIndex(i)
				.ReadWrite(1, 0, 0, i == 0 ? inDirectFilterRes : i % 2 == 1 ? forPinpongTexture : inDirectFilterRes)
				.ReadWrite(1, 1, 0, i == 0 ? pathTracingIndirectRes : i % 2 == 1 ? inDirectFilterRes : forPinpongTexture)
				.ReadWrite(1, 2, 0, velocity)
				.Execute([&](RDGPassContext context) {
				auto& [w, h] = APP_WINDOWSIZE;
				RHICommandListRef command = context.command;
				command->SetComputePipeline(m_Pipeline);
				command->BindDescriptorSet(context.descriptors[1], 1);
				uint32_t curIndex = context.passIndex[0];
				command->PushConstants(&curIndex, sizeof(uint32_t), SHADER_FREQUENCY_COMPUTE);
				command->BindDescriptorSet(RENDER_RESOURCEMANAGER->GetGlobalResourcePerFrameDescriptorSet(), 0);
				command->Dispatch((w + 15) / 16, (h + 15) / 16, 1);
					})
				.Finish();
		}


	}

}

直接光模糊后结果

间接光会有闪烁的情况

滤波公式，每次滤波时都是一个联合双边滤波

具体的联合双边滤波有三部分组成

先加入法线贡献

// 5x5 Atrous 核心 做了空洞滤波，相当于64*64的卷积核
uint curStep = 1 << curPassIndex;
for (int dy = -2; dy <= 2; ++dy) {
    for (int dx = -2; dx <= 2; ++dx) {
        ivec2 samplePos = invocID + ivec2(dx, dy) * int(curStep);

        // 边界检查
        samplePos = clamp(samplePos, ivec2(0), imgSize - 1);

        vec3 sampleColor = imageLoad(IN_COLOR, samplePos).xyz;
        // 高斯
        float gaussWeight = gaussKernel5x5[dx + 2 + (dy + 2) * 5];
        // 法线
        vec3 sampleNormal = imageLoad(NORMAL, samplePos).xyz;
        float normalWeight = pow(max(dot(normal, sampleNormal), 0.0), 128.0);

        float weight = gaussWeight*normalWeight;

        colorSum += sampleColor * weight;
        weightSum += weight;
    }
}

明显还是有问题的，因为小正方形上面和地面法线都朝上，所以贡献偏大了，阴影跑到了正方形上边

需要引入颜色差异来解决这个问题，毕竟阴影里的颜色和阴影外的最大区别就是颜色，很容易区分，另外还需要注意颜色差异是噪声造成的还是场景造成的（方差越大，越不应该作为权重评判的指标）

分子表示亮度差，差异越大权重越小，但差异过大也可能是噪声导致的，所以差异大并不一定表示颜色边界

所以引入方差来表示颜色的变化，方差越大，权重越大。就是越不考虑颜色差异的影响

这里的方差是指时间维度的方差，这样的话就得用MotionVector来找上一帧的位置，也就可以理解为如果一个像素位置颜色一直在变化，那它就很有可能只是噪声，就不应该用颜色差异来知道滤波，所以这一项权重就会变大

先根据一阶矩和二阶矩计算出方差

时间上的方差结果只用于第一次滤波，后续4次滤波用一个公式来更新方差值

PBRT（Reflection Models）

Thu, 25 Dec 2025 14:10:44 +0800

未完结

因为直接看了第7章，第4章还没看，需要先回去看一下4.3.1的BRDF、BTDF、BSSRDF

BXDF框架

BSDF

BRDF

很熟悉了，只定义了反射如何进行

Hemispherical–Directional Reflectance（半球–方向反射率）

从BRDF延申出的一个概念，把光照设置为常量1，这时候的渲染方程就变成了这个东西

它的意义是不关心光照，不关心各个方向的Radiance（均匀分布的光照），只关心材质本身往W0方向的Radiance

它可以用来检查物理守恒，物理正确的材质必须满足：

hemispherical–hemispherical reflectance（半球–半球反射率）

描述了一个面在所有入射方向上平均收到光照后，向所有方向反射的平均能量比例

这不就是把上一个半球–方向反射率求了一个半球积分后的平均么

上述两个东西，感觉是用在表达材质的反射效果的一个指标，并不是渲染需要的东西，写论文用的东西？

BTDF

T 表示transmittance ，BTDF用于描述透射的分布

这里特别提到BTDF并没有reciprocity 的特性，就是不能反着来

BTDF和BRDF被统称为BSDF，因为他们都可以表达为

最终BSDF作用到渲染中为（注意这里绝对值符号是PBRT自己加的，他们意思是并不会修改模型的法线朝向模型外侧，可能有他们的考虑）

整了半天4.3.1 原来并没有介绍具体的BSDF模型，只是引入了概念

BSSRDF

今天属于是理清楚了 scattering是各种各样的改变光方向的行为的统称，并不是额外的效果。。。

折射是透射的一种，透射是更上层的概念，透射就是进入某种介质的行为。。。

bidirectional scattering surface reflectance distribution function (BSSRDF) 描述的是此表面反射的理论框架

参数多了一个Pi，也就是Pi对着色点P0的贡献比例，比BSDF多一个维度，BSDF只考虑当前着色点

看这张图能看出光先进入物体内部，不断散射后从着色点穿出后到达摄像机

计算过程需要遍历每一个Pi，BSSDF定义这个Pi点的贡献值

内层积分定义一个Pi点的渲染贡献，外层积分累积所有Pi点

下图展示了(a) 漫反射 (b)高光反射 (c) 镜面反射（接近）（d）逆反射的Lobe

另外也理解了各项同性和异性，同性就是指如上图的摄像机位置，如果绕着法线进行旋转，得到的结果应该是一致的

基础理论

为可见光的波长（量级为米级）远小于渲染场景中物体的尺寸（毫米到米级），因此波动相关的现象通常不会在渲染图像中体现.

但要深入理解光线撞击表面时的行为，就需要借助波动光学的理论，而且在几何光学的模拟框架中融入波动光学的结论，已经成为计算机图形学的常用设计模式。

当光线照射到物体表面时，会激发材料原子外层的电子，使其发生快速振荡；振荡的电荷会产生次级电场振荡，这些次级振荡会发生相长干涉和相消干涉，这就是原子反射光线的核心机制。而干涉的具体表现，则由原子的种类和原子间的结合方式决定。

材料种类

电介质（Dielectrics）

这是一大类电绝缘体，包括玻璃、水、矿物油、空气等气态、液态、固态物质。这类材料中，电子与原子的结合非常牢固，不会自由移动。

导体（Conductors）

包括金属、合金以及类金属（如石墨）。这类材料的原子晶格中存在自由电子，入射电磁波激发的电子振荡可以让电子在较大范围内移动；同时，电子在晶格中移动时会以热量的形式耗散部分入射能量，导致光线在深入材料的过程中被快速吸收。

关键特性：光线通常在材料表面0.1 米的深度内被完全吸收，只有极薄的金属薄膜才能透射可观的光线。

半导体（Semiconductors）

如硅、锗，兼具电介质和导体的特性。例如硅在可见光波段表现出金属的特性，但在红外波段是透明的，因此可用于红外相机的光学元件。

PBRT后面介绍了IOR（折射率）的原理就是光速与在真空中的光速的比值，两种介质的折射率差值越大，分界面的反射效果越强。

反射定律

这张图解释了反射是如何计算的，分解成平行于法线和垂直于法线的两个向量后很容易计算

折射定律

经过一些推导最终折射的向量可以通过下面这个公式计算

折射需要有一个注意的地方：从折射率高进入折射率低（从水中看向空气）时，入射角度过大会导致折射算出来sin大于1了，此时发生的是全内反射，没有折射了

菲涅耳方程

上述的折射和反射是会同时发生的，对于导体来说，折射会迅速消失。

菲涅耳方程用来计算反射光的比例

这块东西解释了入射波可以分解为垂直（垂直于入射向量和法线组成的平面）和平行两个，单独进行建模。菲涅尔方程描述了给定已知振幅的入射波时，反射波振幅与入射波振幅之间的关系。（这些内容没必要特别细看）

电介质、导体和半导体均遵循相同的菲涅尔方程。

对于电介质，就按照上边的公式计算

对于导体，折射率之比变成用复数表示，然后各种解释，不太理解，看这里最终eta是一个复数，而不是简单的float比值，这种东西就不细看了

常见BXDF

完美模型

Diffuse Reflection（完美漫反射）

介绍了最简单的Lambertian model，完全均匀反射率的漫反射表面使用的模型

下图解释了为什么要除以/Pi。因为这样才能保证使总反射能量=R（反射率，用RGB就是albedo）

Conductor BRDF（完美反射）

导体的BRDF依据两个观点：

镜面反射定律为每条光线分配特定的反射方向，菲涅耳方程则确定反射光的分布范围。

任何残余光线都会折射进入导体，并被迅速吸收转化为热能

所以光滑导体只考虑BRDF、采样只会采样反射方向、PDF=1

非常简单，对W0有贡献的点只有反射方向，所以不需要算积分了，F()是菲涅尔方程

计算积分时的采样函数不需要什么工具，而是直接找反射方向，然后用菲涅尔公式计算反射比值，返回对这个方向的采样结果，另外PDF直接取1即可

Dielectric BSDF（完美反射+完美折射）

不像导体，这里就必须考虑反射和折射了

设置采样方向的方法是根据入射光角度，计算菲涅耳方程的反射比例，然后去一个随机数来概率选择BRDF还是BTDF

等比例选择BRDF和BTDF

根据反射比例来选择BRDF和BTDF，效果明显变好了，因为少了很多低贡献的采样

采样方式代码，会根据概率选择BRDF和BTDF

此时的PDF为

如果选择反射，和导体的采样方向一样

如果选择折射

Thin Dielectric BSDF（薄电介质，比如玻璃（跳过））

先理解薄电介质的物理背景（为什么需要单独建模）：

普通电介质（DielectricBxDF）只模拟 “单界面”（比如空气 - 玻璃），但实际的薄玻璃有两个平行界面（空气→玻璃→空气）：

光线入射到第一层界面：一部分反射，一部分透射进入玻璃；
透射光到达第二层界面：一部分透射出去，一部分反射回玻璃内部；
反射回的光又会在第一层界面反射 / 透射…… 这个过程无限递归（如图 9.16）；
薄电介质的核心假设：玻璃厚度极薄，光线的空间偏移可忽略，只需计算 “所有内部反射的总贡献”。

这个模型主要就是：多层内部反射的总反射率可以用几何级数求和简化（避免追踪无限次反射）

具体就先不看了！

Non-Symmetric Scattering and Refraction（跳过）

BTDF不能和BRDF一样反转使用，反转后必须修正系数才能保证物理正确。

这就不看了，看了一时半会也用不着

粗糙模型

微平面理论的关键洞见在于：无需对每个微平面进行显式几何建模，而是通过统计方法描述其集体行为

微面反射模型需考虑的三个重要几何效应。

(a)遮蔽效应：目标微面因被其他微面遮挡而不可见。

(b)阴影效应：类似地，光线无法抵达该微面。

(c)反射间效应：光线在到达观察者前会在微面间发生多次反射。

用法线分布来描述微表面，这里提到要让一小块微平面dA上方的面积投影下面积等于dA的面积

GGX法线分布

还有一种Beckmann法线分布

GGX的有点是拖尾，它的尾巴比较长，如下图橙色尾巴很长。而beckmannNDF在90°时已经衰减为非常接近0。如果把高出定义为高光，那backmannNDF高光周围会迅速衰减。而GGX会缓慢衰减，形成光晕的效果

后面介绍的过于理论了，感觉对目前帮助不大，先能进入行业再说，否则也没什么意义

PBRT（Monte Carlo Integration）

Mon, 22 Dec 2025 13:17:37 +0800

蒙特卡洛积分

开头一句话就解释了为什么渲染要用蒙特卡洛积分

虽然梯形积分法或高斯求积等标准数值积分技术在求解低维光滑积分时效果显著，但对于渲染中常见的高维不连续积分，其收敛速度却明显不足。蒙特卡洛积分技术为此提供了解决方案，通过随机采样评估积分，其收敛速度与被积函数的维度无关

概率论Review

读一遍，关键是回顾一下PMF/PDF CDF都是什么

随机变量

p(X)表达概率，称为PMF

这个是真忘了

对于连续随机变量，PMF取值始终是0，所以另外引入了PDF（概率密度函数）来表达连续性随机变量的概率情况

计算PDF的理论方法就是，在随机域上对PDF进行积分的结果得=1，反退出来的PDF函数是什么

另外PDF是累积分布函数的导数

PDF作用就很好理解了，他表示当前取值的概率密度，计算ab范围内的概率，就进行积分就是一段区域内的概率

期望，X的期望就可以通过积分X*PDF来计算

The Monte Carlo Estimator

蒙特卡洛公式的期望就等于原始需要计算的积分

蒙特卡洛公式，代码流程就是从PDF表示的分布中随机采样，计算积分值 / pdf值，多个采样点求和后除以采样数

可以看出一般形式的蒙特卡洛公式的期望仍然等于要求的积分

Error in Monte Carlo Estimators 蒙特卡洛积分的误差

使用方差与收敛时间评估蒙特卡洛积分

回顾方差的含义就是函数与其期望值的预期平方偏差

经典公式

多个独立随机变量的方差可以直接求和得到总的方差

蒙特卡洛积分相当于多个独立的随机变量的和，他的方差相当于每个随机变量的方差的和，因为另外因为蒙特卡洛积分要除以/N（样本数量），所以蒙特卡洛积分的方差会随着样本数量的增加而线性递减。

下面这段话是想说明蒙特卡洛算法的收敛速度不受维度影响，因此成为高维积分唯一实用的数值积分算法，TODO: 其实不是特别理解在说什么

使用方差线性递减这一特性，使用方差与运行实践来评估一个蒙特卡洛，方差和运行时间越小越好

并非所有积分估计量的期望值都等于积分本身。这类估计量被称为有偏估计量

虽然有偏，但随着样本数 N→∞N \to \inftyN→∞，误差会趋近 0，这类估计器称为一致（consistent）估计器

在积分估计中，有偏估计器虽然期望值不等于真实值，但可能方差更小、收敛更快，而且一致估计器随着样本数增加仍能得到正确结果；在 Monte Carlo 渲染中，绝大多数估计器是无偏的，光子映射是一个例外。

MSE（均方误差）：估计值与真实值之间的平方误差的期望（方差是估计值与估计值比较，均方误差是估计值与实际值比较）

对于无偏估计，那MSE就等于方差，否则即为方差与估计量偏差平方之和。

最后这点东西介绍，需要明白蒙特卡洛积分本身也是一个随机变量（因为他通过采样多个独立的随机变量来进行的），所以可以求蒙特卡洛的方差和均方误差，求法就是用样本进行估计，下边两幅图就是如何通过样本估计蒙特卡洛的方差和均方误差

这里提到的应该就是用样本估计随机变量的方差（也就是如何量化一个蒙特卡洛积分的方差）

利用样本估计的方差，是实际方差的估计值，所以本身也有方差

另外提到了MSE如何估计

Improving Efficiency 提升效率

Stratified Sampling 分层采样

简单理解就是把积分域划分为多个区域，每个区域按照自己的PDF去进行蒙特卡洛积分

把随机采样改成了在每个子区域随机采样，

下图i代表第i个积分区域，j代表第j个样本

随机采样结果

分层采样结果，对比能看出噪声更小了

分层采样的缺点与维度有关，维度太多分层也变得复杂

Importance Sampling 重要性采样

重要性抽样是一种强大的方差缩减技术，其原理基于蒙特卡洛估计量的特性

原理：若样本取自与被积函数函数形式相似的分布，则收敛速度更快。

如果被积函数是上图，PDF用下图，那最终得到的蒙特卡洛的方差要比随机采样好很多

PDF中间高，说明在这些点采样的概率高，在采样时也就更逼近真实的数据，很好理解的效果好

Multiple Importance Sampling 多重重要性采样

在面对被积函数是多个函数相乘（比如渲染方程就是BRDF Li cos 三项)的情况下的优化方案

首先举个例子，假如有两个PDF，刚好对应两个f(x)，如果我们使用PDFa作为采样的PDF时，最终样本都会只剩下fb(x)，因为PDFa与fa(x)更好成比例

此时蒙特卡洛积分的方差完全由fb(x)的方差决定，但他的方差可能是很高的，另外这是不可控的，因为被积函数是不能变动的。所以单纯依赖被积函数某一项的形状设计PDF，是不可靠的

MIS就是用来解决这个问题的

MIS的采样方案是

也就是用光源相关的PDF采样一次，用BRDF相关的PDF采样一次，并乘以各自的权重。

总结成公式就是

那权重如何计算呢（MIS 的权重来自一个要求：在保持无偏的前提下，让方差尽可能小。）PBRT 默认使用的是 Balance Heuristic。

抛开每种PDF生成的样本数量不谈，权重就是 PDF/所有PDF

更进一步，乘个幂次

紧接着提到单样本模型（Single-Sample MIS），其实就是上边的n都=1，就是每个PDF都只采样一次，方差就很低了

MIS Compensation 多重重要性采样补偿

比如一个渲染场景，光源项PDF与BRDF的PDF两个PDF进行多重重要性采样

这个东西必须学习完MIS并且实践后才能感悟他在干什么，这里先简单理解一下

此时的蒙特卡洛估计的MIS

BRDF在高光方向大量采样，但是这里的光源=0，最终采样样本=0

光源方向采样也因为权重被削弱

MIS虽然考虑到了不同的PDF的配合，但是如果一个PDF大量覆盖了积分接近0的区域，方差并不是最优

BSDF PDF 在“根本没有光”的方向仍然给了概率，总之就是在MIS的情况下，仍然会让积分区域接近0的位置分布大量的采样

一种MIS补偿方案是锐化概率分布，就是说在概率很小的地方，直接让他概率为0，不进行采样

低于阈值的概率 → 直接砍掉
剩下的概率 → 重新归一化
结果：PDF 更“尖锐”（sharpened）

Russian Roulette

跳过贡献度较小的样本，提升蒙特卡洛性能，同时保证无偏

C通常是0，q是一个[0-1]均匀分布的随机变量，有1-q的概率继续计算，有q的概率停止

可以看出来这样做并没有改变蒙特卡洛积分的无偏性

Splitting

同样需要结合具体场景来学习，这里先简单过一下

对于一个二重积分

每次采样都需要重新计算x样本和y样本

每次都要重新采 x

如果 x 很贵（比如一次主光线 / 路径前缀）

Splitting：核心思想

x 很贵，y 很便宜，那就：

先采一次 x

对这个 x，多采几个 y

Sampling Using the Inversion Method 逆变换法采样

已知PDF情况下，解决如何按照这个PDF进行采样的方法：反演变换法从CDF来进行采样

一句话解释思路就是：1. 根据$\xi$ 得到一个[0-1]直接的随机数，然后让 CDF函数 = 这个值，反向求出X

CDF图像的斜率就是PDF值，斜率越大，说明这个采样点的概率越大，同时斜率越大的区域在Y坐标被均匀采样的概率越大，总结结果就是用一个均匀分布采样结果为 PDF越大的区域越容易被采样

离散情况

利用均匀采样配合权重来按照权重进行采样，最终结果是按照权重来提高概率，算法本质是均匀采样

需要前边的公式，$\xi$ 是[0-1]之间均匀分布的随机变量， X是离散的随机变量，这个公式展示了如何从$\xi$去随机选择哪个X作为样本。也就是说用均匀分布的随机变量来采样X

这一操作在CDF图像上就是$\xi$ 取值作为Y轴位置，向右看对齐到哪一列就去Xi

这个东西的作用是在一个权重数组中，通过均匀分布来选择其中一个 最终结果不是均匀采样的，而是按照权重大小来进行的，但是过程本质利用的是均匀采样

这个代码最终返回一个权重索引，满足

连续情况

利用PDF对应的CDF来进行

从PDF采样的步骤：

计算CDF
还是利用均匀分布产生的随机数
构建等式$\xi$ = CDF(X)，反过来就算出来X是什么了

Transforming between Distributions

把上一章讲的逆变换法推演到任意情况，随机变量X的信息都知道，现在利用X对随机变量Y=f(X）进行抽样的方法

感觉目前不会遇到这样的问题，先跳过，不然学了也是忘

游戏引擎开发实践（GPU Driven）

Tue, 16 Dec 2025 13:30:40 +0800

上图展示了Mesh被另外一个摄像机剔除（剩下了AABB盒）、摄像机视锥被灯光影响的分簇结果

间接绘制

	void VulkanRHICommandContext::DrawIndirect(RHIBufferRef argumentBuffer, uint32_t offset, uint32_t drawCount)
	{
		/*
		*	绘制指令参数：
		   //indexed draw
			VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
				VkCommandBuffer                             commandBuffer,
				VkBuffer                                    buffer, // 存储绘制参数的Buffer
				VkDeviceSize                                offset, // Buffer起始偏移 
				uint32_t                                    drawCount,  // 绘制的次数
				uint32_t                                    stride); // Buffer中每个绘制指令的大小

			//non indexed draw
			VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(  // 参数与vkCmdDrawIndirect一致
				VkCommandBuffer                             commandBuffer,
				VkBuffer                                    buffer,
				VkDeviceSize                                offset,
				uint32_t                                    drawCount,
				uint32_t                                    stride);

			绘制Buffer参数：这个Buffer中存储的参数实际就是直接调用vkCmdDrawIndexed、vkCmdDraw需要的参数
			//indexed
			struct VkDrawIndexedIndirectCommand {
				uint32_t    indexCount;		// 索引数量
				uint32_t    instanceCount;	// 实例数量
				uint32_t    firstIndex;		// 索引偏移
				int32_t     vertexOffset;	// 顶点偏移
				uint32_t    firstInstance;	// 实例偏移
			};

			//non indexed
			typedef struct VkDrawIndirectCommand {
				uint32_t    vertexCount;   // 顶点数量
				uint32_t    instanceCount; // 实例数量
				uint32_t    firstVertex;   // 顶点偏移
				uint32_t    firstInstance; // 实例偏移
			} VkDrawIndirectCommand;

		*/
		vkCmdDrawIndirect(handle, CAST<VulkanRHIBuffer>(argumentBuffer)->GetHandle(), offset, drawCount, sizeof(RHIIndirectCommand));
	}

在支持Multi Draw时，一次API可以提交多个IndirectCommand绘制指令，drawCount参数为执行指令的数量，这样在多个Mesh共享同一个VBO和IBO的情况下，可以做到画多种Mesh只需要一次API提交。

这样使用的前提是Draw的context是一致的，中间不能切换（如果使用bindless的话，需要弄清楚怎么把Id传递进去）

另外一点，这个属于新特性，老的设备不支持Multi Draw

图片来自：https://zhuanlan.zhihu.com/p/362994106

Mesh剔除

基本思路就是使用ComputerShader提前剔除不需要渲染的DrawCall，创建Buffer->准备好剔除前的数据->上传到GPU->用HiZ对这些instance剔除 ->写buffer->传给api去绘制

这里的Hiz是用的上一帧的Hiz，毕竟还没处理好Mesh信息，这一帧还没有深度信息

是否支持实例化？

增加实例化后，每个RHIIndirectCommand的instanceCount将不再是1，也就是说一个DrawCallBuffer需要包含多个实例。但剔除并不是连续操作，比如实例100、101、102、103合并到一个DrawCallBuffer后，如果101被剔除。剩下100、102。DrawCallBuffer很好改（实例数量-1，起始实例仍然是100），但是因为101被剔除，那顶点着色器就无法连续操作。必须添加额外信息Buffer来支持。让顶点着色器知道自己处理的是哪个实例！总之，考虑到实例化会大大增加流程的复杂性。不考虑合并实例。

// TODO:DrawIndirectCountKHR 可以间接填写Buffer的数量，这样的话，可以在剔除时把没有被剔除的Buffer紧密排布，并且更新BufferCount,这样的好处就是剔除后的DrawCall不会像老方法一样，生成一条空的DrawCall

最终架构：

CPU端：每个Pass收集自己需要的MeshBatch，将MeshBatch按照PSO进行分类。相同PSO的MeshBatch最终被放在同一个MeshDrawCommand，通过一次DrawCall全部上传，同时把所有对应的间接渲染指令组成一个Buffer，一并上传至GPU（并且携带InstanceCount和CullingType用于GPU执行不同的剔除流程）

enum CullingType :uint32_t {
	CULLING_TYPE_BASE,
	CULLING_TYPE_DIRECTIONLIGHT_SHADOW,
	CULLING_TYPE_POINTLIGHT_SHADOW,
	CULLING_TYPE_MAX_CNT
};

/*
	为了方便剔除时拿到详细信息，上传的Buffer不能只包含绘制指令,还需要记录实例数量,如果后续需要更多信息，可以扩展这个结构体
*/
struct MeshIndirectDrawData {
	 uint32_t instanceCount;
	 CullingType passType;
	 uint32_t _padding[2];

	 std::array<RHIIndirectCommand, MAX_PER_FRAME_INSTANCE_SIZE> indirectCommands;
};

/*
	最终定义一次DrawCall需要的信息
	1. 使用的PSO
	2. 间接绘制Buffer的Batch（PSO一致的绘制指令可以一次性全部上传）
*/
struct MeshDrawCommand
{
	RHIGraphicsPipelineRef pipeline;
	IndexRange meshCommandRange = { 0, 0 };
};

class MeshPassProcessor {
public:
	void Init(CullingType PassType);
	void Process(const std::vector<MeshBatch>& drawBatches);
	void Draw(RHICommandListRef command);
	void AddBatch(const MeshBatch& batch) { m_MeshBatches.push_back(batch); }
	void OnBuildDrawCommands(RHIGraphicsPipelineRef pipeline, std::vector<MeshBatch>& meshBatch);
	uint32_t GetDrawCommandCount() { return m_MeshBatches.size(); }
	RHIBufferRef GetMeshIndirectDrawDataBuffer() { return m_MeshIndirectDrawDataBuffer[APP_FRAMEINDEX]->GetRHIBuffer(); }

protected:
	virtual void MeshPassProcessor::AddMeshBatch(const MeshBatch& batch) = 0;
	virtual RHIGraphicsPipelineRef OnCreatePipeline(const DrawPipelineState& first) = 0;
private:
	void MapMeshBatches(MeshBatch& batch);
private:
	std::vector<MeshBatch> m_MeshBatches; // 收集当前Pass需要的batch
	CullingType m_PassType;
	std::array<std::shared_ptr<RenderBuffer<MeshIndirectDrawData>>, FRAMES_IN_FLIGHT> m_MeshIndirectDrawDataBuffer;
	std::map<DrawPipelineState, std::vector<MeshBatch>> m_MeshBatchMap;
	std::vector<MeshDrawCommand> m_MeshDrawCommands;  // 存储这个是为了Draw的时候遍历
	std::vector<RHIIndirectCommand> m_IndirectCommands; // 存储这个是为了把Commands一口气上传
};
using MeshPassProcessorRef = std::shared_ptr<MeshPassProcessor>;

渲染时，通过MeshDrawCommand中提前记录的偏移，直接指定Buffer的offset和DrawCount(此时的Buffer已经被剔除了，被提出的渲染指令实例数量被设置为0)

	void MeshPassProcessor::Draw(RHICommandListRef command) {
		for (auto& drawCommand : m_MeshDrawCommands)
		{
			auto [w, h] = APP_WINDOWSIZE;

			command->SetGraphicsPipeline(drawCommand.pipeline);

			if (drawCommand.meshCommandRange.size > 0)
			{
				command->DrawIndirect(
					m_MeshIndirectDrawDataBuffer[APP_FRAMEINDEX]->GetRHIBuffer(),
					4 * sizeof(uint32_t) + drawCommand.meshCommandRange.begin * sizeof(RHIIndirectCommand),
					drawCommand.meshCommandRange.size);
			}
		}
	}

GPU端：通过 gl_GlobalInvocationID.x获取实例ID，通过gl_GlobalInvocationID.y获取剔除类型，将不可见的实例buffer的实例数量设置为0

#version 450 core
#include "../common/common.glsl"
#include "../common/constant.glsl"
#include "../common/intersection.glsl"
#ifdef COMPUTE_SHADER

const uint MESH_PASS_TYPE_BASE = 0u;
const uint MESH_PASS_TYPE_DIRECTIONLIGHT_SHADOW = 1u;
const uint MESH_PASS_TYPE_POINTLIGHT_SHADOW = 2u;



#define LOCAL_X 32   // instance
#define LOCAL_Y 1    // MeshPassType
#define LOCAL_Z 1
layout(set = 1,binding = 0) buffer drawbuffer{
    uint instanceCount;
    uint passType;
    uint _padding[2];
    RHIIndirectCommand buffers[MAX_PER_FRAME_INSTANCE_SIZE];
} ALL_CULLING_BUFFERS[4];
layout(local_size_x = LOCAL_X, local_size_y = LOCAL_Y, local_size_z = LOCAL_Z) in;
void main()
{ 
    uint threadInstanceId = gl_GlobalInvocationID.x;
    uint passTypeId = gl_GlobalInvocationID.y;
    if(threadInstanceId >= ALL_CULLING_BUFFERS[passTypeId].instanceCount){
        return;
    }
    uint instanceId = ALL_CULLING_BUFFERS[passTypeId].buffers[threadInstanceId].firstInstance;

    // 摄像机剔除
    if(ALL_CULLING_BUFFERS[passTypeId].passType == MESH_PASS_TYPE_BASE){

    }else if(ALL_CULLING_BUFFERS[passTypeId].passType == MESH_PASS_TYPE_DIRECTIONLIGHT_SHADOW){ // 定向光剔除
        ALL_CULLING_BUFFERS[passTypeId].buffers[threadInstanceId].instanceCount = 0u;

    }else if(ALL_CULLING_BUFFERS[passTypeId].passType == MESH_PASS_TYPE_POINTLIGHT_SHADOW){ // 点光剔除

    }
}

#endif

剩下的工作就是各种求交测试，判断可见性了

相交判断

摄像机的范围定义为视锥Frustum，一个平面定义为$ax + by + cz + d = 0$,每个平面可以用glm::vec4来表示，摄像机的视锥范围就可以用6个平面代替，根据平面方程的性质，(a,b,c)就是这个平面的法线

获取视锥平面

首先需要定义视锥，视锥体由六个面组成

使用union来方便给Shader进行统一架构，因为GPU剔除时并不需要知道当前判断的是哪个平面的相交，只需要一次遍历6个面即可

    struct Frustum
    {
        union
        {
            struct
            {
                glm::vec4 planeRight;
                glm::vec4 planeLeft;
                glm::vec4 planeTop;
                glm::vec4 planeBottom;
                glm::vec4 planeNear;
                glm::vec4 planeFar;
            };
            glm::vec4 planes[6];
        };
    };

下面工作就是如何计算当前摄像机的6个平面了

如何构造一个平面？

法线量 + 一个点定义一个平面

三个点确定一个平面（其实通过三个点构造两个向量，对两个向量叉乘即可得到法向量，这样也就转化成了第一种情况）

对于Far和Near两个平面，法向量: 摄像机的forward向量，点: 用camera.position + forward * (near或者far的距离)
对与上下左右四个平面，摄像机的位置始终经过四个平面，点就确定了。法向量需要叉乘来实现，具体步骤就是先计算远平面的4个交点的坐标，与摄像机位置构成两个向量叉乘后得到法向量

求Far平面坐标用Fov来求

上面的方法从理论上很好理解，但是下面的方法是直接从viewPorj矩阵中计算出来6个平面的vec4

下面这种方案是在寻找对空间中点的约束，来构造平面方程。约束条件就是视锥平面上任何一点（世界坐标系下）进行VP变换后，要在NDC范围的边界上，从而构建一个等式求解的

首先VP矩阵的意义就是把世界坐标下的点$\vec{P}=(x,y,z,1)$转移到NDC空间，经过变换后的点表示为$\vec{P_{clip}}=(x_c, y_c, z_c, w_c)$

以右裁剪面为例。$(x_c = w_c)$是NDC最大支持的右边界（这个本质就是透视除法后，xc=1是最大边界）。

再来看VP矩阵 * 一个列向量（世界空间顶点位置），计算过程就是（注意这里的取值是按照列主序进行的）

把计算过程带入$(x_c = w_c)$得到

这也就是说世界空间点P与VP矩阵满足上边这个关系的点都在视锥的右面。把这个约束展开

也就得到了平面方程（本质就是空间中的点满足这个约束的点集组成的平面，这种方法就是在寻找这种约束）

    Frustum CreateFrustumFromMatrix(const glm::mat4& VP)
    {
        Frustum frustum;
        // 右平面
        frustum.planeRight = glm::vec4(
            VP[0][3] - VP[0][0],
            VP[1][3] - VP[1][0],
            VP[2][3] - VP[2][0],
            VP[3][3] - VP[3][0]
        );

        // 左平面
        frustum.planeLeft = glm::vec4(
            VP[0][3] + VP[0][0],
            VP[1][3] + VP[1][0],
            VP[2][3] + VP[2][0],
            VP[3][3] + VP[3][0]
        );

        // 上平面
        frustum.planeTop = glm::vec4(
            VP[0][3] - VP[0][1],
            VP[1][3] - VP[1][1],
            VP[2][3] - VP[2][1],
            VP[3][3] - VP[3][1]
        );

        // 下平面
        frustum.planeBottom = glm::vec4(
            VP[0][3] + VP[0][1],
            VP[1][3] + VP[1][1],
            VP[2][3] + VP[2][1],
            VP[3][3] + VP[3][1]
        );

        // 远平面
        frustum.planeFar = glm::vec4(
            VP[0][3] - VP[0][2],
            VP[1][3] - VP[1][2],
            VP[2][3] - VP[2][2],
            VP[3][3] - VP[3][2]
        );

        // 近平面
        frustum.planeNear = glm::vec4(
            VP[0][3] + VP[0][2],
            VP[1][3] + VP[1][2],
            VP[2][3] + VP[2][2],
            VP[3][3] + VP[3][2]
        );

        // 归一化
        auto normalizePlane = [](glm::vec4& p)
            {
                float len = glm::length(glm::vec3(p));
                p /= len;
            };

        normalizePlane(frustum.planeRight);
        normalizePlane(frustum.planeLeft);
        normalizePlane(frustum.planeTop);
        normalizePlane(frustum.planeBottom);
        normalizePlane(frustum.planeNear);
        normalizePlane(frustum.planeFar);

        return frustum;
    }

上边第二个方案相比第一个方案计算量就少很多了

视锥与AABB相交

计算AABB的8个角点，是否都在视锥体外部

判断思路就是，如果8个角点都在面的同一侧，那么整个AABB盒都在面的一侧（与面没有相交）

判断如果AABB盒在6个面的同一侧，那他肯定就没有相交

首先注意，不能反过来求是否有角点在视锥体内部，来判断相交，原因如下图，D的角点都在外部，但是他在视锥体内部

如何判断一个点在平面的哪一侧呢？

在下图场景中，OA与法线的cos即可判断，大于0不就是与法线在同一侧呗，或者直接把点带入平面方程，如果结果大于0，那他就在法向量的同侧

如果8个点在任意一个视锥面的外侧，那这个AABB盒就在视锥体外侧

同样，以上方法是逻辑上很清晰的代码，但是实践中为了效率，有更好的方法

SAT 分离轴定理

对于两个凸几何体 A 和 B，若存在一条直线（轴），使得 A 和 B 在这条轴上的投影互不重叠，则称这条轴为「分离轴」，此时 A 和 B 不相交；若不存在这样的分离轴，则 A 和 B 相交（或包含）。也就是说只要找到一条轴能分离，那两个物体肯定不相交

对于很规则的形状，只需要依次在每条边的垂直线做投影即可

注意不适用于凹多面体

在当前场景下，视锥的分离轴就只有6个（6个平面的法向量）

所有AABB盒与平面的相交判断，集中在平面的法向量这条分离轴上。十分精炼的代码还是需要一步步理解

首先平面在分离轴上如何定义？

因为分离轴是平面的法线，所以在分离轴上来看，平面是一个点。

那如何表达平面在分离轴的位置呢？（也就是说得先定义一个分离轴的原点） 把原点作为分离轴的原点 （在写这个的时候忽略了一个点，法线肯定是过原点来定义的，所以分离轴肯定是过原点的，另外分离轴的空间位置是没有意义的，因为投影后结果都是一样的，所以放在原点也比较合理）

这时平面在分离轴的坐标就是(-d) (拿一个简单的平面画图推一下就能看出来)

到这里分离轴代表的1D坐标系已经有了。

下一步理解AABB如何投影到这个坐标系上

AABB的每个点都可以定义为从000到点位置的向量，然后把他投影到了分离轴上，下一步就是求AABB在分离轴上的范围

到这里就理解了最大偏移，也理解了项目代码中那个蜜汁操作的含义

/*
	当前Frustum的6个平面的法向量都指向内部

	这里的相交判断利用的是SAT（分离轴定理），平面的法向量方向作为分离轴，这时，整个平面在分离轴上就只是一个点，
	
*/
bool FrustumIntersectBox(Frustum frustum, BoundingBox box)
{
    vec3 center = (box.maxBound + box.minBound) * 0.5;
    vec3 extent = (box.maxBound - box.minBound) * 0.5;

    for (int i = 0; i < 6; i++)
    {
        vec4 plane = frustum.planes[i];

		// 这段蜜汁代码需要结合记录的博客来看，真的不理解清除，这代码写的简直是顶级防御性编程
        vec3 absN = abs(plane.xyz);
        float radius = dot(absN, extent); // AABB中心到AABB的所有投影位置的最大距离
        float distance = dot(plane.xyz, center) + plane.w;  // -plane.w是平面的投影
        if (distance < -radius)
            return false;
    }

    return true;
}

点光源剔除

点光源的范围是一个球，只需要做一个球和AABB的相交判断

bool SphereIntersectBox(BoundingSphere sphere, BoundingBox box)
{
    vec3 closestPoint = clamp(
        sphere.center,
        box.minBound,
        box.maxBound
    );
    vec3 delta = closestPoint - sphere.center;
    float distSq = dot(delta, delta);
    return distSq <= sphere.radius * sphere.radius;
}

#version 450 core
#include "../common/common.glsl"
#include "../common/constant.glsl"
#include "../common/intersection.glsl"
#ifdef COMPUTE_SHADER

const uint MESH_PASS_TYPE_BASE = 0u;
const uint MESH_PASS_TYPE_DIRECTIONLIGHT_SHADOW = 1u;
const uint MESH_PASS_TYPE_POINTLIGHT_SHADOW = 2u;

#include "../common/gizmo.glsl"

#define LOCAL_X 32   // instance
#define LOCAL_Y 1    // MeshPassType
#define LOCAL_Z 1
layout(set = 1, binding = 0) buffer drawbuffer{
    uint instanceCount;
    uint passType;
    uint _padding[2];
    RHIIndirectCommand buffers[MAX_PER_FRAME_INSTANCE_SIZE];
} ALL_CULLING_BUFFERS[4];
layout(local_size_x = LOCAL_X, local_size_y = LOCAL_Y, local_size_z = LOCAL_Z) in;
void main()
{ 
    uint threadInstanceId = gl_GlobalInvocationID.x;
    uint passTypeId = gl_GlobalInvocationID.y;
    if(threadInstanceId >= ALL_CULLING_BUFFERS[passTypeId].instanceCount){
        return;
    }
    uint instanceId = ALL_CULLING_BUFFERS[passTypeId].buffers[threadInstanceId].firstInstance;
    mat4 modelMatrix = GetModelMatrix(instanceId);
    BoundingBox aabb = GetOriginBoundingBox(instanceId);    
    aabb = BoundingBoxTransform(aabb,modelMatrix);

    // 摄像机剔除  TODO：用前一帧的HIZ进行遮挡剔除？
    if(ALL_CULLING_BUFFERS[passTypeId].passType == MESH_PASS_TYPE_BASE){

        Camera camera = GetCamera();

        if(GetRenderSetting().renderBoundingBox == 1){
            AddGizmoBoundingBox(aabb, vec4(1,0,0,1));
        }

        bool isVisiable = FrustumIntersectBox(camera.frustum, aabb);

        if(!isVisiable){
            ALL_CULLING_BUFFERS[passTypeId].buffers[threadInstanceId].instanceCount = 0u;
        }

    }else if(ALL_CULLING_BUFFERS[passTypeId].passType == MESH_PASS_TYPE_DIRECTIONLIGHT_SHADOW){ 
        DirectionLight light = GetDirectionLight();
        
        bool isVisiable = FrustumIntersectBox(light.frustum[0], aabb);   // TODO: 现在只考虑一个级联的剔除（导致现在只有CSM=0距离内有阴影），也就是后三个级联的剔除用的第一个视锥，这是错的！！！解决需要想办法把当前是处理第几个级联的信息传递进来~现在架构不够灵活，还不太好传递呢~
        if(!isVisiable){
            ALL_CULLING_BUFFERS[passTypeId].buffers[threadInstanceId].instanceCount = 0u;
        }


    }else if(ALL_CULLING_BUFFERS[passTypeId].passType == MESH_PASS_TYPE_POINTLIGHT_SHADOW){ // 点光剔除

        BoundingSphere sphere = GetPointLight(0).sphere;

        bool isVisiable = SphereIntersectBox(sphere, aabb);
        if(!isVisiable){
            ALL_CULLING_BUFFERS[passTypeId].buffers[threadInstanceId].instanceCount = 0u;
        }

    }
}


#endif

目前的剔除完成了最简单的版本，每个Pass都会进行自己需要的Mesh的剔除，在间接渲染时拿着被修改的IndirectDrawBuffer去渲染

Cluster Based Lighting

把摄像机视锥分簇，每个簇记录会影响它的光源信息，计算光照时，先判断着色点属于哪个簇，只遍历影响它的光源

数据结构

目前灯光存储依靠两个结构

// 获取灯光信息的地方
struct LightInfo
{
	uint32_t directionLightCount = 0;
	uint32_t pointLightCount = 0;
	uint32_t spotLightCount = 0;
	uint32_t _padding0;

	DirectionLight dirLights;
	PointLight pointLights[MAX_POINT_LIGHT_SIZE];
	SpotLight spotLights[MAX_SPOT_LIGHT_SIZE];
};

// 所有的光源信息统一存储在
layout(set = 0, binding = GLORBAL_RESOURCE_BINDING_LIGHTINFO) readonly buffer LightInfoBuffer {
    LightInfo data;
} LIGHTINFO;
LightInfo GetLightInfo()
{
    return LIGHTINFO.data;
}
DirectionLight GetDirectionLight()
{
    return LIGHTINFO.data.dirLights;
}
PointLight GetPointLight(uint index)
{
    return LIGHTINFO.data.pointLights[index];
}
SpotLight GetSpotLight(uint index)
{
    return LIGHTINFO.data.spotLights[index];
}
uint GetPointLightCount()
{
    return LIGHTINFO.data.pointLightCount;
}
uint GetSpotLightCount()
{
    return LIGHTINFO.data.spotLightCount;
}

参考下图进行架构簇，每个簇存储起始位置和数量，所有簇的灯光id信息统一存储在lightAssignBuffer中，在簇Buffer中只存储起始索引和数量

簇的划分

先存Forward方向进行深度划分，可以采样平均切分或者对数切分

在写Shader时疏忽了一个很早之前的知识点，线性深度和非线性深度。

在当前场景下，如果在near-far之间定义深度，是线性深度，但是如果想通过逆变换把屏幕空间坐标转回世界坐标，必须提供非线性深度，但是直接把自己自定义的深度转为非线性后配合当前UV来计算是错的，因为深度与XY的计算是有联系的，自定义深度破坏了这种联系

1
2

float minZ 	= (far - near) / LIGHT_CLUSTER_DEPTH * float(globalID.z) + near;
float maxZ 	= (far - near) / LIGHT_CLUSTER_DEPTH * float(globalID.z + 1) + near;

所以采用射线来定义方向，再用深度来计算最终的世界位置深度

/*
	传入自定义深度（线性深度[near-far]）
*/
vec3 SceenToWorldCustomDepth(vec2 uv, float viewZ, Camera camera)
{
    vec2 ndcXY = uv * 2.0 - 1.0;
    vec4 ndcPos = vec4(ndcXY, 0.0, 1.0);
    vec4 viewPos = camera.invProj * ndcPos;
    viewPos /= viewPos.w;
    vec3 viewDir = normalize(viewPos.xyz);
    float t = viewZ / (-viewDir.z);
    vec3 finalViewPos = viewDir * t;
    vec4 worldPos = camera.invView * vec4(finalViewPos, 1.0);
    return worldPos.xyz;
}

哎这种写起来太麻烦，重新看了一眼博客，它的做法是直接拿near和Far进行映射，然后再切分，也就是转为世界坐标的点都在Near和Far上，然后调整按比例调整

最终版本，还捎带实现了多摄像机系统，为了方便调试

#version 450 core
#include "../common/common.glsl"
#include "../common/constant.glsl"
#include "../common/intersection.glsl"
#include "../common/math.glsl"
#include "../common/gizmo.glsl"
#ifdef COMPUTE_SHADER

layout(set = 1, binding = 0, rg32ui) uniform  uimage2DArray u_Clusters;   // FORMAT_R32G32_UINT
layout(set = 1, binding = 1) buffer lightIDs{

    uint lightID[];

}u_lightIDs;

#define THREAD_SIZE_X 8
#define THREAD_SIZE_Y 8
#define THREAD_SIZE_Z 1
layout (local_size_x = THREAD_SIZE_X, 
		local_size_y = THREAD_SIZE_Y, 
		local_size_z = THREAD_SIZE_Z) in;

void main()
{
    uvec3 globalID = gl_GlobalInvocationID;
    Camera camera;
    if(GetRenderSetting().ClusterLightFrustum == 1){ 
        camera = GetDefaultCamera();
    }else{
        camera = GetCamera();
    }
    camera.InverseViewProj = inverse(camera.projNoJetter * camera.view);  // 后续都用的projNoJetter
    float w = camera.width;
    float h = camera.height;
	uint clusterX = uint((w + LIGHT_CLUSTER_GRID_SIZE - 1) / LIGHT_CLUSTER_GRID_SIZE);
    uint clusterY = uint((h + LIGHT_CLUSTER_GRID_SIZE - 1) / LIGHT_CLUSTER_GRID_SIZE);
    uint clusterZ = LIGHT_CLUSTER_DEPTH;
    uint clusterCount = clusterX * clusterY * clusterZ;


    if (globalID.x >= clusterX || globalID.y >= clusterY || globalID.z >= clusterZ) {
        return;
    }

    //////////////////////////////////////// 计算每个簇的世界坐标（先计算NDC坐标下8个顶点位置，转到世界空间即可） ///////////////////////////////////////////
    float ndcMinx = float(globalID.x) / float(clusterX);
    float ndcMiny = float(globalID.y) / float(clusterY);
    float ndcMaxx = (float(globalID.x) + 1) / float(clusterX);
    float ndcMaxy = (float(globalID.y) + 1) / float(clusterY);

    // 线性划分
    float minZ = float(globalID.z) / float(clusterZ);
    float maxZ = float((globalID.z + 1)) / float(clusterZ);

    // 一长条的簇
    vec3 p0 = SceenToWorld(vec2(ndcMinx, ndcMiny), 0, camera);
    vec3 p1 = SceenToWorld(vec2(ndcMinx, ndcMiny), 1, camera);
    vec3 p2 = SceenToWorld(vec2(ndcMinx, ndcMaxy), 0, camera);
    vec3 p3 = SceenToWorld(vec2(ndcMinx, ndcMaxy), 1, camera);
    vec3 p4 = SceenToWorld(vec2(ndcMaxx, ndcMiny), 0, camera);
    vec3 p5 = SceenToWorld(vec2(ndcMaxx, ndcMiny), 1, camera);
    vec3 p6 = SceenToWorld(vec2(ndcMaxx, ndcMaxy), 0, camera);
    vec3 p7 = SceenToWorld(vec2(ndcMaxx, ndcMaxy), 1, camera);


    // 在World下切分深度
    vec3 clusterP0 = p0 + minZ * (p1-p0);
    vec3 clusterP1 = p0 + maxZ * (p1-p0);
    vec3 clusterP2 = p2 + minZ * (p3-p2);
    vec3 clusterP3 = p2 + maxZ * (p3-p2);
    vec3 clusterP4 = p4 + minZ * (p5-p4);
    vec3 clusterP5 = p4 + maxZ * (p5-p4);
    vec3 clusterP6 = p6 + minZ * (p7-p6);
    vec3 clusterP7 = p6 + maxZ * (p7-p6);



    vec3 clusterCenter = (clusterP0 + clusterP1 + clusterP2 + clusterP3 + clusterP4 + clusterP5 + clusterP6 + clusterP7) / 8;

    // 构建视锥
    Frustum frustum;
    frustum.planes[0] = calculatePlane(clusterP0, clusterP2,clusterP4, clusterCenter); // 近平面
    frustum.planes[1] = calculatePlane(clusterP5, clusterP7, clusterP1, clusterCenter); // 远平面
    frustum.planes[2] = calculatePlane(clusterP0, clusterP1, clusterP2, clusterCenter); // 左平面
    frustum.planes[3] = calculatePlane(clusterP4, clusterP6,clusterP5, clusterCenter); // 右平面
    frustum.planes[4] = calculatePlane(clusterP0, clusterP4, clusterP5, clusterCenter); // 下平面
    frustum.planes[5] = calculatePlane(clusterP2, clusterP3, clusterP6, clusterCenter); // 上平面

    //////////////////////////////////////// 相加测试与记录数据 ///////////////////////////////////////////
	uint lightIDs[MAX_LIGHTS_PER_CLUSTER];
    uint lightCount = 0;
    for(int i = 0; i < GetPointLightCount(); i++){
	    BoundingSphere sphere = GetPointLight(i).sphere;
        bool isVisiable = FrustumIntersectSphere(frustum, sphere);
        if(isVisiable){
            lightIDs[lightCount++] = i;
            if(GetRenderSetting().ClusterLightFrustum == 1){ // debug受影响的视锥
                DrawFrustumEdges(clusterP0, clusterP2,clusterP6, clusterP4, clusterP1, clusterP3,  clusterP7, clusterP5, vec4(1, 0, 0, 1.0));
            }
        }
	}

    // 记录数据
    uint startOffset = atomicAdd(LIGHTINFO.data.clusterAtomicOffset,lightCount);   // 它返回的是操作前的数据
    for(uint i = 0; i < lightCount; i++){
        u_lightIDs.lightID[startOffset + i] = lightIDs[i];
    }
    imageStore(u_Clusters, ivec3(globalID), uvec4(uvec2(lightCount, startOffset), 0, 0));

}
#endif

ivec3 GetClusterIndex(vec3 worldPos,Camera camera)
{
    vec3 viewPos = (camera.view * vec4(worldPos, 1.0)).xyz;

    float zView = -viewPos.z;

    if (zView <= camera.Near)
        zView = camera.Near;
    if (zView >= camera.Far)
        zView = camera.Far;


    vec4 clipPos = camera.proj * vec4(viewPos, 1.0);
    vec3 ndcPos  = clipPos.xyz / clipPos.w;   // [-1, 1]

    vec2 screenUV = ndcPos.xy * 0.5 + 0.5;     // [0, 1]
    vec2 pixelPos = screenUV * vec2(camera.width, camera.height);

    uint clusterX = uint((camera.width  + LIGHT_CLUSTER_GRID_SIZE - 1)
                          / LIGHT_CLUSTER_GRID_SIZE);
    uint clusterY = uint((camera.height + LIGHT_CLUSTER_GRID_SIZE - 1)
                          / LIGHT_CLUSTER_GRID_SIZE);
    uint clusterZ = LIGHT_CLUSTER_DEPTH;

    uint x = uint(pixelPos.x / LIGHT_CLUSTER_GRID_SIZE);
    uint y = uint(pixelPos.y / LIGHT_CLUSTER_GRID_SIZE);

    x = clamp(x, 0u, clusterX - 1);
    y = clamp(y, 0u, clusterY - 1);

    float zNorm = (zView - camera.Near) / (camera.Far - camera.Near);
    uint  z     = uint(zNorm * float(clusterZ));

    z = clamp(z, 0u, clusterZ - 1);

    return ivec3(x, y, z);
}

这张图展示了Mesh剔除和灯光分簇

UE源码学习（渲染机制）

Sat, 13 Dec 2025 12:29:39 +0800

内容参考https://www.cnblogs.com/timlly/p/14588598.html、https://www.cnblogs.com/timlly/p/14327537.html#25-ue%E7%9A%84%E5%A4%9A%E7%BA%BF%E7%A8%8B%E6%B8%B2%E6%9F%93

内容总结:

游戏线程的组件如何与渲染线程的Proxy进行交互

从proxy到RHI层命令之间的转换流程

多线程渲染

这块东西，如果想深入看代码的话，需要先学习UE的多线程架构，TaskGraph什么的，目前还没看。游戏线程->渲染线程->RHI线程（这个分工我的渲染器已经简单实现了一个版本，不过RHI没有单独开线程，放在渲染线程之后执行 https://github.com/sdpyy1/GameEngine-dev/tree/mutliThread）

emmm 看到后边发现，上边说的是错的，我实现的实际上只是RHI线程，渲染线程其实还是主线程执行的

游戏线程的对象通常做逻辑更新，在内存中有一份持久的数据，为了避免游戏线程和渲染线程产生竞争条件，会在渲染线程额外存储一份内存拷贝，并且使用的是另外的类型，以下是UE比较常见的类型映射关系（游戏线程对象以U开头，渲染线程以F开头）

单独划分出RHI线程，让渲染线程更稳定了。不理解。。

游戏线程和渲染线程的交互

先弄清楚游戏组件向SceneProxy传递数据的机制，下面内容主要是如何把组件信息传递给渲染线程，如果把组件修改信息传递给渲染线程

三个基础概念：

- UPrimitiveComponent：图元组件，是所有可渲染或拥有物理模拟的物体父类。是CPU层裁剪的最小粒度单位

- FScene：是UWorld在渲染模块的代表。只有加入到FScene的物体才会被渲染器感知到。渲染线程拥有FScene的所有状态（游戏线程不可直接修改）。

- FPrimitiveSceneProxy：图元场景代理，是UPrimitiveComponent在渲染器的代表，镜像了UPrimitiveComponent在渲染线程的状态。

下面也就是把这个组件传入FScene的过程，就是在渲染器的FScene中创建一个代理对象，并把收集到的信息传递给渲染线程

// 输入一个UPrimitiveComponent组件，把他加到渲染器可感知的FScene中
void FScene::AddPrimitive(UPrimitiveComponent* Primitive)
{	
	// If the bulk reregister flag is set, add / remove will be handled in bulk by the FStaticMeshComponentBulkReregisterContext
	if (Primitive->bBulkReregister)
	{
		return;
	}
	BatchAddPrimitivesInternal(MakeArrayView(&Primitive, 1));
}

void FScene::BatchAddPrimitivesInternal(TArrayView<T*> InPrimitives){
    ...
        
    for (T* Primitive : InPrimitives){
		FPrimitiveSceneProxy* PrimitiveSceneProxy  = nullptr;
      	...
            // 创建代理
		PrimitiveSceneProxy = Primitive->GetPrimitiveComponentInterface()->CreateSceneProxy();
        ...
    }
    
    // 把批量创建信息传递到渲染线程  ENQUEUE_RENDER_COMMAND（内部的lambda会放在渲染线程中执行）
    ...
    ENQUEUE_RENDER_COMMAND(AddPrimitiveCommand)(
	[this, CreateCommands = MoveTemp(CreateCommands)](FRHICommandListBase& RHICmdList)
    {
        for (const FCreateCommand& Command : CreateCommands)
        {
            FScopeCycleCounter Context(Command.PrimitiveSceneProxy->GetStatId());
            Command.PrimitiveSceneProxy->SetTransform(RHICmdList, Command.RenderMatrix, Command.WorldBounds, Command.LocalBounds, 		                   Command.AttachmentRootPosition);
            Command.PrimitiveSceneProxy->CreateRenderThreadResources(RHICmdList);
		    // 在渲染线程中将SceneInfo加入到场景中.
            AddPrimitiveSceneInfo_RenderThread(Command.PrimitiveSceneInfo, Command.PreviousTransform);
        }
    });
}

下面看看创建代理对象的过程

看这个情况，是每个组件都有自己创建场景代理的流程

随便翻一翻他们干了什么

// 聚光组件
FLightSceneProxy* USpotLightComponent::CreateSceneProxy() const
{
	if (IsSpotLightSupported(this))
	{
		return new FSpotLightSceneProxy(this);
	}
	return nullptr;
}
// skyLight组件
FSkyLightSceneProxy* USkyLightComponent::CreateSceneProxy() const
{
	if (ProcessedSkyTexture || IsRealTimeCaptureEnabled())
	{
		return new FSkyLightSceneProxy(this);
	}

	return NULL;
}

// staticMesh组件比较复杂，不过翻到最后也是进入了	
auto* Proxy = ::new FStaticMeshSceneProxy(this, false);

他们都进入了各自的复杂的构造函数链，一直翻到最顶层

比如灯光代理

FLightSceneProxy::FLightSceneProxy(const ULightComponent* InLightComponent)
	: LightComponent(InLightComponent)
	, SceneInterface(InLightComponent->GetScene())
	, IndirectLightingScale(InLightComponent->IndirectLightingIntensity)
	, VolumetricScatteringIntensity(FMath::Max(InLightComponent->VolumetricScatteringIntensity, 0.0f))
	, ShadowResolutionScale(InLightComponent->ShadowResolutionScale)
	, ShadowBias(InLightComponent->ShadowBias)
	, ShadowSlopeBias(InLightComponent->ShadowSlopeBias)
	, ShadowSharpen(InLightComponent->ShadowSharpen)
	, ContactShadowLength(InLightComponent->ContactShadowLength)
	, ContactShadowCastingIntensity(InLightComponent->ContactShadowCastingIntensity)
	, ContactShadowNonCastingIntensity(InLightComponent->ContactShadowNonCastingIntensity)
	, SpecularScale(InLightComponent->SpecularScale)
	, DiffuseScale(InLightComponent->DiffuseScale)
	, LightGuid(InLightComponent->LightGuid)
	, RayStartOffsetDepthScale(InLightComponent->RayStartOffsetDepthScale)
	, IESTexture(0)
	, bContactShadowLengthInWS(InLightComponent->ContactShadowLengthInWS ? true : false)
	, bMovable(InLightComponent->IsMovable())
	, bStaticLighting(InLightComponent->HasStaticLighting())
	, bStaticShadowing(InLightComponent->HasStaticShadowing())
	, bCastDynamicShadow(InLightComponent->CastShadows&& InLightComponent->CastDynamicShadows)
	, bCastStaticShadow(InLightComponent->CastShadows&& InLightComponent->CastStaticShadows)
	, bCastTranslucentShadows(InLightComponent->CastTranslucentShadows)
	, bTransmission(InLightComponent->bTransmission && bCastDynamicShadow && !bStaticShadowing)
	, bCastVolumetricShadow(InLightComponent->bCastVolumetricShadow)
	, bCastHairStrandsDeepShadow(InLightComponent->bCastDeepShadow)
	, bCastShadowsFromCinematicObjectsOnly(InLightComponent->bCastShadowsFromCinematicObjectsOnly)
	, bForceCachedShadowsForMovablePrimitives(InLightComponent->bForceCachedShadowsForMovablePrimitives)
	, CastRaytracedShadow(InLightComponent->CastShadows == 0 ? (TEnumAsByte<ECastRayTracedShadow::Type>) ECastRayTracedShadow::Disabled : InLightComponent->CastRaytracedShadow)
	, bAffectReflection(InLightComponent->bAffectReflection)
	, bAffectGlobalIllumination(InLightComponent->bAffectGlobalIllumination)
	, bAffectTranslucentLighting(InLightComponent->bAffectTranslucentLighting)
	, bUsedAsAtmosphereSunLight(InLightComponent->IsUsedAsAtmosphereSunLight())
	, bUseRayTracedDistanceFieldShadows(InLightComponent->bUseRayTracedDistanceFieldShadows)
	, bUseVirtualShadowMaps(false)	// See below
	, bCastModulatedShadows(false)
	, bUseWholeSceneCSMForMovableObjects(false)
	, bSelected(InLightComponent->IsSelected() || InLightComponent->IsOwnerSelected())
	, bAllowMegaLights(InLightComponent->bAllowMegaLights)
	, MegaLightsShadowMethod(InLightComponent->MegaLightsShadowMethod)
	, LightFunctionAtlasLightIndex(0)
	, AtmosphereSunLightIndex(InLightComponent->GetAtmosphereSunLightIndex())
	, AtmosphereSunDiskColorScale(InLightComponent->GetAtmosphereSunDiskColorScale())
	, LightType(InLightComponent->GetLightType())
	, LightingChannelMask(GetLightingChannelMaskForStruct(InLightComponent->LightingChannels))
	, StatId(InLightComponent->GetStatID(true))
	, ComponentName(InLightComponent->GetFName())
	, LevelName(InLightComponent->GetOwner() ? InLightComponent->GetOwner()->GetLevel()->GetOutermost()->GetFName() : NAME_None)
	, FarShadowDistance(0)
	, FarShadowCascadeCount(0)
	, ShadowAmount(1.0f)
	, SamplesPerPixel(1)
	, DeepShadowLayerDistribution(InLightComponent->DeepShadowLayerDistribution)
	, IESAtlasId(~0u)

staticMesh代理，这些图元相关的对象，最上层都是FPrimitiveSceneProxy::FPrimitiveSceneProxy

FPrimitiveSceneProxy::FPrimitiveSceneProxy(const FPrimitiveSceneProxyDesc& InProxyDesc, FName InResourceName) :
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
	WireframeColor(FLinearColor::White)
,	
#endif
	CustomPrimitiveData(InProxyDesc.GetCustomPrimitiveData())
,	TranslucencySortPriority(FMath::Clamp(InProxyDesc.TranslucencySortPriority, SHRT_MIN, SHRT_MAX))
,	TranslucencySortDistanceOffset(InProxyDesc.TranslucencySortDistanceOffset)
,	Mobility(InProxyDesc.Mobility)
,	LightmapType(InProxyDesc.LightmapType)
,	StatId()
,	DrawInGame(InProxyDesc.IsVisible())
,	DrawInEditor(InProxyDesc.IsVisibleEditor())
,	bReceivesDecals(InProxyDesc.bReceivesDecals)
,	bVirtualTextureMainPassDrawAlways(true)
,	bVirtualTextureMainPassDrawNever(false)
,	bOnlyOwnerSee(InProxyDesc.bOnlyOwnerSee)
,	bOwnerNoSee(InProxyDesc.bOwnerNoSee)
,	bParentSelected(InProxyDesc.ShouldRenderSelected())
,	bIndividuallySelected(InProxyDesc.IsComponentIndividuallySelected())
,	bLevelInstanceEditingState(InProxyDesc.GetLevelInstanceEditingState())
,	bHovered(false)
,	bUseViewOwnerDepthPriorityGroup(InProxyDesc.bUseViewOwnerDepthPriorityGroup)
,	StaticDepthPriorityGroup((uint8)InProxyDesc.GetStaticDepthPriorityGroup())
,	ViewOwnerDepthPriorityGroup(InProxyDesc.ViewOwnerDepthPriorityGroup)
,	bStaticLighting(InProxyDesc.HasStaticLighting())
,	bVisibleInReflectionCaptures(InProxyDesc.bVisibleInReflectionCaptures)
,	bVisibleInRealTimeSkyCaptures(InProxyDesc.bVisibleInRealTimeSkyCaptures)
,	bVisibleInRayTracing(InProxyDesc.bVisibleInRayTracing)
,	bRenderInDepthPass(InProxyDesc.bRenderInDepthPass)
,	bRenderInMainPass(InProxyDesc.bRenderInMainPass)
,	bForceHidden(false)
,	bCollisionEnabled(InProxyDesc.IsCollisionEnabled())
,	bTreatAsBackgroundForOcclusion(InProxyDesc.bTreatAsBackgroundForOcclusion)
,	bSupportsParallelGDME(true)
,	bSinglePassGDME(false)
,	bVisibleInLumenScene(false)
,	bOpaqueOrMasked(true)
,	bCanSkipRedundantTransformUpdates(true)
,	bGoodCandidateForCachedShadowmap(true)
,	bNeedsUnbuiltPreviewLighting(!InProxyDesc.IsPrecomputedLightingValid())
,	bHasValidSettingsForStaticLighting(InProxyDesc.HasValidSettingsForStaticLighting())
,	bWillEverBeLit(true)
        ...

基本上来看，主要工作是把组件信息手动填充到proxy中，来构造proxy。拷贝数据之后，游戏线程修改的是PrimitiveComponent的数据，而渲染线程修改或访问的是PrimitiveSceneProxy的数据，彼此不干扰，避免了临界区和锁的同步，也保证了线程安全。

但在创建完之后，PrimitiveComponent是如何向PrimitiveSceneProxy更新数据的呢？

这里涉及到UActorComponent是所有组件的父类。在UActorComponent 有一些标志来说明组件是否被被修改

class UActorComponent : public UObject, public IInterface_AssetUserData
{
	GENERATED_BODY()
    // 下面四个虚函数用于管理后边的四个uint8的状态信息，子类可以重新他们的逻辑，在这里只修改脏读状态
    virtual void DoDeferredRenderUpdates_Concurrent()
    {
        (......)
        
        if(bRenderStateDirty)
        {
            RecreateRenderState_Concurrent();
        }
        else
        {
            if(bRenderTransformDirty)
            {
                SendRenderTransform_Concurrent();
            }
            if(bRenderDynamicDataDirty)
            {
                SendRenderDynamicData_Concurrent();
            }
        }
    }
    virtual void CreateRenderState_Concurrent(FRegisterComponentContext* Context)
    {
        bRenderStateCreated = true;

        bRenderStateDirty = false;
        bRenderTransformDirty = false;
        bRenderDynamicDataDirty = false;
    }
    virtual void SendRenderTransform_Concurrent()
    {
        bRenderTransformDirty = false;
    }
    virtual void SendRenderDynamicData_Concurrent()
    {
        bRenderDynamicDataDirty = false;
    }
	...
	/** Is this component in need of its whole state being sent to the renderer? */
	uint8 bRenderStateDirty:1;

	/** Is this component's transform in need of sending to the renderer? */
	uint8 bRenderTransformDirty:1;

	/** Is this component's dynamic data in need of sending to the renderer? */
	uint8 bRenderDynamicDataDirty:1;

	/** Is this component's instanced data in need of sending to the renderer? */
	uint8 bRenderInstancesDirty:1;	
    ...
}

比如灯光组件的更新

// 灯光组件更新变换矩阵
void ULightComponent::SendRenderTransform_Concurrent()
{
	// Update the scene info's transform for this light.
    // 也能看出UE的设计框架是任何地方都可以访问这些全局Context
	GetWorld()->Scene->UpdateLightTransform(this);
	Super::SendRenderTransform_Concurrent();
}

// update内部可以看出首先Scene指的就是Fscene他是渲染器感知的场景，其次，更新时传入的是proxy，这也就实现了组件更新的传递
// 另外说明SceneProxy是在这个组件内部存好指针的
void FScene::UpdateLightTransform(ULightComponent* Light)
{
	UpdateLightInternal(Light->SceneProxy, FUpdateLightTransformParameters{.LightToWorld = Light->GetComponentTransform().ToMatrixNoScale(), .Position = Light->GetLightPosition()});
}

// 再内部，把更新信息传递到渲染线程
template <typename UpdatePayloadType>
void FScene::UpdateLightInternal(FLightSceneProxy* LightSceneProxy, UpdatePayloadType&& InUpdatePayload)
{
	if (LightSceneProxy)
	{
		FLightSceneInfo* LightSceneInfo = LightSceneProxy->GetLightSceneInfo();
		if (LightSceneInfo->bVisible)
		{
			ENQUEUE_RENDER_COMMAND(UpdateLightTransform)(
				[this, LightSceneInfo, UpdatePayload = MoveTemp(InUpdatePayload)] (FRHICommandListBase&) mutable
				{
					FScopeCycleCounter Context(LightSceneInfo->Proxy->GetStatId());
					SceneLightInfoUpdates->Enqueue(LightSceneInfo, MoveTemp(UpdatePayload));
				});
		}
	}
}

渲染流程

上一节拿捏了Proxy的创建，现在渲染器就是要收集Proxy，然后布拉布拉变成RHICommandList😄

大致可以总结为：模型数据准备 → Scene 收集 → 可见性剔除 → DrawCall 收集 → Pass 提交 → RHI 转换 → GPU 执行

Mesh数据—→FMeshBatch—→MeshDrawCommand——>Pass submit → RHI translate → GPU

顶点工厂

定义了顶点数据从CPU->GPU的框架

先过一些需要的类

FStaticMeshDataType 定义了顶点属性

struct FStaticMeshDataType
{
	/** The stream to read the vertex position from. */
	FVertexStreamComponent PositionComponent;   // 每一项底层都是一个RHIBuffer
	/** The streams to read the tangent basis from. */
	FVertexStreamComponent TangentBasisComponents[2];
	/** The streams to read the texture coordinates from. */
	TArray<FVertexStreamComponent, TFixedAllocator<MAX_STATIC_TEXCOORDS / 2> > TextureCoordinates;
	/** The stream to read the shadow map texture coordinates from. */
	FVertexStreamComponent LightMapCoordinateComponent;
	/** The stream to read the vertex color from. */
	FVertexStreamComponent ColorComponent;
	FRHIShaderResourceView* PositionComponentSRV = nullptr;
	FRHIShaderResourceView* TangentsSRV = nullptr;
	/** A SRV to manually bind and load TextureCoordinates in the vertex shader. */
	FRHIShaderResourceView* TextureCoordinatesSRV = nullptr;
	/** A SRV to manually bind and load Colors in the vertex shader. */
	FRHIShaderResourceView* ColorComponentsSRV = nullptr;
	uint32 ColorIndexMask = ~0u;
	int8 LightMapCoordinateIndex = -1;
	uint8 NumTexCoords = 0;
	uint8 LODLightmapDataIndex = 0;
};

// 翻开一个StreamComponent，基本就看懂了，所以StreamComponent是存储了具体的Buffer的
struct FVertexStreamComponent
{
	/** The vertex buffer to stream data from.  If null, no data can be read from this stream. */
	const FVertexBuffer* VertexBuffer = nullptr;
	/** The offset to the start of the vertex buffer fetch. */
	uint32 StreamOffset = 0;
	/** The offset of the data, relative to the beginning of each element in the vertex buffer. */
	uint8 Offset = 0;
	/** The stride of the data. */
	uint8 Stride = 0;
	/** The type of the data read from this stream. */
	TEnumAsByte<EVertexElementType> Type = VET_None;
	EVertexStreamUsage VertexStreamUsage = EVertexStreamUsage::Default;
}

//FVertexBuffer 底层就是RHI层的Buffer
class FVertexBuffer : public FRenderResource
{
public:
	FBufferRHIRef VertexBufferRHI;
};
using FBufferRHIRef  = TRefCountPtr<FRHIBuffer>;

FVertexStream也是类似FVertexStreamComponent，底层封装了一个FVertexBuffer

/**
 * Information needed to set a vertex stream.
 */
struct FVertexStream
{
	const FVertexBuffer* VertexBuffer = nullptr;
	uint32 Offset = 0;
	uint16 Stride = 0;
	EVertexStreamUsage VertexStreamUsage = EVertexStreamUsage::Default;
	uint8 Padding = 0;
};

FVertexElement 描述 StreamIndex对应的Stream 与 AttributeIndex的对应关系 Attribute就是在Vulkan中是VkVertexInputAttributeDescription的location，进一步再对应Shader就是 layout (location = 0) in vec3 inPos;

“从哪个 Vertex Buffer（StreamIndex），在什么偏移和格式下，读数据，送到 Vertex Shader 的哪个输入槽（AttributeIndex）。”

struct FVertexElement
{
	uint8 StreamIndex;
	uint8 Offset;
	TEnumAsByte<EVertexElementType> Type;
	uint8 AttributeIndex;
	uint16 Stride;
	/**
	 * Whether to use instance index or vertex index to consume the element.  
	 * eg if bUseInstanceIndex is 0, the element will be repeated for every instance.
	 */
	uint16 bUseInstanceIndex;
}

在VertexFactory的FVertexFactory::InitDeclaration中，就是拿一批FVertexElement去初始化一个FVertexDeclarationRHIRef

// 拿一堆Element去创建Declaration
void FVertexFactory::InitDeclaration(const FVertexDeclarationElementList& Elements, EVertexInputStreamType StreamType)
{
	
	if (StreamType == EVertexInputStreamType::PositionOnly)
	{
		PositionDeclaration = PipelineStateCache::GetOrCreateVertexDeclaration(Elements);
	}
	else if (StreamType == EVertexInputStreamType::PositionAndNormalOnly)
	{
		PositionAndNormalDeclaration = PipelineStateCache::GetOrCreateVertexDeclaration(Elements);
	}
	else // (StreamType == EVertexInputStreamType::Default)
	{
		// Create the vertex declaration for rendering the factory normally.
		Declaration = PipelineStateCache::GetOrCreateVertexDeclaration(Elements);
	}
}

上面提到的DeclarationFVertexDeclarationRHIRef PositionDeclaration，在UE也被抽象成了RHI资源，这粒度太细了。这个东西就是用来在创建PSO时使用的

typedef TArray<struct FVertexElement,TFixedAllocator<MaxVertexElementCount> > FVertexDeclarationElementList;

class FRHIVertexDeclaration : public FRHIResource
{
public:
	FRHIVertexDeclaration() : FRHIResource(RRT_VertexDeclaration) {}
	virtual bool GetInitializer(FVertexDeclarationElementList& Init) { return false; }
	virtual uint32 GetPrecachePSOHash() const { return 0; }
};

回过头再看顶点工厂内部存储了 Stream（数据从哪来，VertexBuffer）以及对应的RHI资源FVertexDeclarationRHIRef

/**
 * Encapsulates a vertex data source which can be linked into a vertex shader.
 */
class FVertexFactory : public FRenderResource
{
public:
	/**
	 * Information needed to set a vertex stream.
	 */
	struct FVertexStream
	{
		const FVertexBuffer* VertexBuffer = nullptr;
		uint32 Offset = 0;
		uint16 Stride = 0;
		EVertexStreamUsage VertexStreamUsage = EVertexStreamUsage::Default;
		uint8 Padding = 0;

		friend bool operator==(const FVertexStream& A,const FVertexStream& B)
		{
			return A.VertexBuffer == B.VertexBuffer && A.Stride == B.Stride && A.Offset == B.Offset && A.VertexStreamUsage == B.VertexStreamUsage;
		}

		FVertexStream()
		{
		}
	};

	typedef TArray<FVertexStream, TInlineAllocator<8> > FVertexStreamList;
		
	/** The vertex streams used to render the factory. */
	FVertexStreamList Streams;
	
private:

	/** The position only vertex stream used to render the factory during depth only passes. */
	TArray<FVertexStream,TInlineAllocator<2> > PositionStream;
	TArray<FVertexStream, TInlineAllocator<3> > PositionAndNormalStream;

	/** The RHI vertex declaration used to render the factory normally. */
	FVertexDeclarationRHIRef Declaration;

	/** The RHI vertex declaration used to render the factory during depth only passes. */
	FVertexDeclarationRHIRef PositionDeclaration;
	FVertexDeclarationRHIRef PositionAndNormalDeclaration;

};

再看FLocalVertexFactory 他继承VertexFactory，定义一个最基础的VertexFactory

 /**
 * A vertex factory which simply transforms explicit vertex attributes from local to world space.
 */
class FLocalVertexFactory : public FVertexFactory
{
    
    	FDataType Data;  // 这个东西就是来自上边提到的FStaticMeshDataType
}

struct FDataType : public FStaticMeshDataType
{
    FVertexStreamComponent PreSkinPositionComponent;
    FRHIShaderResourceView* PreSkinPositionComponentSRV = nullptr;
#if WITH_EDITORONLY_DATA
    const class UStaticMesh* StaticMesh = nullptr;
    bool bIsCoarseProxy = false;
#endif
};

FLocalVertexFactory 内主要的方法

void FLocalVertexFactory::InitRHI(FRHICommandListBase& RHICmdList)
{
	SCOPED_LOADTIMER(FLocalVertexFactory_InitRHI);
	// We create different streams based on feature level
	check(HasValidFeatureLevel());
	// VertexFactory needs to be able to support max possible shader platform and feature level
	// in case if we switch feature level at runtime.
	const bool bCanUseGPUScene = UseGPUScene(GMaxRHIShaderPlatform, GetFeatureLevel());
	const bool bUseManualVertexFetch = SupportsManualVertexFetch(GetFeatureLevel());
	// If the vertex buffer containing position is not the same vertex buffer containing the rest of the data,
	// then initialize PositionStream and PositionDeclaration.
	if (Data.PositionComponent.VertexBuffer != Data.TangentBasisComponents[0].VertexBuffer)
	{
		auto AddDeclaration = [this](EVertexInputStreamType InputStreamType, bool bAddNormal)
		{
			FVertexDeclarationElementList StreamElements;
			StreamElements.Add(AccessStreamComponent(Data.PositionComponent, 0, InputStreamType));
			bAddNormal = bAddNormal && Data.TangentBasisComponents[1].VertexBuffer != NULL;
			if (bAddNormal)
			{
				StreamElements.Add(AccessStreamComponent(Data.TangentBasisComponents[1], 2, InputStreamType));
			}
			AddPrimitiveIdStreamElement(InputStreamType, StreamElements, 1, 1);
			// 在这里就执行了前边提到的InitDeclaration
			InitDeclaration(StreamElements, InputStreamType);
		};
		AddDeclaration(EVertexInputStreamType::PositionOnly, false);
		AddDeclaration(EVertexInputStreamType::PositionAndNormalOnly, true);
	}
	FVertexDeclarationElementList Elements;
	GetVertexElements(GetFeatureLevel(), EVertexInputStreamType::Default, bUseManualVertexFetch, Data, Elements, Streams, ColorStreamIndex);
	AddPrimitiveIdStreamElement(EVertexInputStreamType::Default, Elements, 13, 13);
	check(Streams.Num() > 0);
	InitDeclaration(Elements);
	check(IsValidRef(GetDeclaration()));
	const int32 DefaultBaseVertexIndex = 0;
	const int32 DefaultPreSkinBaseVertexIndex = 0;
	if (RHISupportsManualVertexFetch(GMaxRHIShaderPlatform) || bCanUseGPUScene)
	{
		SCOPED_LOADTIMER(FLocalVertexFactory_InitRHI_CreateLocalVFUniformBuffer);
		UniformBuffer = CreateLocalVFUniformBuffer(this, Data.LODLightmapDataIndex, nullptr, DefaultBaseVertexIndex, DefaultPreSkinBaseVertexIndex);
	}
	FLocalVertexFactoryLooseParameters LooseParameters;
	LooseParameters.FrameNumber = -1;
	LooseParameters.GPUSkinPassThroughPositionBuffer = GNullVertexBuffer.VertexBufferSRV;
	LooseParameters.GPUSkinPassThroughPreviousPositionBuffer = GNullVertexBuffer.VertexBufferSRV;
	LooseParameters.GPUSkinPassThroughPreSkinnedTangentBuffer = GNullVertexBuffer.VertexBufferSRV;
	LooseParametersUniformBuffer = TUniformBufferRef<FLocalVertexFactoryLooseParameters>::CreateUniformBufferImmediate(LooseParameters, UniformBuffer_MultiFrame);
	check(IsValidRef(GetDeclaration()));
}

总结来看，顶点工厂的粒度是Mesh级别的，也就是说，顶点数据不一致就得新创建一个顶点工厂

总之顶点工厂就是一个模型在渲染器的代表

从FPrimitiveSceneProxy到FMeshBatch

FMeshBatch是本节才接触的新概念，它它包含了绘制Pass所需的所有信息，解耦了网格Pass和FPrimitiveSceneProxy，所以FPrimitiveSceneProxy并不知道会被哪些Pass绘制。

首先看看FMeshBatchElement，网格批次元素, 存储了FMeshBatch单个网格所需的数据

struct FMeshBatchElement
{
    // 存储实例的信息比如变换矩阵、材质信息，这里是RHIBuffer，说明他是GPU端的handle
	FRHIUniformBuffer* PrimitiveUniformBuffer;

    // 网格的UniformBuffer在CPU侧的数据.
	const TUniformBuffer<FPrimitiveUniformShaderParameters>* PrimitiveUniformBufferResource;

	/** Uniform buffer containing the "loose" parameters that aren't wrapped in other uniform buffers. Those parameters can be unique per mesh batch, e.g. view dependent. */
	FUniformBufferRHIRef LooseParametersUniformBuffer;

    // 索引缓冲
	const FIndexBuffer* IndexBuffer;

	// 实例数量
	uint32 NumInstances;
	uint32 BaseVertexIndex;
	uint32 MinVertexIndex;
	uint32 MaxVertexIndex;
	int32 UserIndex;
	float MinScreenSize;
	float MaxScreenSize;

    ...
};

再看FMeshBatch，这里注释可以看出来，如果顶点缓冲和材质是一致的就再一个Batch中（所以自己实现的话，同一个SubMesh+一个材质，就可以定义一个Batch）

/**
 * A batch of mesh elements, all with the same material and vertex buffer
 */
struct FMeshBatch
{
	TArray<FMeshBatchElement,TInlineAllocator<1> > Elements; // 包含的FMeshBatchElement

	/** Vertex factory for rendering, required. */
	const FVertexFactory* VertexFactory;  // 顶点工厂

	/** Material proxy for rendering, required. */  
	const FMaterialRenderProxy* MaterialRenderProxy; // 材质信息
	...

};

一个FMeshBatch拥有一组FMeshBatchElement、一个顶点工厂和一个材质实例，同一个FMeshBatch的所有FMeshBatchElement共享着相同的材质和顶点缓冲（可可被视为Vertex Factory）。但通常情况（大多数情况）下，FMeshBatch只会有一个FMeshBatchElement。

在进入渲染函数后，会执行可见性测试和剔除，以便剔除被遮挡和被隐藏的物体，在此阶段的末期会调用GatherDynamicMeshElements收集当前场景所有的FPrimitiveSceneProxy

void FDynamicMeshElementContext::GatherDynamicMeshElementsForPrimitive(FPrimitiveSceneInfo* Primitive, uint8 ViewMask)
{
	SCOPED_NAMED_EVENT(DynamicPrimitive, FColor::Magenta);

	TArray<int32, TInlineAllocator<4>> MeshBatchCountBefore;
	MeshBatchCountBefore.SetNumUninitialized(Views.Num());
	for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
	{
		MeshBatchCountBefore[ViewIndex] = MeshCollector.GetMeshBatchCount(ViewIndex);
	}

	MeshCollector.SetPrimitive(Primitive->Proxy, Primitive->DefaultDynamicHitProxyId);

	// If Custom Render Passes aren't in use, there will be only one group, which is the common case.
	if (ViewFamilyGroups.Num() == 1 || Primitive->Proxy->SinglePassGDME())
	{
		Primitive->Proxy->GetDynamicMeshElements(FirstViewFamily.AllViews, FirstViewFamily, ViewMask, MeshCollector);  // 关键是这里 Proxy自己有方法封装出一个MeshElement
	}
	else
	{
		for (FViewFamilyGroup& Group : ViewFamilyGroups)
		{
			if (uint8 MaskedViewMask = ViewMask & Group.ViewSubsetMask)
			{
				Primitive->Proxy->GetDynamicMeshElements(FirstViewFamily.AllViews, *Group.Family, MaskedViewMask, MeshCollector);
			}
		}
	}

	for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
	{
		FViewInfo& View = *Views[ViewIndex];

		if (ViewMask & (1 << ViewIndex))
		{
			FDynamicPrimitive& DynamicPrimitive = DynamicPrimitives.Emplace_GetRef();
			DynamicPrimitive.PrimitiveIndex = Primitive->GetIndex();
			DynamicPrimitive.ViewIndex = ViewIndex;
			DynamicPrimitive.StartElementIndex = MeshBatchCountBefore[ViewIndex];
			DynamicPrimitive.EndElementIndex = MeshCollector.GetMeshBatchCount(ViewIndex);
		}
	}
}

这里边proxy会进行GetDynamicMeshElements(),他是每个proxy子类自己实现的方法

	virtual void GetDynamicMeshElements(const TArray<const FSceneView*>& Views, const FSceneViewFamily& ViewFamily, uint32 VisibilityMap, class FMeshElementCollector& Collector) const {} 


// 骨骼mesh的实现
void FSkeletalMeshSceneProxy::GetDynamicMeshElements(const TArray<const FSceneView*>& Views, const FSceneViewFamily& ViewFamily, uint32 VisibilityMap, FMeshElementCollector& Collector) const
{
	QUICK_SCOPE_CYCLE_COUNTER(STAT_FSkeletalMeshSceneProxy_GetMeshElements);
	GetMeshElementsConditionallySelectable(Views, ViewFamily, true, VisibilityMap, Collector);
}
void FSkeletalMeshSceneProxy::GetMeshElementsConditionallySelectable(const TArray<const FSceneView*>& Views, const FSceneViewFamily& ViewFamily, bool bInSelectable, uint32 VisibilityMap, FMeshElementCollector& Collector) const
{
	if (!MeshObject)
	{
		return;
	}

	TRACE_CPUPROFILER_EVENT_SCOPE(SkeletalMesh);

	const FEngineShowFlags& EngineShowFlags = ViewFamily.EngineShowFlags;

	const int32 FirstLODIdx = SkeletalMeshRenderData->GetFirstValidLODIdx(FMath::Max(SkeletalMeshRenderData->PendingFirstLODIdx, SkeletalMeshRenderData->CurrentFirstLODIdx));
	if (FirstLODIdx == INDEX_NONE)
	{
#if DO_CHECK
		UE_LOG(LogSkeletalMesh, Warning, TEXT("Skeletal mesh %s has no valid LODs for rendering."), *GetResourceName().ToString());
#endif
	}
	else
	{
		const int32 LODIndex = MeshObject->GetLOD();
		check(LODIndex < SkeletalMeshRenderData->LODRenderData.Num());
		const FSkeletalMeshLODRenderData& LODData = SkeletalMeshRenderData->LODRenderData[LODIndex];

		if (LODSections.Num() > 0 && LODIndex >= FirstLODIdx)
		{
			check(SkeletalMeshRenderData->LODRenderData[LODIndex].GetNumVertices() > 0);
			const FLODSectionElements& LODSection = LODSections[LODIndex];
			check(LODSection.SectionElements.Num() == LODData.RenderSections.Num());
			for (FSkeletalMeshSectionIter Iter(LODIndex, *MeshObject, LODData, LODSection); Iter; ++Iter)
			{
				const FSkelMeshRenderSection& Section = Iter.GetSection();
				const int32 SectionIndex = Iter.GetSectionElementIndex();
				const FSectionElementInfo& SectionElementInfo = Iter.GetSectionElementInfo();
				bool bSectionSelected = false;
#if WITH_EDITORONLY_DATA
				// TODO: This is not threadsafe! A render command should be used to propagate SelectedEditorSection to the scene proxy.
				if (MeshObject->SelectedEditorMaterial != INDEX_NONE)
				{
					bSectionSelected = (MeshObject->SelectedEditorMaterial == SectionElementInfo.UseMaterialIndex);
				}
				else
				{
					bSectionSelected = (MeshObject->SelectedEditorSection == SectionIndex);
				}
#endif
				// If hidden skip the draw
				if (MeshObject->IsMaterialHidden(LODIndex, SectionElementInfo.UseMaterialIndex) || Section.bDisabled)
				{
					continue;
				}

				GetDynamicElementsSection(Views, ViewFamily, VisibilityMap, LODData, LODIndex, SectionIndex, bSectionSelected, SectionElementInfo, bInSelectable, Collector);
			}
		}
	}
#
}

代码比较复杂，总之，渲染开始后会收集所有需要渲染的FPrimitiveSceneProxy组成FMeshBatch

从FMeshBatch到FMeshDrawCommand

紧接着进入SetupMeshPass来创建FMeshPassProcessor,这里关注到一个点，各种需要Mesh信息的Pass都会在这里统一并行处理，而不是等Pass自己渲染时才处理

UE事先罗列了所有可能需要绘制的Pass，在SetupMeshPass阶段对需要用到的Pass并行化地生成DrawCommand

void FSceneRenderer::SetupMeshPass(FViewInfo& View, FExclusiveDepthStencil::Type BasePassDepthStencilAccess, FViewCommands& ViewCommands, FInstanceCullingManager& InstanceCullingManager)
{
	SCOPE_CYCLE_COUNTER(STAT_SetupMeshPass);
	const EShadingPath ShadingPath = GetFeatureLevelShadingPath(Scene->GetFeatureLevel());
    // 遍历所有的EMeshPass定义的pass
	for (int32 PassIndex = 0; PassIndex < EMeshPass::Num; PassIndex++)
	{
		const EMeshPass::Type PassType = (EMeshPass::Type)PassIndex;
		// 每个MeshPass创建一个FMeshPassProcessor
        FMeshPassProcessor* MeshPassProcessor = FPassProcessorManager::CreateMeshPassProcessor(ShadingPath, PassType, Scene->GetFeatureLevel(), Scene, &View, nullptr);

        FParallelMeshDrawCommandPass& Pass = View.ParallelMeshDrawCommandPasses[PassIndex];
        TArray<int32, TInlineAllocator<2> > ViewIds;
        ViewIds.Add(View.GPUSceneViewId);
        // Only apply instancing for ISR to main view passes
        const bool bIsMainViewPass = PassType != EMeshPass::Num && (FPassProcessorManager::GetPassFlags(ShadingPath, PassType) & EMeshPassFlags::MainView) != EMeshPassFlags::None;
        
        FName PassName(GetMeshPassName(PassType));
        // 并行地处理可见Pass的处理任务，创建此Pass的所有绘制命令
        Pass.DispatchPassSetup(
            Scene,
            View,
            FInstanceCullingContext(PassName, ShaderPlatform, &InstanceCullingManager, ViewIds, bAllowInstanceOcclusionCulling ? View.PrevViewInfo.HZB : nullptr, InstanceCullingMode, CullingFlags),
            PassType,
            BasePassDepthStencilAccess,
            MeshPassProcessor,
            View.DynamicMeshElements,
            &View.DynamicMeshElementsPassRelevance,
            View.NumVisibleDynamicMeshElements[PassType],
            ViewCommands.DynamicMeshCommandBuildRequests[PassType],
            ViewCommands.DynamicMeshCommandBuildFlags[PassType],
            ViewCommands.NumDynamicMeshCommandBuildRequestElements[PassType],
            ViewCommands.MeshCommands[PassIndex]);
		}
	}
}

这里展示一下所有的MeshPassEnum

// 罗列所有需要Mesh数据的Pass，比如深度Pass
namespace EMeshPass
{
	enum Type : uint8
	{
		DepthPass,
		SecondStageDepthPass,
		BasePass,
		AnisotropyPass,
		SkyPass,
		SingleLayerWaterPass,
		SingleLayerWaterDepthPrepass,
		CSMShadowDepth,
		VSMShadowDepth,
		OnePassPointLightShadowDepth,
		Distortion,
		Velocity,
		TranslucentVelocity,
		TranslucencyStandard,
		TranslucencyStandardModulate,
		TranslucencyAfterDOF,
		TranslucencyAfterDOFModulate,
		TranslucencyAfterMotionBlur,
		TranslucencyHoldout, /** A standalone pass to render all translucency for holdout, inferring the background visibility*/
		TranslucencyAll, /** Drawing all translucency, regardless of separate or standard.  Used when drawing translucency outside of the main renderer, eg FRendererModule::DrawTile. */
		LightmapDensity,
		DebugViewMode, /** Any of EDebugViewShaderMode */
		CustomDepth,
		MobileBasePassCSM,  /** Mobile base pass with CSM shading enabled */
		VirtualTexture,
		LumenCardCapture,
		LumenCardNanite,
		LumenTranslucencyRadianceCacheMark,
		LumenFrontLayerTranslucencyGBuffer,
		DitheredLODFadingOutMaskPass, /** A mini depth pass used to mark pixels with dithered LOD fading out. Currently only used by ray tracing shadows. */
		NaniteMeshPass,
		MeshDecal_DBuffer,
		MeshDecal_SceneColorAndGBuffer,
		MeshDecal_SceneColorAndGBufferNoNormal,
		MeshDecal_SceneColor,
		MeshDecal_AmbientOcclusion,
		WaterInfoTextureDepthPass,
		WaterInfoTexturePass,

#if WITH_EDITOR
		HitProxy,
		HitProxyOpaqueOnly,
		EditorLevelInstance,
		EditorSelection,
#endif

		Num,
		NumBits = 6,
	};
}

看看DispatchPassSetup分发时干了什么

void FParallelMeshDrawCommandPass::DispatchPassSetup(
	FScene* Scene,
	const FViewInfo& View,
	FInstanceCullingContext&& InstanceCullingContext,
	EMeshPass::Type PassType,
	FExclusiveDepthStencil::Type BasePassDepthStencilAccess,
	FMeshPassProcessor* MeshPassProcessor,
	const TArray<FMeshBatchAndRelevance, SceneRenderingAllocator>& DynamicMeshElements,
	const TArray<FMeshPassMask, SceneRenderingAllocator>* DynamicMeshElementsPassRelevance,
	int32 NumDynamicMeshElements,
	TArray<const FStaticMeshBatch*, SceneRenderingAllocator>& InOutDynamicMeshCommandBuildRequests,
	TArray<EMeshDrawCommandCullingPayloadFlags, SceneRenderingAllocator> InOutDynamicMeshCommandBuildFlags,
	int32 NumDynamicMeshCommandBuildRequestElements,
	FMeshCommandOneFrameArray& InOutMeshDrawCommands,
	FMeshPassProcessor* MobileBasePassCSMMeshPassProcessor,
	FMeshCommandOneFrameArray* InOutMobileBasePassCSMMeshDrawCommands
)
{
	TRACE_CPUPROFILER_EVENT_SCOPE(ParallelMdcDispatchPassSetup);
	check(!TaskEventRef.IsValid() && MeshPassProcessor != nullptr && TaskContext.PrimitiveIdBufferData == nullptr);
	check((PassType == EMeshPass::Num) == (DynamicMeshElementsPassRelevance == nullptr));

	MaxNumDraws = InOutMeshDrawCommands.Num() + NumDynamicMeshElements + NumDynamicMeshCommandBuildRequestElements;
	// 设置TaskContext的数据，收集生成MeshCommand所需的数据
	TaskContext.MeshPassProcessor = MeshPassProcessor;
	TaskContext.MobileBasePassCSMMeshPassProcessor = MobileBasePassCSMMeshPassProcessor;
	TaskContext.DynamicMeshElements = &DynamicMeshElements;
	TaskContext.DynamicMeshElementsPassRelevance = DynamicMeshElementsPassRelevance;
	
	TaskContext.View = &View;
	TaskContext.Scene = Scene;
	TaskContext.ShadingPath = GetFeatureLevelShadingPath(View.GetFeatureLevel());
	TaskContext.ShaderPlatform = Scene->GetShaderPlatform();
	TaskContext.PassType = PassType;
	TaskContext.bUseGPUScene = UseGPUScene(GMaxRHIShaderPlatform, View.GetFeatureLevel());
	TaskContext.bDynamicInstancing = IsDynamicInstancingEnabled(View.GetFeatureLevel());
	TaskContext.bReverseCulling = View.bReverseCulling;
	TaskContext.bRenderSceneTwoSided = View.bRenderSceneTwoSided;
	TaskContext.BasePassDepthStencilAccess = BasePassDepthStencilAccess;
	TaskContext.DefaultBasePassDepthStencilAccess = Scene->DefaultBasePassDepthStencilAccess;
	TaskContext.NumDynamicMeshElements = NumDynamicMeshElements;
	TaskContext.NumDynamicMeshCommandBuildRequestElements = NumDynamicMeshCommandBuildRequestElements;

	// Only apply instancing for ISR to main view passes

	const bool bIsMainViewPass = PassType != EMeshPass::Num && (FPassProcessorManager::GetPassFlags(TaskContext.ShadingPath, TaskContext.PassType) & EMeshPassFlags::MainView) != EMeshPassFlags::None;
	// GPUCULL_TODO: Note the InstanceFactor is ignored by the GPU-Scene supported instances, but is used for legacy primitives.
	TaskContext.InstanceFactor = (bIsMainViewPass && View.IsInstancedStereoPass()) ? 2 : 1;

	TaskContext.InstanceCullingContext = MoveTemp(InstanceCullingContext); 

    // 设置基于view的透明排序键 
	TaskContext.TranslucencyPass = ETranslucencyPass::TPT_MAX;
	TaskContext.TranslucentSortPolicy = View.TranslucentSortPolicy;
	TaskContext.TranslucentSortAxis = View.TranslucentSortAxis;
	TaskContext.ViewOrigin = View.ViewMatrices.GetViewOrigin();
	TaskContext.ViewMatrix = View.ViewMatrices.GetViewMatrix();
	TaskContext.PrimitiveBounds = &Scene->PrimitiveBounds;

	switch (PassType)
	{
		case EMeshPass::TranslucencyStandard: TaskContext.TranslucencyPass			= ETranslucencyPass::TPT_TranslucencyStandard; break;
		case EMeshPass::TranslucencyStandardModulate: TaskContext.TranslucencyPass	= ETranslucencyPass::TPT_TranslucencyStandardModulate; break;
		case EMeshPass::TranslucencyAfterDOF: TaskContext.TranslucencyPass			= ETranslucencyPass::TPT_TranslucencyAfterDOF; break;
		case EMeshPass::TranslucencyAfterDOFModulate: TaskContext.TranslucencyPass	= ETranslucencyPass::TPT_TranslucencyAfterDOFModulate; break;
		case EMeshPass::TranslucencyAfterMotionBlur: TaskContext.TranslucencyPass	= ETranslucencyPass::TPT_TranslucencyAfterMotionBlur; break;
		case EMeshPass::TranslucencyHoldout: TaskContext.TranslucencyPass			= ETranslucencyPass::TPT_TranslucencyHoldout; break;
		case EMeshPass::TranslucencyAll: TaskContext.TranslucencyPass				= ETranslucencyPass::TPT_AllTranslucency; break;
	}

	Swap(TaskContext.MeshDrawCommands, InOutMeshDrawCommands);
	Swap(TaskContext.DynamicMeshCommandBuildRequests, InOutDynamicMeshCommandBuildRequests);
	Swap(TaskContext.DynamicMeshCommandBuildFlags, InOutDynamicMeshCommandBuildFlags);

	if (TaskContext.ShadingPath == EShadingPath::Mobile && TaskContext.PassType == EMeshPass::BasePass)
	{
		Swap(TaskContext.MobileBasePassCSMMeshDrawCommands, *InOutMobileBasePassCSMMeshDrawCommands);
	}
	else
	{
		check(MobileBasePassCSMMeshPassProcessor == nullptr && InOutMobileBasePassCSMMeshDrawCommands == nullptr);
	}
// 真正去分发任务
	if (MaxNumDraws > 0)
	{
		// Preallocate resources on rendering thread based on MaxNumDraws.
		TaskContext.PrimitiveIdBufferDataSize = TaskContext.InstanceFactor * MaxNumDraws * sizeof(int32);
		TaskContext.PrimitiveIdBufferData = FMemory::Malloc(TaskContext.PrimitiveIdBufferDataSize);
#if DO_GUARD_SLOW
		FMemory::Memzero(TaskContext.PrimitiveIdBufferData, TaskContext.PrimitiveIdBufferDataSize);
#endif // DO_GUARD_SLOW
		TaskContext.MeshDrawCommands.Reserve(MaxNumDraws);
		TaskContext.TempVisibleMeshDrawCommands.Reserve(MaxNumDraws);

		const bool bExecuteInParallel = FApp::ShouldUseThreadingForPerformance()
			&& CVarMeshDrawCommandsParallelPassSetup.GetValueOnRenderThread() > 0
			&& GIsThreadedRendering; // Rendering thread is required to safely use rendering resources in parallel.
        
        // 如果是并行方式, 便创建并行任务实例并加入TaskGraph系统执行.
		if (bExecuteInParallel)
		{
			if (IsOnDemandShaderCreationEnabled())
			{
				TaskEventRef = TGraphTask<FMeshDrawCommandPassSetupTask>::CreateTask().ConstructAndDispatchWhenReady(TaskContext);
			}
			else
			{
				FGraphEventArray DependentGraphEvents;
				DependentGraphEvents.Add(TGraphTask<FMeshDrawCommandPassSetupTask>::CreateTask().ConstructAndDispatchWhenReady(TaskContext));
				TaskEventRef = TGraphTask<FMeshDrawCommandInitResourcesTask>::CreateTask(&DependentGraphEvents).ConstructAndDispatchWhenReady(TaskContext);
			}
		}
		else
		{
			QUICK_SCOPE_CYCLE_COUNTER(STAT_MeshPassSetupImmediate);
			FMeshDrawCommandPassSetupTask Task(TaskContext);
			Task.AnyThreadTask();
			if (!IsOnDemandShaderCreationEnabled())
			{
				FMeshDrawCommandInitResourcesTask DependentTask(TaskContext);
				DependentTask.AnyThreadTask();
			}
		}

		// This work needs to be deferred until at least BuildRenderingCommands (to ensure the DynamicPrimitiveCollector is uploaded), so we use the async mechanism either way 
		auto FinalizeInstanceCullingSetup = [this, Scene](FInstanceCullingContext& InstanceCullingContext)
		{
			WaitForMeshPassSetupTask();

#if DO_CHECK
			for (const FVisibleMeshDrawCommand& VisibleMeshDrawCommand : TaskContext.MeshDrawCommands)
			{
				if (VisibleMeshDrawCommand.PrimitiveIdInfo.bIsDynamicPrimitive)
				{
					uint32 PrimitiveIndex = VisibleMeshDrawCommand.PrimitiveIdInfo.DrawPrimitiveId & ~GPrimIDDynamicFlag;
					TaskContext.View->DynamicPrimitiveCollector.CheckPrimitiveProcessed(PrimitiveIndex, Scene->GPUScene);
				}
			}
#endif
			InstanceCullingContext.SetDynamicPrimitiveInstanceOffsets(TaskContext.View->DynamicPrimitiveCollector.GetInstanceSceneDataOffset(), TaskContext.View->DynamicPrimitiveCollector.NumInstances());
		};
		TaskContext.InstanceCullingContext.BeginAsyncSetup(FinalizeInstanceCullingSetup);
	}
}

上边设置的context会被放在FMeshDrawCommandPassSetupTask中，并执行createTask, 所以Task是这个流程中的关键


// 并行设置网格绘制指令的任务. 包含动态网格绘制命令的生成, 排序, 合并等.
class FMeshDrawCommandPassSetupTask
{
public:
    // context封装到这里了
	FMeshDrawCommandPassSetupTask(FMeshDrawCommandPassSetupTaskContext& InContext)
		: Context(InContext)
	{
	}
	
    ...
    // 生成动态和静态网格绘制指令(通过MeshPassProcessor将FMeshBatch转换成MeshDrawCommand).
    GenerateDynamicMeshDrawCommands(
	Context.View,
	Context.ShadingPath,
	Context.PassType,
	Context.MeshPassProcessor,
	*Context.DynamicMeshElements,
	Context.DynamicMeshElementsPassRelevance,
	Context.NumDynamicMeshElements,
	Context.DynamicMeshCommandBuildRequests,
	Context.DynamicMeshCommandBuildFlags,
	Context.NumDynamicMeshCommandBuildRequestElements,
	Context.MeshDrawCommands,
	Context.MeshDrawCommandStorage,
	Context.MinimalPipelineStatePassSet,
	Context.NeedsShaderInitialisation
    
    // 开始处理生成的MeshDrawCommands
    if (Context.MeshDrawCommands.Num() > 0)
    {
	    // 用view相关的数据更新网格排序键. 排序键的类型是FMeshDrawCommandSortKey, 包含了BasePass和透明的键值, 其中透明物体的排序以其到摄像机的距离为依据.  点进去看发现他处理了距离信息并且把他写入SortKey，在下边才真正开始排序
    UpdateTranslucentMeshSortKeys(
                    Context.TranslucentSortPolicy,
                    Context.TranslucentSortAxis,
                    Context.ViewOrigin,
                    Context.ViewMatrix,
                    *Context.PrimitiveBounds,
                    Context.TranslucencyPass,
                    bInverseSorting,
                    Context.MeshDrawCommands
		);
        
                        // 执行MeshDrawCommand的排序, FCompareFMeshDrawCommands首先以FMeshDrawCommandSortKey作为排序依据, 其次再用StateBucketId.
        {
            QUICK_SCOPE_CYCLE_COUNTER(STAT_SortVisibleMeshDrawCommands);
            Context.MeshDrawCommands.Sort(FCompareFMeshDrawCommands());
        }
    }
    
    ...
}

Context.MeshDrawCommands.Sort(FCompareFMeshDrawCommands()); Sort就是一个基础的方法，传入的是一个比较器

struct FCompareFMeshDrawCommands
{
	FORCEINLINE bool operator() (const FVisibleMeshDrawCommand& A, const FVisibleMeshDrawCommand& B) const
	{
		// First order by a sort key.
		if (A.SortKey != B.SortKey)
		{
			return A.SortKey < B.SortKey;
		}

		// Next order by instancing bucket.
		if (A.StateBucketId != B.StateBucketId)
		{
			return A.StateBucketId < B.StateBucketId;
		}

		return false;
	}
};

所以FMeshDrawCommands的排序就是主要依赖SortKey的。下面看一下这个SortKey的设计。他是一个union，也就是说有三种排序模式只能三选一，越靠前的数据优先级越高

/** FVisibleMeshDrawCommand sort key. */
class FMeshDrawCommandSortKey
{
public:
	union 
	{
		uint64 PackedData;

		struct
		{
			uint64 VertexShaderHash		: 16; // Order by vertex shader's hash.
			uint64 PixelShaderHash		: 32; // Order by pixel shader's hash.
			uint64 Background			: 1;
			uint64 Masked				: 15; // First order by masked.
		} BasePass;

		struct
		{
			uint64 MeshIdInPrimitive	: 16; // Order meshes belonging to the same primitive by a stable id.
			uint64 Distance				: 32; // Order by distance.
			uint64 Priority				: 16; // First order by priority.
		} Translucent;

		struct 
		{
			uint64 VertexShaderHash : 32;	// Order by vertex shader's hash.
			uint64 PixelShaderHash : 32;	// First order by pixel shader's hash.
		} Generic;
	};

	FORCEINLINE bool operator!=(FMeshDrawCommandSortKey B) const
	{
		return PackedData != B.PackedData;
	}

	FORCEINLINE bool operator<(FMeshDrawCommandSortKey B) const
	{
		return PackedData < B.PackedData;
	}

	static RENDERER_API const FMeshDrawCommandSortKey Default;
};

下面是这些key的计算

这里需要弄清楚这个union的工作机制

    union {
        uint64_t PackedData;
        struct {
            uint64_t VertexShaderHash : 16;
            uint64_t PixelShaderHash : 32;
            uint64_t Background : 1;
            uint64_t Masked : 15;
        } BasePass;
    } test;

    test.PackedData = 0;
    test.BasePass.VertexShaderHash = 0x1234;
    std::cout << "PackedData = 0x" << std::hex << std::setfill('0') << std::setw(16) << test.PackedData << std::endl;
// 这个例子打印出来是PackedData = 0x0000000000001234   所以越上边的内容，其实是越低优先级  Masked优先级最高

上边例子也说明了，最终把这些字段都填充后，直接比较两个SortKey的大小就可以进行排序了~

接下来看看什么是FMeshDrawCommand，从注释能开出来，到RHI层之上最后一层就是FMeshDrawCommand

/** 
 * FMeshDrawCommand fully describes a mesh pass draw call, captured just above the RHI.  
		FMeshDrawCommand should contain only data needed to draw.  For InitViews payloads, use FVisibleMeshDrawCommand.
 * FMeshDrawCommands are cached at Primitive AddToScene time for vertex factories that support it (no per-frame or per-view shader binding changes).
 * Dynamic Instancing operates at the FMeshDrawCommand level for robustness.  
		Adding per-command shader bindings will reduce the efficiency of Dynamic Instancing, but rendering will always be correct.
 * Any resources referenced by a command must be kept alive for the lifetime of the command.  FMeshDrawCommand is not responsible for lifetime management of resources.
		For uniform buffers referenced by cached FMeshDrawCommand's, RHIUpdateUniformBuffer makes it possible to access per-frame data in the shader without changing bindings.
 */
class FMeshDrawCommand
{
public:
	
	// 资源信息  Shader、顶点、索引信息
	FMeshDrawShaderBindings ShaderBindings;
	FVertexInputStreamArray VertexStreams;
	FRHIBuffer* IndexBuffer;
    
    // PSO信息
	FGraphicsMinimalPipelineStateId CachedPipelineId;
	
	// DrawCall用的信息
	uint32 FirstIndex;
	uint32 NumPrimitives;
	uint32 NumInstances;

    // 包含两种模式，直接绘制或者间接绘制，间接绘制就是包含一个间接绘制Buffer
	union
	{
		struct 
		{
			uint32 BaseVertexIndex;
			uint32 NumVertices;
		} VertexParams;
		
		struct  
		{
			FRHIBuffer* Buffer;
			uint32 Offset;
		} IndirectArgs;
	};
	... 
};

下面接着看FMeshPassProcessor 它就是把FMeshBatch转换成FMeshDrawCommands的工具

/** 
 * Base class of mesh processors, whose job is to transform FMeshBatch draw descriptions received from scene proxy implementations into FMeshDrawCommands ready for the RHI command list
 */
class FMeshPassProcessor : public IPSOCollector
{
public:

	EMeshPass::Type MeshPassType;
	const FScene* RESTRICT Scene;
	ERHIFeatureLevel::Type FeatureLevel;
	const FSceneView* ViewIfDynamicMeshCommand;
	FMeshPassDrawListContext* DrawListContext;
		
	UE_DEPRECATED(5.4, "Use the below Ctor instead which provides either EMeshPass::Type or the name of the mesh pass directly.")
	FMeshPassProcessor(const FScene* InScene, ERHIFeatureLevel::Type InFeatureLevel, const FSceneView* InViewIfDynamicMeshCommand, FMeshPassDrawListContext* InDrawListContext) :
		FMeshPassProcessor(EMeshPass::Num, InScene, InFeatureLevel, InViewIfDynamicMeshCommand, InDrawListContext) { }

	RENDERER_API FMeshPassProcessor(EMeshPass::Type InMeshPassType, const FScene* InScene, ERHIFeatureLevel::Type InFeatureLevel, const FSceneView* InViewIfDynamicMeshCommand, FMeshPassDrawListContext* InDrawListContext);
	RENDERER_API FMeshPassProcessor(const TCHAR* InMeshPassName, const FScene* InScene, ERHIFeatureLevel::Type InFeatureLevel, const FSceneView* InViewIfDynamicMeshCommand, FMeshPassDrawListContext* InDrawListContext);

	virtual ~FMeshPassProcessor() {}

	void SetDrawListContext(FMeshPassDrawListContext* InDrawListContext)
	{
		DrawListContext = InDrawListContext;
	}

	// FMeshPassProcessor interface
	// Add a FMeshBatch to the pass    是否处理一个MeshBatch是由子类实现的，也就是各个MeshPass自己定义自己需要哪些MeshBatch
	virtual void AddMeshBatch(const FMeshBatch& RESTRICT MeshBatch, uint64 BatchElementMask, const FPrimitiveSceneProxy* RESTRICT PrimitiveSceneProxy, int32 StaticMeshId = -1) = 0;
		
	// By default no PSOs collected 
	virtual void CollectPSOInitializers(const FSceneTexturesConfig& SceneTexturesConfig, const FMaterial& Material, const FPSOPrecacheVertexFactoryData& VertexFactoryData, const FPSOPrecacheParams& PreCacheParams, TArray<FPSOPrecacheData>& PSOInitializers) override {}

	static FORCEINLINE_DEBUGGABLE ERasterizerCullMode InverseCullMode(ERasterizerCullMode CullMode)
	{
		return CullMode == CM_None ? CM_None : (CullMode == CM_CCW ? CM_CW : CM_CCW);
	}

	struct FMeshDrawingPolicyOverrideSettings
	{
		EDrawingPolicyOverrideFlags	MeshOverrideFlags = EDrawingPolicyOverrideFlags::None;
		EPrimitiveType				MeshPrimitiveType = PT_TriangleList;
	};

	RENDERER_API static FMeshDrawingPolicyOverrideSettings ComputeMeshOverrideSettings(const FPSOPrecacheParams& PrecachePSOParams);
	RENDERER_API static FMeshDrawingPolicyOverrideSettings ComputeMeshOverrideSettings(const FMeshBatch& Mesh);

	RENDERER_API static ERasterizerFillMode ComputeMeshFillMode(const FMaterial& InMaterialResource, const FMeshDrawingPolicyOverrideSettings& InOverrideSettings);
	RENDERER_API static ERasterizerCullMode ComputeMeshCullMode(const FMaterial& InMaterialResource, const FMeshDrawingPolicyOverrideSettings& InOverrideSettings);

	template<typename PassShadersType, typename ShaderElementDataType>
	void BuildMeshDrawCommands(
		const FMeshBatch& RESTRICT MeshBatch,
		uint64 BatchElementMask,
		const FPrimitiveSceneProxy* RESTRICT PrimitiveSceneProxy,
		const FMaterialRenderProxy& RESTRICT MaterialRenderProxy,
		const FMaterial& RESTRICT MaterialResource,
		const FMeshPassProcessorRenderState& RESTRICT DrawRenderState,
		const PassShadersType& PassShaders,
		ERasterizerFillMode MeshFillMode,
		ERasterizerCullMode MeshCullMode,
		FMeshDrawCommandSortKey SortKey,
		EMeshPassFeatures MeshPassFeatures,
		const ShaderElementDataType& ShaderElementData);

	template<typename PassShadersType>
	void AddGraphicsPipelineStateInitializer(
		const FPSOPrecacheVertexFactoryData& VertexFactoryData,
		const FMaterial& RESTRICT MaterialResource,
		const FMeshPassProcessorRenderState& RESTRICT DrawRenderState,
		const FGraphicsPipelineRenderTargetsInfo& RESTRICT RenderTargetsInfo,
		const PassShadersType& PassShaders,
		ERasterizerFillMode MeshFillMode,
		ERasterizerCullMode MeshCullMode,
		EPrimitiveType PrimitiveType,
		EMeshPassFeatures MeshPassFeatures,
		bool bRequired,
		TArray<FPSOPrecacheData>& PSOInitializers);

	template<typename PassShadersType>
	static void AddGraphicsPipelineStateInitializer(
		const FPSOPrecacheVertexFactoryData& VertexFactoryData,
		const FMaterial& RESTRICT MaterialResource,
		const FMeshPassProcessorRenderState& RESTRICT DrawRenderState,
		const FGraphicsPipelineRenderTargetsInfo& RESTRICT RenderTargetsInfo,
		const PassShadersType& PassShaders,
		ERasterizerFillMode MeshFillMode,
		ERasterizerCullMode MeshCullMode,
		EPrimitiveType PrimitiveType,
		EMeshPassFeatures MeshPassFeatures,
		ESubpassHint SubpassHint,
		uint8 SubpassIndex,
		bool bRequired,
		int32 PSOCollectorIndex,
		TArray<FPSOPrecacheData>& PSOInitializers);

protected:
	RENDERER_API FMeshDrawCommandPrimitiveIdInfo GetDrawCommandPrimitiveId(
		const FPrimitiveSceneInfo* RESTRICT PrimitiveSceneInfo,
		const FMeshBatchElement& BatchElement) const;

	RENDERER_API bool ShouldSkipMeshDrawCommand(
		const FMeshBatch& RESTRICT MeshBatch,
		const FPrimitiveSceneProxy* RESTRICT PrimitiveSceneProxy
	) const;

	RENDERER_API bool PipelineVariableRateShadingEnabled() const;
	RENDERER_API bool HardwareVariableRateShadingSupportedByScene() const;
};

由此可见，FMeshPassProcessor的主要作用是：

Pass过滤。将该Pass无关的MeshBatch给过滤掉，比如深度Pass过滤掉透明物体。(通过子类重载AddBatch)
选择绘制命令所需的Shader及渲染状态（深度、模板、混合状态、光栅化状态等）。
收集绘制命令涉及的Shader资源绑定。
- Pass的Uniform Buffer，如ViewUniformBuffer、DepthPassUniformBuffer。
- 顶点工厂绑定（顶点数据和索引）。
- 材质绑定。
- Pass的与绘制指令相关的绑定。
收集Draw Call相关的参数。

从FMeshDrawCommand到RHICommandList

FMeshBatch转换成FMeshDrawCommand后，每个Pass都对应了一个FMeshPassProcessor，每个FMeshPassProcessor保存了该Pass需要绘制的所有FMeshDrawCommand，以便渲染器在合适的时间触发并渲染。

也就是说，在前边流程，已经把每个Pass需要的FMeshDrawCommand准备好了，可以进行每个Pass的绘制流程了。

// 传入单个MeshDrawCommand，
bool FMeshDrawCommand::SubmitDraw(
	const FMeshDrawCommand& RESTRICT MeshDrawCommand,
	const FGraphicsMinimalPipelineStateSet& GraphicsMinimalPipelineStateSet,
	const FMeshDrawCommandSceneArgs& SceneArgs,
	uint32 InstanceFactor,
	FRHICommandList& RHICmdList,
	FMeshDrawCommandStateCache& RESTRICT StateCache)
{
#if WANTS_DRAW_MESH_EVENTS
	RHI_BREADCRUMB_EVENT_CONDITIONAL(RHICmdList, GShowMaterialDrawEvents != 0, "%s %s (%u instances)"
		, MeshDrawCommand.DebugData.MaterialRenderProxy->GetMaterialName()
		, MeshDrawCommand.DebugData.ResourceName
		, MeshDrawCommand.NumInstances * InstanceFactor
	);
#endif

	bool bAllowSkipDrawCommand = true;
	if (SubmitDrawBegin(MeshDrawCommand, GraphicsMinimalPipelineStateSet, SceneArgs, InstanceFactor, RHICmdList, StateCache, bAllowSkipDrawCommand))
	{
        // 在这里边就是RHICmdList.DrawIndexedPrimitive 这种RHI指令了~
		SubmitDrawEnd(MeshDrawCommand, SceneArgs, InstanceFactor, RHICmdList);
		return true;
	}

	return false;
}

// 这就进入了CommandList中
RHICmdList.DrawIndexedPrimitive(
    MeshDrawCommand.IndexBuffer,
    MeshDrawCommand.VertexParams.BaseVertexIndex,
    0,
    MeshDrawCommand.VertexParams.NumVertices,
    MeshDrawCommand.FirstIndex,
    MeshDrawCommand.NumPrimitives,
    MeshDrawCommand.NumInstances * InstanceFactor
);

后续RHICommandList->具体API，这个我的仓库已经写了一版，这里就不解析了

游戏引擎开发实践（DDGI）

Sun, 07 Dec 2025 20:36:06 +0800

总体流程

探针收集光照信息：探针向四面八方发射256条光线，计算击中点的光照并存储（此处可以额外计算击中点的间接光照，来模拟无限弹射的全局光照效果），另外还要存储hitT用来评估可见性

混合光照信息：每个探针分配6*6的像素，每个像素代表一个法线方向，通过蒙特卡洛积分来估计法线方向上的Irrandiance（其实和IBL思路一致），并进行时域加权混合，来获得更多的样本？

混合距离信息：每个探针分配 14*14的像素，计算每个方向上HitT的期望和平方的期望，时域混合（这两部都采用了八面体映射，另外这两步涉及到采样边界的问题，在像素外扩充一圈，用特定规则填充后存储）类似，保证在一个探针内采样时，不会采样到别的探针数据

光照Pass使用探针：根据着色点位置找到周围8个探针，从8个探针中获取对应法线位置的数据进行加权平均，有3种权重系数

如果probe离着色点较远，降低probe的权重（三线性插值系数）

如果着色点到probe的方向与表面法线的夹角过大，降低probe的权重（方向系数）

如果着色点与probe之间有较大的概率存在遮挡物，降低probe的权重（切比雪夫系数）

DDGI Probe

DDGIVolume

把探针组组成一个包围盒，定义探针数量和间距，以及DDGI的各种参数，这里实现了一个新的探针组件来表达它，并实现了他的可视化

ProbeTrace

这个阶段利用光追，计算并保存每个探针发射四面八方的光线的Radiance 信息（在每个击中点进行一次光照计算）

获取volume的设置，采用y-up方向，作为Image2Darray的layer，所以每层的探针数量为probeCount.x * probeCount.z

DDGISetting ddgiSetting = RENDER_RESOURCEMANAGER->GetGlobalSettingInfo().ddgiSetting;

glm::uvec3 probeCount = ddgiSetting.probeCount;
uint32_t raysPerProbe = ddgiSetting.raysPerProbe;
uint32_t probeCountPreLayer = probeCount.x * probeCount.z;
uint32_t volumeLayerCount = probeCount.y;  // y-up

执行光追TraceRays(raysPerProbe，probeCountPreLayer，volumeLayerCount)

// VolumeTrace
{
	auto& build = builder.CreateRayTracingPass(GetName() + "_VolumeTrace")
		.PassIndex(raysPerProbe, probeCountPreLayer, volumeLayerCount)
		.RootSignature(m_VolumeTraceRootSignature)
		.ReadWrite(1, 0, 0, rayTexture, VIEW_TYPE_2D_ARRAY, { TEXTURE_ASPECT_COLOR ,0,1,0,volumeLayerCount })
		.Read(1, 1, 0, dirShadowMap, VIEW_TYPE_2D_ARRAY, { TEXTURE_ASPECT_DEPTH ,0,1,0,4 })
		.Read(1, 3, 0, skyBox, VIEW_TYPE_CUBE, { TEXTURE_ASPECT_COLOR ,0,1,0,6 })
		.Read(1, 4, 0, irrandiance, VIEW_TYPE_2D_ARRAY, { TEXTURE_ASPECT_COLOR,0,1,0,volumeLayerCount })
		.Read(1, 5, 0, distance, VIEW_TYPE_2D_ARRAY, { TEXTURE_ASPECT_COLOR,0,1,0,volumeLayerCount })
		.Execute([&](RDGPassContext context) {
		RHICommandListRef command = context.command;
		command->SetRayTracingPipeline(m_VolumeTracePipeline);
		command->BindDescriptorSet(RENDER_RESOURCEMANAGER->GetGlobalResourcePerFrameDescriptorSet(), 0);
		command->BindDescriptorSet(context.descriptors[1], 1);
		command->TraceRays(context.passIndex[0], context.passIndex[1], context.passIndex[2]);
			});
	LightInfo& lightInfo = LightCollector::GetLightInfo();
	if (lightInfo.pointLightCount > 0) {
		RDGTextureHandle pointShadowMap = builder.GetTexture("Point Shadow Color[0]");
		build.Read(1, 2, 0, pointShadowMap, VIEW_TYPE_CUBE, { TEXTURE_ASPECT_COLOR,0,1,0,6 });
	}
}

光追Shader

RayGen中需要为每个探针的每条光线的击中点计算光照和阴影，并且混合历史信息（计算击中点的周围8个探针历史信息的irrandiance，作为击中点的间接光照（只计算漫反射部分））

struct Payload {
    vec3 albedo;
	float roughness; 
	vec3 worldPosition;
	float metallic;
	vec3 normal;
	float  hitT;
};


void main(){

    uint rayIndex = gl_LaunchIDEXT.x;
    uint probePlaneIndex = gl_LaunchIDEXT.y;
    uint planeIndex = gl_LaunchIDEXT.z;
    uint probeCountPrePlane = DDGIGetProbesPerPlane(volume.probeCount);  // x * z（y-up）
	uint probeIndex = (planeIndex * probeCountPrePlane) + probePlaneIndex; 
	uvec3 probeCoords = DDGIGetProbeCoords(probeIndex,volume); // 探针在探针网格的坐标
	vec3 probeWorldPosition = DDGIGetProbeWorldPosition(probeCoords, volume); 
	vec3 rayDirection = normalize(RTXGISphericalFibonacci(rayIndex,volume.raysPerProbe)); // 生成光线方向
    // 最终每根光线的计算结果都需要存储， Texture2DArray(x:rayIndex, y:probeIndexInLayer, z:layerIndex)
	uvec3 outputCoords = DDGIGetRayDataTexelCoords(rayIndex,probeIndex,volume);

    // 启动射线
	traceRayEXT(TLAS, 					// acceleration structure
		gl_RayFlagsOpaqueEXT,       	// rayFlags 控制光线的行为，比如是否忽略背面、是否启用 any-hit、是否可用 conservative tracing 等
		0xFF,           				// cullMask 0xFF → 匹配所有实例
		0,              				// sbtRecordOffset 索引到 Shader Binding Table (SBT) 的起始记录位置
		1,              				// sbtRecordStride SBT 中每条记录的间隔（单位是记录数，不是字节）
		0,              				// missIndex 当光线没有击中任何几何体时，使用 SBT 中 miss shader 的索引
		probeWorldPosition.xyz,     	// ray origin
		0,       						// ray min range
		rayDirection.xyz,  				// ray direction
		MAX_RAY_TRACING_DISTANCE,       // TODO:这个应该换成DDGI自己的参数设置
		0               				// payload (location = 0) payload的位置
  	);

    // Miss，返回天空的Radiance
    if(payload.hitT == -1.f){
        imageStore(out_RAYDATA, ivec3(outputCoords), vec4(payload.albedo, 1e27f));
        return;
	}

    // 击中背面，参考RTXGI的做法
    // Make the hit distance negative to mark a backface hit for blending, probe relocation, and probe classification.
	// Shorten the hit distance on a backface hit by 80% to decrease the influence of the probe during irradiance sampling.
    if(payload.hitKind == gl_HitKindBackFacingTriangleEXT){
    	imageStore(out_RAYDATA, ivec3(outputCoords), vec4(vec3(0), -payload.hitT * 0.2));
    	return;
	}

/////////////////////////////////////////////
// Directional Light TODO: 点光源和聚光   这里也是通过TraceRays来判断阴影的
/////////////////////////////////////////////
	vec3 brdf = (payload.albedo / PI);
	vec3 lighting = vec3(0.f);
	DirectionLight dirLight = GetDirectionLight();
	// 硬件在找到第一个 hit 后立即停止 | 跳过ClosestHitShader，直接返回rayGen | 所有模型都被视为不透明
	const uint rayFlags =gl_RayFlagsTerminateOnFirstHitEXT | gl_RayFlagsSkipClosestHitShaderEXT | gl_RayFlagsOpaqueEXT;
	// 发射光线计算遮挡
	traceRayEXT(TLAS,
		rayFlags,
		0xFF, 
		0, 
		1,
		1, 
		payload.worldPosition,
		0,   
		-dirLight.direction,
		MAX_RAY_TRACING_DISTANCE,
		1
  	);
	float shadowScale = 1.0;
	if(shadowPayload.hitT !=  -1.f){
		shadowScale = 0.0;
	}
    vec3 lightDirection = -normalize(dirLight.direction);
    float  nol = max(dot(payload.normal, lightDirection), 0.f);
	vec3 dirLighting = nol * dirLight.radiance * shadowScale;
	lighting += dirLighting;
	vec3 diffuse = lighting * brdf;


/////////////////////////////////////////////
// Indirection Light
/////////////////////////////////////////////
	vec3 irradiance = vec3(0);
	float volumeBlendWeight = DDGIGetVolumeBlendWeight(payload.worldPosition, volume);
	if (volumeBlendWeight > 0){

        irradiance = DDGIGetIrrandianceByWorldPosition(
            payload.worldPosition,
            payload.normal,
            volume,
            ddgi_Irrandiance,ddgi_Distance);
	}
	// Perfectly diffuse reflectors don't exist in the real world.
    // Limit the BRDF albedo to a maximum value to account for the energy loss at each bounce.
    float maxAlbedo = 0.9f;

    vec3 radiance = diffuse + ((min(payload.albedo, vec3(maxAlbedo, maxAlbedo, maxAlbedo)) / PI) * irradiance * volumeBlendWeight);

	// 最终存储rayData radiance(3) + hitT(1)
	imageStore(out_RAYDATA, ivec3(outputCoords), vec4(Saturate(radiance), payload.hitT));
}

closestHit需要获取击中点的模型信息

#ifdef RAYCLOSEST_HIT_SHADER
layout(location = 0) rayPayloadInEXT Payload payload;
hitAttributeEXT vec2 attribs;
void main()
{
	uint instanceID       = gl_InstanceCustomIndexEXT;   // 在构建TLAS时，给每个实例分配的ID
	uint primitiveID     = gl_PrimitiveID;  // 击中的三角形索引

	vec3 barycentrics = vec3(1.0 - attribs.x - attribs.y, attribs.x, attribs.y); 

	// 收集MeshInfo
	mat4 model = GetModelMatrix(instanceID);
	uvec3 triangleIndex = GetTriangleIndex(instanceID, primitiveID);
	vec4 position = GetTrianglePosition(instanceID,triangleIndex,barycentrics);
	vec3 meshNormal = GetTriangleMeshNormal(instanceID,triangleIndex,barycentrics);
	vec4 tangent = GetTriangleTangent(instanceID,triangleIndex,barycentrics);

	vec3 worldNormal = GetWorldNormal(meshNormal,model);
	vec4 worldTangent = GetWorldTangent(tangent,model);
	vec2 texCoord  = GetTriangleTexCoord(instanceID, triangleIndex, barycentrics);    
    vec4 worldPos       = model * position; 
	MaterialInfo material   = GetMaterialInfo(instanceID);
	vec4 albedo = GetDiffuse(material,texCoord);
	vec3 normal = GetNormal(material, texCoord, worldNormal, worldTangent);
    vec4 emission = GetEmission(material,texCoord);
	albedo += emission;
	float roughness = GetRoughness(material,texCoord);
    float metallic = GetMetallic(material, texCoord);

	payload.worldPosition = worldPos.xyz;
	payload.normal = normal;
	payload.roughness = roughness;
	payload.metallic = metallic;
	payload.albedo = albedo.rgb;
	payload.hitT = gl_HitTEXT;
	payload.hitKind = gl_HitKindEXT;
}
#endif

Miss处理未击中的情况，需要两个，一个处理天空，一个处理阴影判断标记（因为MissShader只支持一个Payload，好像只有RayGen可以定义多个PayLoad，其他都只能用于处理一个PayLoad）

#ifdef RAYMISS_SHADER
layout(location = 0) rayPayloadInEXT Payload payload;    // rayPayloadInEXT 注意是InEXT

layout(set = 1, binding = 3) uniform textureCube skyCube;
void main()
{
	vec3 rayDir = normalize(gl_WorldRayDirectionEXT);
    payload.albedo = texture(samplerCube(skyCube,SAMPLER[0]),rayDir).rgb;
	payload.hitT = -1;
}
#endif

#ifdef RAYMISS_SHADER
layout(location = 1) rayPayloadInEXT ShadowPayLoad shadowPayload;

void main()
{
	shadowPayload.hitT = -1;
}
#endif

RayTrace结束后，获得了每个探针的每条光线携带的Radiance信息

另外还会在着色点采样它周围8个探针的光照数据（就是上一帧的记录，也是该着色点的间接光照）这样做相当于得到了采样点的间接光照

ProbeBlend

根据RayData来更新探针信息

IrrandianceBlend

探针理论上需要存储每个方向上的半球积分来得到该位置的Irrandiance，但是存储所有方向不太可能，DDGI采用6*6的像素存储一个探针36个方向上的Irrandiance，使用时进行插值即可，另外使用八面体映射，遍历每个探针，保存一个6 * 6区域，每个区域都被映射到八面体上的一个方向，再把这个方向挪到球面，遍历所有光线与该方向的权重进行混合

注意Texture2DArray的采样的uvw的w不是0-1,用第几层就传递几，这点疏忽了给我整麻了

// dispatch 需要处理网格中的每一个探针，所以传入的是probeCount.x, probeCount.y, probeCount.z
{
        // Irrandiance Blend
        builder.CreateComputePass(GetName() + "_ProbeIrrandianceBlend")
            .ReadWrite(1, 0, 0, irrandiance, VIEW_TYPE_2D_ARRAY, { TEXTURE_ASPECT_COLOR ,0,1,0,volumeLayerCount })
            .ReadWrite(1, 1, 0, rayTexture, VIEW_TYPE_2D_ARRAY, { TEXTURE_ASPECT_COLOR ,0,1,0,volumeLayerCount })
            .RootSignature(m_ProbeIrrandianceBlendRootSignature)
            .PassIndex(probeCount.x, probeCount.z, probeCount.y)
            .Execute([&](RDGPassContext context) {
            RHICommandListRef command = context.command;
            command->SetComputePipeline(m_ProbeIrrandianceBlendPipeline);
            command->BindDescriptorSet(RENDER_RESOURCEMANAGER->GetGlobalResourcePerFrameDescriptorSet(), 0);
            command->BindDescriptorSet(context.descriptors[1], 1);
            command->Dispatch(context.passIndex[0], context.passIndex[1], context.passIndex[2]);
                })
            .Finish();
    }

layout(set = 1, rgba32f, binding = 0) uniform image2DArray o_Texture;
layout(set = 1, rgba32f, binding = 1) uniform image2DArray  IN_RayData;
// 每个探针需要8*8的区域，所以这里线程组设置就是8*8（内部6*6是数据，外部一圈是填充，为了保证双线性插值的正确性）
layout(local_size_x = DDGI_PROBE_NUM_TEXELS_IRRANDIANCE, local_size_y = DDGI_PROBE_NUM_TEXELS_IRRANDIANCE, local_size_z = 1) in;

void main(){
    // 索引探针在RayData的位置
    DDGISetting volume = GetDDGISetting();
    uvec3 groupID = gl_WorkGroupID;  // 对于dispatch的ID
    uvec3 invocationID = gl_GlobalInvocationID; // 相对于全局的调用ID 用于最后存储像素位置
    uvec3 LocalInvocationID = gl_LocalInvocationID; // 相对于组内的调用ID 用于区别边界和内部
    // 用LocalInvocationID是不是0，0或者 7，7 马上就能判断是不是边界
    bool isBorderTexel = (LocalInvocationID.x == 0 || LocalInvocationID.x == (DDGI_PROBE_NUM_TEXELS_IRRANDIANCE_INTERIOR + 1)) || (LocalInvocationID.y == 0 || LocalInvocationID.y == (DDGI_PROBE_NUM_TEXELS_IRRANDIANCE_INTERIOR + 1));
    
    // 
    uint probeIndex = (groupID.y * DDGIGetProbesPerPlane(volume.probeCount)) + groupID.z * volume.probeCount.x + groupID.x ;

    // Early out: no probe maps to this thread 感觉不会出现这种情况
    uint numProbes = (volume.probeCount.x * volume.probeCount.y * volume.probeCount.z);
    if (probeIndex >= numProbes || probeIndex < 0) return;
    
    vec4 result = vec4(0.0);
    
    // 首先处理内部6*6
    if(!isBorderTexel){
        // 对于6*6区域的一个像素，对应到探针的一个方向上，需要计算这个方向上的半球积分来存储Irrandiance
        // 1. 获取这个像素对应的方向
        uvec3 threadCoords = uvec3(groupID.x * DDGI_PROBE_NUM_TEXELS_IRRANDIANCE_INTERIOR, groupID.y * DDGI_PROBE_NUM_TEXELS_IRRANDIANCE_INTERIOR, invocationID.z) + LocalInvocationID - uvec3(1, 1, 0); // 计算出抛开边界后当前线程是的坐标（没有边界填充的2DArray坐标）
        // 把6*6区域当作一个纹理，下面获得当前线程处理的位置的UV坐标[-1,1]
        vec2 probeOctantUV = DDGIGetNormalizedOctahedralCoordinates(uvec2(threadCoords.xy), DDGI_PROBE_NUM_TEXELS_IRRANDIANCE_INTERIOR);
        // 获取这个UV对应到八面体上的方向
    	vec3 probeRayDirection = DDGIGetOctahedralDirection(probeOctantUV);

        
        // 遍历当前探针的所有光线，为当前八面体上的方向计算irrandiance
        for (uint rayIndex = 0; rayIndex < volume.raysPerProbe; rayIndex++){
            // 获取ray的方向，RTXGISphericalFibonacci是可以复现的所以不需要提前存储
            vec3 rayDirection = normalize(RTXGISphericalFibonacci(rayIndex,volume.raysPerProbe));  // TODO: 优化点，因为每个探针计算这个都是一模一样的
            // 当前要存储的方向与这跟光线的cos，两个方向夹角越小，权重越大
            float weight = max(0.0, dot(probeRayDirection, rayDirection));
            // 解析RayData中的信息
            uvec3 rayDataTexCoords = DDGIGetRayDataTexelCoords(rayIndex, probeIndex, volume);  
            vec4 storedData = imageLoad(IN_RayData, ivec3(rayDataTexCoords));
            vec3 probeRayRadiance = storedData.xyz;
            float probeRayDistance = storedData.w;
            if(probeRayDistance < 0){ // 击中的是背面
                continue;
            }
            result += vec4(probeRayRadiance * weight, weight);
        }

        // 到这里 用vec4存储了所有光线的加权和，并且w分量存储了权重和，方便计算
//////////////////////////////工程化修正/////////////////////////////////////////////
        float epsilon = float(volume.raysPerProbe);
        epsilon *= 1e-9f;
        result.rgb *= 1.f / (1.f * max(result.a, epsilon));

        // 时域加权混合
        vec4 history = imageLoad(o_Texture,ivec3(gl_GlobalInvocationID));
        vec3 delta = (result.rgb - history.rgb);

        float  hysteresis = 0.97; // TODO：混合系数是参数
        if (dot(history, history) == 0) hysteresis = 0.f;
        float probeIrradianceEncodingGamma = 5.0f;  // TODO：编码Gamma是参数
        
        result.rgb = pow(result.rgb, vec3(1.f / probeIrradianceEncodingGamma));
        vec3 irradianceSample = result.rgb;
        float probeIrradianceThreshold = 0.25f; // TODO：阈值是参数
        if (RTXGIMaxComponent(history.rgb - result.rgb) > probeIrradianceThreshold)
        {
            // Lower the hysteresis when a large lighting change is detected
            hysteresis = max(0.f, hysteresis - 0.75f);
        }
        float probeBrightnessThreshold  = 0.10f; // TODO：阈值是参数
        if (RGBtoLuminance(delta) > probeBrightnessThreshold)
        {
            // Clamp the maximum per-update change in irradiance when a large brightness change is detected
            delta *= 0.25f;
        }
        const float c_threshold = 1.f / 1024.f;
        vec3 lerpDelta = (1.f - hysteresis) * delta;
        if (RTXGIMaxComponent(result.rgb) < RTXGIMaxComponent(history.rgb))
        {
            lerpDelta = min(max(vec3(c_threshold), abs(lerpDelta)), abs(delta)) * sign(lerpDelta);
        }
        result = vec4(history.rgb + lerpDelta, 1.f);
        imageStore(o_Texture, ivec3(gl_GlobalInvocationID), result);
///////////////////////////////////////////////////////////////////////////
        
        
        // 边界处理
       else{
        // 边界
        // AllMemoryBarrierWithGroupSync();   这里有一个同步点 

        bool isCornerTexel = (LocalInvocationID.x == 0 || LocalInvocationID.x == (DDGI_PROBE_NUM_TEXELS_IRRANDIANCE - 1)) && (LocalInvocationID.y == 0 || LocalInvocationID.y == (DDGI_PROBE_NUM_TEXELS_IRRANDIANCE - 1));
        bool isRowTexel = (LocalInvocationID.x > 0 && LocalInvocationID.x < (DDGI_PROBE_NUM_TEXELS_IRRANDIANCE - 1));

        uvec3 copyCoordinates = uvec3(groupID.x * DDGI_PROBE_NUM_TEXELS_IRRANDIANCE, groupID.y * DDGI_PROBE_NUM_TEXELS_IRRANDIANCE, invocationID.z);

        if(isCornerTexel)
        {
            copyCoordinates.x += LocalInvocationID.x > 0 ? 1 : DDGI_PROBE_NUM_TEXELS_IRRANDIANCE_INTERIOR;
            copyCoordinates.y += LocalInvocationID.y > 0 ? 1 : DDGI_PROBE_NUM_TEXELS_IRRANDIANCE_INTERIOR;
        }
        else if(isRowTexel)
        {
            copyCoordinates.x += (DDGI_PROBE_NUM_TEXELS_IRRANDIANCE - 1) - LocalInvocationID.x;
            copyCoordinates.y += LocalInvocationID.y + ((LocalInvocationID.y > 0) ? -1 : 1);
        }
        else // Column Texel
        {
            copyCoordinates.x += LocalInvocationID.x + ((LocalInvocationID.x > 0) ? -1 : 1);
            copyCoordinates.y += (DDGI_PROBE_NUM_TEXELS_IRRANDIANCE - 1) - LocalInvocationID.y;
        }

        imageStore(o_Texture, ivec3(gl_GlobalInvocationID), imageLoad(o_Texture, ivec3(copyCoordinates)));
    }
}

DistanceBlend

对于distance，只有一些地方不一样

#version 450 core
#include "../common/common.glsl"
#include "../common/DDGI.glsl"
layout(set = 1, rgba32f, binding = 0) uniform image2DArray o_Texture;
layout(set = 1,rgba32f, binding = 1) uniform image2DArray  IN_RayData;
#ifdef COMPUTE_SHADER
layout(local_size_x = DDGI_PROBE_NUM_TEXELS_DISTANCE, local_size_y = DDGI_PROBE_NUM_TEXELS_DISTANCE, local_size_z = 1) in;  
void main(){
	DDGISetting volume = GetDDGISetting();
    uvec3 groupID = gl_WorkGroupID;  // 对于dispatch的ID
    uvec3 invocationID = gl_GlobalInvocationID; // 相对于全局的调用ID
    uvec3 LocalInvocationID = gl_LocalInvocationID; // 相对于组内的调用ID
    bool isBorderTexel = (LocalInvocationID.x == 0 || LocalInvocationID.x == (DDGI_PROBE_NUM_TEXELS_DISTANCE_INTERIOR + 1)) || (LocalInvocationID.y == 0 || LocalInvocationID.y == (DDGI_PROBE_NUM_TEXELS_DISTANCE_INTERIOR + 1));
    uint probeIndex = (groupID.y * DDGIGetProbesPerPlane(volume.probeCount)) + groupID.z * volume.probeCount.x + groupID.x ;

    vec4 result = vec4(0.0);

    if(!isBorderTexel){
        uvec3 threadCoords = uvec3(groupID.x * DDGI_PROBE_NUM_TEXELS_DISTANCE_INTERIOR, groupID.y * DDGI_PROBE_NUM_TEXELS_DISTANCE_INTERIOR, invocationID.z) + LocalInvocationID - uvec3(1, 1, 0);
        vec2 probeOctantUV = DDGIGetNormalizedOctahedralCoordinates(uvec2(threadCoords.xy), DDGI_PROBE_NUM_TEXELS_DISTANCE_INTERIOR);
        vec3 probeRayDirection = DDGIGetOctahedralDirection(probeOctantUV);
        // 遍历当前探针的所有光线
        for (uint rayIndex = 0; rayIndex < volume.raysPerProbe; rayIndex++){
            vec3 rayDirection = normalize(RTXGISphericalFibonacci(rayIndex, volume.raysPerProbe));
            float weight = max(0.f, dot(probeRayDirection, rayDirection));
            float probeDistanceExponent = 50.f; // TODO:参数
             // Increase or decrease the filtered distance value's "sharpness"
            weight = pow(weight, probeDistanceExponent);
            uvec3 rayDataTexCoords = DDGIGetRayDataTexelCoords(rayIndex, probeIndex, volume);
            // 光线最大能射到probe间距的1.5倍
            float probeMaxRayDistance = length(volume.gridStep) * 1.5f;
            vec4 storedData = imageLoad(IN_RayData, ivec3(rayDataTexCoords));
            float probeRayDistance = storedData.w;
            probeRayDistance = min(abs(probeRayDistance),probeMaxRayDistance);
            result += vec4(probeRayDistance * weight, (probeRayDistance * probeRayDistance) * weight, 0.f, weight);
        }
//////////////////////////////工程化修正/////////////////////////////////////////////
        float epsilon = float(volume.raysPerProbe);
        epsilon *= 1e-9f;
        result.rgb *= 1.f / (1.f * max(result.a, epsilon));

        // 时域加权混合
        vec4 history = imageLoad(o_Texture,ivec3(gl_GlobalInvocationID));
        float  hysteresis = 0.97; // TODO：混合系数是参数
        if (dot(history, history) == 0) hysteresis = 0.f;
        result = vec4(Lerp(result.rg, history.rg, hysteresis), 0.f, 1.f);
//////////////////////////////工程化修正/////////////////////////////////////////////
        imageStore(o_Texture, ivec3(gl_GlobalInvocationID), result);
        return;

    }else{
        // 边界
        memoryBarrier();        // 所有全局内存类型的屏障
        memoryBarrierShared();  // 对 shared 内存屏障
        barrier();   //这里有一个同步点 


        bool isCornerTexel = (LocalInvocationID.x == 0 || LocalInvocationID.x == (DDGI_PROBE_NUM_TEXELS_DISTANCE - 1)) && (LocalInvocationID.y == 0 || LocalInvocationID.y == (DDGI_PROBE_NUM_TEXELS_IRRANDIANCE - 1));
        bool isRowTexel = (LocalInvocationID.x > 0 && LocalInvocationID.x < (DDGI_PROBE_NUM_TEXELS_DISTANCE - 1));

        uvec3 copyCoordinates = uvec3(groupID.x * DDGI_PROBE_NUM_TEXELS_DISTANCE, groupID.y * DDGI_PROBE_NUM_TEXELS_DISTANCE, invocationID.z);

        if(isCornerTexel)
        {
            copyCoordinates.x += LocalInvocationID.x > 0 ? 1 : DDGI_PROBE_NUM_TEXELS_DISTANCE_INTERIOR;
            copyCoordinates.y += LocalInvocationID.y > 0 ? 1 : DDGI_PROBE_NUM_TEXELS_DISTANCE_INTERIOR;
        }
        else if(isRowTexel)
        {
            copyCoordinates.x += (DDGI_PROBE_NUM_TEXELS_DISTANCE - 1) - LocalInvocationID.x;
            copyCoordinates.y += LocalInvocationID.y + ((LocalInvocationID.y > 0) ? -1 : 1);
        }
        else // Column Texel
        {
            copyCoordinates.x += LocalInvocationID.x + ((LocalInvocationID.x > 0) ? -1 : 1);
            copyCoordinates.y += (DDGI_PROBE_NUM_TEXELS_DISTANCE - 1) - LocalInvocationID.y;
        }

        imageStore(o_Texture, ivec3(gl_GlobalInvocationID), imageLoad(o_Texture, ivec3(copyCoordinates)));
    }

}

#endif

IndirectLight

/*
    根据一个世界坐标，计算从探针中获取的Irrandiance
*/
vec3 DDGIGetIrrandianceByWorldPosition(vec3 worldPosition, vec3 direction, DDGISetting volume, texture2DArray IrrdianceTexture,texture2DArray distanceTexture){

    // 如果WorldPosition不在DDGIvolume内，直接返回
    // if(!DDGICheckPostion(worldPosition,volume)){
    //     return vec3(0.f, 0.f, 0.f);
    // }
    vec3  sumIrradiance = vec3(0.0f);
    float sumWeight = 0.0f;

    vec3 irradiance = vec3(0.f, 0.f, 0.f);
    float accumulatedWeights = 0.f;
    // 得到离worldPosition最近的探针坐标
    ivec3 baseProbeCoords = DDGIGetBaseProbeGridCoords(worldPosition, volume);
    vec3 baseProbeWorldPosition = DDGIGetProbeWorldPosition(baseProbeCoords,volume);
    vec3 alpha = clamp(((worldPosition - baseProbeWorldPosition) / volume.gridStep), vec3(0.f, 0.f, 0.f), vec3(1.f, 1.f, 1.f));

    for(int i = 0; i < 8; i++){
        float weight = 1.0;
        // 使用魔法获得一个探针😄
        ivec3  offset  = ivec3(i, i >> 1, i >> 2) & ivec3(1);
        ivec3  probeGridCoord   = clamp(baseProbeCoords + offset, ivec3(0), ivec3(volume.probeCount) - ivec3(1));
        uint probeIndex =  (probeGridCoord.y * DDGIGetProbesPerPlane(volume.probeCount)) + probeGridCoord.z * volume.probeCount.x + probeGridCoord.x;
        vec3 probePos = DDGIGetProbeWorldPosition(probeGridCoord, volume);

        // 方向系数
        {
            vec3 directionToProbe = normalize(probePos - worldPosition);
            weight *= Square(max(0.0001, (dot(directionToProbe, direction) + 1.0) * 0.5)) + 0.2;  
        }

        //切比雪夫系数
        {
            vec3 probeToPoint   = worldPosition - probePos;
            vec3 dir            = normalize(-probeToPoint);
            float dist          = length(probeToPoint);
            vec2 octantCoords = DDGIGetOctahedralCoordinates(dir);
            vec3 probeTextureUV = DDGIGetProbeUV(int(probeIndex), octantCoords, int(DDGI_PROBE_NUM_TEXELS_DISTANCE_INTERIOR), volume);
            vec2 temp = texture(sampler2DArray(distanceTexture,SAMPLER[0]),probeTextureUV).rg;  // 采样距离纹理
            float mean      = temp.x;
            float variance  = abs(Square(temp.x) - temp.y);

            float chebyshev = variance / (variance + Square(max(dist - mean, 0.0)));
            chebyshev       = max(Pow3(chebyshev), 0.0);  //以切比雪夫系数三次方作为权重

            weight *= (dist <= mean) ? 1.0 : chebyshev;
        }

        //避免计算精度问题
        {
            weight = max(0.000001, weight); 

            const float crushThreshold = 0.2f;
            if (weight < crushThreshold)
                weight *= weight * weight * (1.0f / Square(crushThreshold)); 
        }

        //三线性插值系数
        {
            vec3 trilinear = mix(1.0 - alpha, alpha, offset);
            weight *= trilinear.x * trilinear.y * trilinear.z;  
        }

        //采样，累计光照      
        {
            vec3 irradianceDir  = direction;
            vec2 octantCoords = DDGIGetOctahedralCoordinates(direction);
            vec3 probeTextureUV = DDGIGetProbeUV(int(probeIndex), octantCoords, int(DDGI_PROBE_NUM_TEXELS_IRRANDIANCE_INTERIOR), volume);
            vec3 probeIrradiance = texture(sampler2DArray(IrrdianceTexture,SAMPLER[0]),probeTextureUV).rgb;
            sumIrradiance += weight * probeIrradiance;
            sumWeight += weight;
        }

    }

    vec3 netIrradiance = sumIrradiance / sumWeight;
    return 2 * PI * netIrradiance; 
}

下图显示只渲染间接光

Math

首先回顾Irrandiance是单位半球上各个方向的Radiance的积分（×cos）

均匀分布的蒙特卡洛积分来近似上边这个积分式

DDGI存储一个Irrandiance时，并不是/N，而是/余弦权重之和，目的是减少方差

他的期望是N/2,对比蒙特卡洛积分还需要*2

总结

第一次实现比较复杂的全局光照效果，还是太逞能，总想抄RTXGI的各种实践Tick，实际根本理解不了。甚至还想着用Y-Up来构建Imager2DArray，导致逻辑十分混乱。大量时间用在了无用的调试Bug上。
还有一些DDGI的内容没有实现
1. RelocationVolumeProbes：读取一个探针交中背面的次数，如果大于阈值，说明Probe在墙里边，就朝着交中背面的方向偏移，或者交中正面的距离太短了，也进行偏移
2. ClassifyVolumeProbes：Classify主要是为了给probe进行分类，对于一些卡在墙中或者不在视野内的probe则不进行计算，以节省开销，当然，更重要的是，这个还能避免计算墙外probe，一定程度上减少漏光
总体来看第一次搞大动作比较失败~

游戏引擎开发实践（抗锯齿 TAA）

Thu, 04 Dec 2025 18:58:15 +0800

总体来看TAA思想比较简单易懂，实现思路更多是实践性的经验总结

TAA

TAA (Temporal Anti-Aliasing) 综合历史帧的数据来实现抗锯齿，这样会将每个像素点的多次采样均摊到多个帧中，相对的开销要小得多。在 MSAA 中，我们在一帧中，在每个像素中放置了多个次像素采样点。在 TAA 中，我们实现的方式，就是在每帧采样时，将采样的点进行偏移，实现抖动 (jitter)。

静态场景

在静态场景下，上一帧与本帧的颜色信息很好获得，只需要取相同位置进行采样，然后进行一个插值即可，然后用jitter进行抖动

1
2
3

float3 currColor = currBuffer.Load(pos);
float3 historyColor = historyBuffer.Load(pos);
return lerp(historyColor, currColor, 0.05f);

这里的取混合系数为0.05，意味着最新的一帧渲染结果，只对最终结果产生了5%的贡献。

将累计的过程展开来看的话，可以看出当前帧 TAA 后的结果，是包含了所有的历史帧结果的，说明这种方式是合理的：

在 TAA 中，我们实现的方式，就是在每帧采样时，将采样的点进行偏移，实现抖动 (jitter)。采样点抖动的偏移，是和 MSAA 的次像素采样点放置是相同的，都需要使用低差异的采样序列，来实现更好的抗锯齿效果。TAA 中都会直接使用 Halton 序列，采样的点位置如下所示：

1
2
3

// 先将Halton序列的值转化为 -0.5~0.5范围的偏移；再除以屏幕长度，得到UV下的偏移值；最后乘以2，是转化到裁剪空间中的偏移值
ProjectionMatrix.m02 += (HaltonSequence[Index].x - 0.5f) / ScreenWidth * 2;
ProjectionMatrix.m12 += (HaltonSequence[Index].y - 0.5f) / ScreenHeight * 2;

动态物体

要对历史数据进行混合，就要能够还原出当前物体在屏幕中投影的位置。为了能够精确地记录物体在屏幕空间中的移动，我们使用 Motion Vector 贴图来记录物体在屏幕空间中的变化距离，表示当前帧和上一帧中，物体在屏幕空间投影坐标的变化值

记录上一帧的投影矩阵和上一帧的模型位置，在本帧使用上一帧的透视变换逆变换就能把模型还原到上一帧的视角下，在上一帧视角下对比两帧模型的位置来拿到Motion Vector（这种有点麻烦，实战不用这种方案）

使用 MotionVector

已经知道模型的运动变化了，在本帧中复原模型到上一帧的位置，算出对应的屏幕坐标

// 减去抖动坐标值，得到当前实际的像素中心UV值
uv -= _Jitter;
// 减去Motion值，算出上帧的投影坐标
float2 uvLast = uv - motionVectorBuffer.Sample(point, uv);
//使用双线性模式采样
float3 historyColor = historyBuffer.Sample(linear, uvLast);

这样使用也是有问题的。比如一扇门，本来模型在门后，现在向右位移模型出现，但是按照MontionVector去采样上一帧的颜色时，其实采样到了门上。

因此为了得到更加平滑的数据，可以在当前像素点周围判断深度，取距离镜头最近的点位置，来采样 Motion Vector 的值，这样可以减弱遮挡错误的影响。

优化手法：使用 lerp 代替 if-else，可以在 GPU 并行计算中避免分支，提高效率

float2 GetClosestFragment(float2 uv)
{
    float2 k = _CameraDepthTexture_TexelSize.xy;
    //在上下左右四个点
    const float4 neighborhood = float4(
        SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, sampler_PointClamp, clamp(uv - k)),
        SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, sampler_PointClamp, clamp(uv + float2(k.x, -k.y))),
        SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, sampler_PointClamp, clamp(uv + float2(-k.x, k.y))),
        SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, sampler_PointClamp, clamp(uv + k))
    );
    // 获取离相机最近的点
    #if defined(UNITY_REVERSED_Z)
        #define COMPARE_DEPTH(a, b) step(b, a)
    #else
        #define COMPARE_DEPTH(a, b) step(a, b)
    #endif
    // 获取离相机最近的点，这里使用 lerp 是避免在shader中写分支判断
    float3 result = float3(0.0, 0.0, SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, sampler_PointClamp, uv));
    result = lerp(result, float3(-1.0, -1.0, neighborhood.x), COMPARE_DEPTH(neighborhood.x, result.z));
    result = lerp(result, float3( 1.0, -1.0, neighborhood.y), COMPARE_DEPTH(neighborhood.y, result.z));
    result = lerp(result, float3(-1.0,  1.0, neighborhood.z), COMPARE_DEPTH(neighborhood.z, result.z));
    result = lerp(result, float3( 1.0,  1.0, neighborhood.w), COMPARE_DEPTH(neighborhood.w, result.z));
    return (uv + result.xy * k);
}

//在周围像素中，寻找离相机最近的点
float2 closest = GetClosestFragment(uv);
//使用周围最近点，得到Velocity值，来计算上帧投影位置
float2 uvLast = uv - motionVectorBuffer.Sample(point, closest);
//...

另外对应历史点的采样，可以使用 Catmull–Rom 采样进行进一步优化，而不是使用默认的双线性采样

因为使用了双线性采样，所以得到的值会混合周围像素的颜色，造成结果略微模糊。如果想要使得到的历史结果质量更好，也可以使用一些特殊的过滤方式进行处理。比如UE4中使用 Catmull–Rom 的方式进行锐化过滤。Catmull-Rom方式的采样，会在目标点周围进行 5 次采样，然后根据相应权重进行过滤混合，额外的开销也非常大。

历史结果处理

由于像素抖动，模型变化，渲染光照变化导致渲染结果发生变化时，会导致历史帧得到的像素值失效，就会产生 鬼影/ghosting 和 闪烁 /flicking 问题。

为了缓解鬼影和闪烁的问题，我们还要对采样的历史帧和当前帧数据进行对比，将历史帧数据 clamp/截断 在合理的范围内。要确定当前帧目标像素的亮度范围，就需要读取当前帧数据目标像素周围 5 个或者 9 个像素点的颜色范围：

简单的做法就是直接进行 clamp：就是先在当前位置像素领域内判断颜色范围，之后采样历史点时把历史点的颜色clamp到这个范围内，防止它颜色变化太大

float3 AABBMin, AABBMax;
AABBMax = AABBMin = RGBToYCoCg(Color);
// 取得YCoCg色彩空间下，Clip的范围
for(int k = 0; k < 9; k++)
{
    float3 C = RGBToYCoCg(_MainTex.Sample(sampler_PointClamp, uv, kOffsets3x3[k]));
    AABBMin = min(AABBMin, C);
    AABBMax = max(AABBMax, C);
}
// 需要 Clip处理的历史数据
float3 HistoryYCoCg = RGBToYCoCg(HistoryColor);

// 简单地进行Clmap
float3 ResultYCoCg =  clmap(History, AABBMin, AABBMax);
//还原到RGB色彩空间，得到最终结果
HistoryColor.rgb = YCoCgToRGB(ResultYCoCg));

另外一种做法是进行 clip，clip的效果会更好，计算量也会相对较大二者的差别可从下图看出：

Clip和Clamp的区别，clamp简单粗暴地把颜色固定到范围角点上，clip则效果更好，首先获取范围内颜色的中间值，然后从历史点颜色发送射线到中间值，取射线与AABB盒交点位置的颜色值

混合结果

1
2
3

// 与上帧相比移动距离越远，就越倾向于使用当前的像素的值
blendFactor = saturate(0.05 + length(motion) * 100);
return lerp(historyColor, currColor, blendFactor);

因为我们用到了很多双线性采样，会使得得到的结果有些模糊，因此我们根据情况选择是否对结果进行一次简单的锐化。

实战

MotionVector

这块逻辑很清晰。因为模型在世界的位置只取决于模型实例的Model变换。而模型在屏幕像素的位置取决于投影矩阵和摄像机矩阵。所以每个模型都需要额外存储一个glm::mat4来存储上一帧的模型变换，摄像机也需要额外存储上一帧的投影矩阵（不过这个一般不会变），已经上一帧的View矩阵

在GBufferPass时，获取模型上一帧的Model矩阵，在FragShader中，根据像素存储插值出来的本帧Position和上帧Position进行计算，得到MotionVector

vec2 CalculateVelocity(vec4 pos, vec4 prevPos){
    vec4 curNDC  = CAMERAINFO.data.proj * CAMERAINFO.data.view * pos;
    curNDC /= curNDC.w;
    vec2 curUV = curNDC.xy * 0.5 + 0.5;
    vec4 prevNDC = CAMERAINFO.data.prevProj * CAMERAINFO.data.prevView * prevPos;
    prevNDC /= prevNDC.w;
    vec2 prevUV = prevNDC.xy * 0.5 + 0.5;
    return vec2(curUV.xy - prevUV.xy);  // MotionVector存储的是当前像素与上一帧中该位置信息所在的像素的偏移增量
}

混合历史信息

在TAApass，读取当前ViewPort，根据MotionVector把像素值偏移到上一帧位置，读取历史信息，混合历史信息和当前信息

#version 450 core
#include "../common/common.glsl"
#ifdef COMPUTE_SHADER

layout(set = 1,binding = 0,rgba32f) uniform image2D out_texture;
layout(set = 1,binding = 1) uniform texture2D velocityTexture;
layout(set = 1,binding = 2) uniform texture2D historyTexture;
layout(set = 1,binding = 3) uniform texture2D curTexture;
layout(set = 1,binding = 4) uniform texture2D depthTexture;


vec2 GetClosestFragment(vec2 uv)
{
    vec2 k = 1.0 / vec2(imageSize(out_texture)); 
    
    float depth0 = texture(sampler2D(depthTexture, SAMPLER[0]), clamp(uv - k, 0.0, 1.0)).r;
    float depth1 = texture(sampler2D(depthTexture, SAMPLER[0]), clamp(uv + vec2(k.x, -k.y), 0.0, 1.0)).r;
    float depth2 = texture(sampler2D(depthTexture, SAMPLER[0]), clamp(uv + vec2(-k.x, k.y), 0.0, 1.0)).r;
    float depth3 = texture(sampler2D(depthTexture, SAMPLER[0]), clamp(uv + k, 0.0, 1.0)).r;
    
    vec4 neighborhood = vec4(depth0, depth1, depth2, depth3);

    #define COMPARE_DEPTH(a, b) step(a, b)


    vec3 result = vec3(0.0, 0.0, texture(sampler2D(depthTexture, SAMPLER[0]), uv).r);
    
    result = mix(result, vec3(-1.0, -1.0, neighborhood.x), COMPARE_DEPTH(neighborhood.x, result.z));
    result = mix(result, vec3( 1.0, -1.0, neighborhood.y), COMPARE_DEPTH(neighborhood.y, result.z));
    result = mix(result, vec3(-1.0,  1.0, neighborhood.z), COMPARE_DEPTH(neighborhood.z, result.z));
    result = mix(result, vec3( 1.0,  1.0, neighborhood.w), COMPARE_DEPTH(neighborhood.w, result.z));

    #undef COMPARE_DEPTH
    return uv + result.xy * k;
}

layout(local_size_x = 16, local_size_y = 16, local_size_z = 1) in;
void main()
{
    // TODO: 此处的重投影逻辑可能在别的地方一会用到，应该写成单独的一个pass,把重投影后的UV写在一个纹理中
    ivec2 imgSize = ivec2(imageSize(out_texture));
    ivec2 invocID = ivec2(gl_GlobalInvocationID.xy);
    if (invocID.x >= imgSize.x || invocID.y >= imgSize.y) 
        return;
    vec2 texCoords = (vec2(invocID) + 0.5f) / vec2(imgSize);

    vec2 ClosestUv = GetClosestFragment(texCoords);

    vec2 velocity = texture(sampler2D(velocityTexture,SAMPLER[0]), ClosestUv).rg;  // 用采样点周围离摄像头最近的深度的UV来采样速度值
    vec2 historyTexCoords = texCoords - velocity;
    bool valid = historyTexCoords.x > 0.0f ? true : false;

    float blend = 0.95f;
    if(!valid)  blend = 1.0f;

    vec3 historyColor = texture(sampler2D(historyTexture,SAMPLER[0]), historyTexCoords).rgb;
    vec3 curColor = texture(sampler2D(curTexture,SAMPLER[0]), texCoords).rgb;
    vec3 mixColor = mix(curColor,historyColor, blend);
    imageStore(out_texture, invocID, vec4(mixColor, 1.0));
}

#endif

当然目前只是简单混合了颜色，渲染结果能看出来TAA的效果，但是移动物体或者摄像机时，鬼影十分严重

处理拖影

对比当前数据和历史数据，把历史数据clamp到合理范围内

#version 450 core
#include "../common/common.glsl"
#include "../common/TAA.glsl"
#include "../common/math.glsl"
#ifdef COMPUTE_SHADER

layout(set = 1,binding = 0,rgba32f) uniform image2D out_texture;
layout(set = 1,binding = 1) uniform texture2D velocityTexture;
layout(set = 1,binding = 2) uniform texture2D historyTexture;
layout(set = 1,binding = 3) uniform texture2D curTexture;
layout(set = 1,binding = 4) uniform texture2D depthTexture;

layout(local_size_x = 16, local_size_y = 16, local_size_z = 1) in;

void main()
{
    ivec2 invocID = ivec2(gl_GlobalInvocationID.xy);
    ivec2 imgSize = ivec2(imageSize(out_texture));
    if (invocID.x >= imgSize.x || invocID.y >= imgSize.y) 
        return;
    if(GetPostprocessSetting().TaaSetting.enable == 0){
        vec2 texCoords = (vec2(invocID) + 0.5f) / vec2(imgSize);
        vec3 curColor = texture(sampler2D(curTexture,SAMPLER[0]), texCoords).rgb;
        imageStore(out_texture, invocID, vec4(curColor, 1.0));
        return;
    }
    vec2 texelSize = 1.0 / vec2(imgSize);
    vec2 baseTexCoords = (vec2(invocID) + 0.5f) / vec2(imgSize);
    vec2 jitterUV = GetPostprocessSetting().TaaSetting.UVjetter * texelSize;
    vec2 texCoordsWithJitter = baseTexCoords + jitterUV;

    vec2 ClosestUv = GetClosestFragment(baseTexCoords, texelSize, depthTexture);
    vec2 velocity = texture(sampler2D(velocityTexture,SAMPLER[0]), ClosestUv).rg;
    vec2 historyTexCoords = baseTexCoords - velocity; 

    // 采样当前帧（带抖动）、历史帧（无抖动）颜色
    vec3 historyColor = texture(sampler2D(historyTexture,SAMPLER[0]), historyTexCoords).rgb;
    vec3 curColor = texture(sampler2D(curTexture,SAMPLER[0]), texCoordsWithJitter).rgb;

    const vec2 kOffsets3x3[9] = {
        vec2(-1.0, -1.0), vec2( 0.0, -1.0), vec2( 1.0, -1.0),
        vec2(-1.0,  0.0), vec2( 0.0,  0.0), vec2( 1.0,  0.0),
        vec2(-1.0,  1.0), vec2( 0.0,  1.0), vec2( 1.0,  1.0)
    };

    // fix 拖影：3x3邻域使用带抖动的UV，且钳位边界
    vec3 AABBMin = RGBToYCoCg(curColor);
    vec3 AABBMax = AABBMin;
    for(int k = 0; k < 9; k++)
    {
        vec2 uvOffset = kOffsets3x3[k] * texelSize;
        vec2 neighborUV = texCoordsWithJitter + uvOffset;
        neighborUV = clamp(neighborUV, 0.0, 1.0);
        vec3 C = RGBToYCoCg(texture(sampler2D(curTexture, SAMPLER[0]), neighborUV).rgb);
        AABBMin = min(AABBMin, C);
        AABBMax = max(AABBMax, C);
    }

    // Clip处理核心逻辑（无问题）
    vec3 HistoryYCoCg = RGBToYCoCg(historyColor);
    vec3 Filtered = (AABBMin + AABBMax) * 0.5f;
    vec3 RayOrigin = HistoryYCoCg;
    vec3 RayDir = Filtered - RayOrigin;
    float epsilon = 1.0 / 65536.0;
    RayDir = mix(vec3(epsilon), RayDir, greaterThan(abs(RayDir), vec3(epsilon)));
    vec3 InvRayDir = 1.0 / RayDir;
    vec3 MinIntersect = (AABBMin - RayOrigin) * InvRayDir;
    vec3 MaxIntersect = (AABBMax - RayOrigin) * InvRayDir;
    vec3 EnterIntersect = min(MinIntersect, MaxIntersect);
    float ClipBlend = max(EnterIntersect.x, max(EnterIntersect.y, EnterIntersect.z));
    ClipBlend = clamp(ClipBlend, 0.0, 1.0);
    vec3 ResultYCoCg = mix(HistoryYCoCg, Filtered, ClipBlend);
    historyColor = YCoCgToRGB(ResultYCoCg);

    float motionLength = length(velocity);
    float blendFactor = Saturate(0.05 + motionLength * 1000.0);
    bool valid = (historyTexCoords.x >= 0.0 && historyTexCoords.x <= 1.0) && 
                 (historyTexCoords.y >= 0.0 && historyTexCoords.y <= 1.0);
    if (!valid) {blendFactor = 1.0;}

    if (GetPostprocessSetting().TaaSetting.shaper == 1)
    {
        float strength = GetPostprocessSetting().TaaSetting.shaperStrength;
        vec2 topUV     = clamp(texCoordsWithJitter + vec2(0.0, -texelSize.y), 0.0, 1.0);
        vec2 leftUV    = clamp(texCoordsWithJitter + vec2(-texelSize.x, 0.0), 0.0, 1.0);
        vec2 rightUV   = clamp(texCoordsWithJitter + vec2(texelSize.x, 0.0), 0.0, 1.0);
        vec2 bottomUV  = clamp(texCoordsWithJitter + vec2(0.0, texelSize.y), 0.0, 1.0);

        vec3 topColor    = RGBToYCoCg(texture(sampler2D(curTexture, SAMPLER[0]), topUV).rgb);
        vec3 leftColor   = RGBToYCoCg(texture(sampler2D(curTexture, SAMPLER[0]), leftUV).rgb);
        vec3 centerColor = RGBToYCoCg(curColor);
        vec3 rightColor  = RGBToYCoCg(texture(sampler2D(curTexture, SAMPLER[0]), rightUV).rgb);
        vec3 bottomColor = RGBToYCoCg(texture(sampler2D(curTexture, SAMPLER[0]), bottomUV).rgb);

        vec3 sharpenSum = vec3(0.0);
        sharpenSum += (-1.0 * strength) * topColor;
        sharpenSum += (-1.0 * strength) * leftColor;
        sharpenSum += (5.0 * strength) * centerColor;
        sharpenSum += (-1.0 * strength) * rightColor;
        sharpenSum += (-1.0 * strength) * bottomColor;

        vec3 sharpenedColor = YCoCgToRGB(sharpenSum);
        sharpenedColor = max(sharpenedColor, vec3(0.0));
        curColor = sharpenedColor;
    }

    // HDR需要先转为LDRmix后再恢复， 如果不这样，目前测试发现会出现一个黑点，然后移动后越来越大
    historyColor = ToneMapping(max(historyColor, 0.0f));
    curColor = ToneMapping(max(curColor, 0.0f));
    vec3 mixColor = mix(historyColor, curColor, blendFactor);
    mixColor = InverseToneMapping(max(mixColor, 0.0f));

    imageStore(out_texture, invocID, vec4(mixColor, 1.0));
}

#endif

游戏引擎开发实践（Vulkan接入光线追踪光线）

Tue, 02 Dec 2025 16:22:18 +0800

Vulkan接入光追管线

参考https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR 、 https://docs.vulkan.org/tutorial/latest/courses/18_Ray_tracing/02_Acceleration_structures.html

加速结构

在 Vulkan 中，用户创建的加速结构分为两个部分：底层加速结构（bottom level acceleration structure，BLAS） 和顶层加速结构（top level acceleration structure，TLAS）。

BLAS (Bottom-Level Acceleration Structure)

包含：各网格单元（三角形、顶点、索引）的实际几何数据。注：法线、UV及其他属性未存储于BLAS本身——需在着色器中单独访问。

每个Mesh对应一个BLAS

TLAS (Top-Level Acceleration Structure)

包含：对BLAS结构的引用及其世界空间变换（位置、旋转、缩放）

整个场景一个TLAS

示例：TLAS包含如下实例：“位于（1,0,1）位置的茶壶BLAS，旋转角度为45°，比例为2.0”

两层结构目的：TLAS存储BLAS的实例化信息，每个Mesh的BLAS只需要存储一次

RT过程

Ray Generation
射线与TLAS相交以确定可能被击中的实例
对于每个潜在命中，射线均经过转换并针对相应的BLAS进行测试
最近交点确定命中点与材质

Shader Binding Table (SBT)

着色器绑定表（SBT）是“蓝图”，它告诉光线追踪器在不同类型的光线交点上执行哪些着色器。与光栅化中着色器按顺序绑定不同，光线追踪需要所有着色器同时可用，因为光线可以随时击中任何表面。

Ray Generation Shaders: Entry point for each pixel’s primary ray
Miss Shaders: Executed when rays don’t hit any geometry (background/sky)
Hit Shaders: Executed when rays intersect with geometry (material shading)
Callable Shaders: Optional shaders that can be invoked from other shaders

也就是一个Shader池，Hit或者Miss时都可以从池中拿不同的Shader来执行

为什么需要SBT：在光线追踪中，单条光线可能击中场景中的任何物体，不同的物体可能需要不同的着色器（例如，不同的材质、透明度效果）

一些概念：

Shader Handles: 显然需要给池子中每个Shader一个唯一标识

SBT Regions：不同类型的Shader存储在不同的Regions

Instance Association：TLAS实例可通过hitGroupId字段指定所使用的命中着色器。

Data Attachment:着色器可附加自定义数据（材质属性、实例数据）至着色器句柄，应该就是给Shader

Shader

shader写起来思路很清晰，设计的很好

#version 460
#extension GL_EXT_ray_tracing : enable
#extension GL_ARB_separate_shader_objects : enable
#extension GL_GOOGLE_include_directive : enable
#include "../common/common.glsl"
// RayPayLoad是自定义的，定义layout时需要前缀rayPayloadEXT，任何需要的 Hit/ Miss/ ClosestHit 等 shader 会写回 payload
struct Payload {
    vec3 color;
};
#ifdef RAYGEN_SHADER
/*
	RayGenShader目的很简单，他是GPU与CPU交换的中间，负责定义payLoad，负责计算Ray的生成，就是从摄像机射向各个像素中心，整体来看就是一个工作组是二维，处理一张Image的ComputerShader
*/
// layout(set = 0, binding = 0) uniform accelerationStructureEXT topLevelAS;  这个已经在全局资源中

layout(set = 1, binding = 0, rgba32f) uniform image2D OUT_COLOR;  // 定义数据



layout(location = 0) rayPayloadEXT Payload payload ;   // 必须有rayPayloadEXT前缀

void main() 
{
	// 相当于一个自动的二维dipatch
	// gl_LaunchIDEXT.xy;   线程ID
	// gl_LaunchSizeEXT; 总线程数

	// 1. 计算屏幕坐标，并转到NDC坐标
	const vec2 pixelCenter = vec2(gl_LaunchIDEXT.xy) + vec2(0.5);  // 移动到像素中心
	const vec2 inUV = pixelCenter / vec2(gl_LaunchSizeEXT.xy);  // UV坐标
	vec2 ndc = inUV * 2.0 - 1.0; // 屏幕坐标转NDC[-1,1]
	// 2. Ray参数
	vec3 origin = CAMERAINFO.data.position;  // 相机位置
	vec4 target = CAMERAINFO.data.invProj * vec4(ndc.x, ndc.y, 0, 1) ; // 射线终点， 设置在像素NDC坐标，深度最近的位置  并转到View空间
	target /= target.w;   // 透视除法
	target = CAMERAINFO.data.invView * target;
	vec3 direction = normalize(target.xyz - origin.xyz);

	payload.color = vec3(0.0);


	traceRayEXT(TLAS, 					// acceleration structure
		gl_RayFlagsOpaqueEXT,       	// rayFlags 控制光线的行为，比如是否忽略背面、是否启用 any-hit、是否可用 conservative tracing 等
		0xFF,           				// cullMask 0xFF → 匹配所有实例
		0,              				// sbtRecordOffset 索引到 Shader Binding Table (SBT) 的起始记录位置
		1,              				// sbtRecordStride SBT 中每条记录的间隔（单位是记录数，不是字节）
		0,              				// missIndex 当光线没有击中任何几何体时，使用 SBT 中 miss shader 的索引
		origin.xyz,     				// ray origin
		MIN_RAY_TRACING_DISTANCE,           				// ray min range
		direction.xyz,  				// ray direction
		MAX_RAY_TRACING_DISTANCE,           				// ray max range
		0               				// payload (location = 0) payload的位置
  	);
    vec4 outColor = vec4(payload.color, 1.0);
	imageStore(OUT_COLOR, ivec2(gl_LaunchIDEXT.xy), outColor);
}

#endif

#ifdef RAYCLOSEST_HIT_SHADER
/*

	Hit是具体到Mesh的某一个三角形以及击中点，并且会给hitAttributeEXT来表示重心坐标，需要手动插值来计算击中点的信息
	gl_WorldRayTmaxEXT 可以获得击中的时间 t 
*/
layout(location = 0) rayPayloadInEXT Payload payload;    // rayPayloadInEXT 注意是InEXT

// Hit shader 可以访问击中的 geometry 信息
hitAttributeEXT vec2 attribs;   // 用来求重心坐标，表示击中点对于击中三角形的三个顶点的权重
void main()
{
	uint instanceID       = gl_InstanceCustomIndexEXT;   // 在构建TLAS时，给每个实例分配的ID
	uint primitiveID     = gl_PrimitiveID;  // 击中的三角形索引

	vec3 barycentrics = vec3(1.0 - attribs.x - attribs.y, attribs.x, attribs.y);   // 插值需要手动进行

	// 需要根据实例ID和三角形索引去Bindless找对应三个顶点的信息，再根据barycentrics进行插值


	// 根据插值后的结果计算着色信息
	MaterialInfo material   = GetMaterialInfo(instanceID);



	// 返回颜色
	payload.color = material.diffuse.xyz;

	// 或者继续递归
}
#endif

#ifdef RAYMISS_SHADER
/*
	MissShader是当Ray没有击中任何几何体时，会调用MissShader，MissShader可以返回一个颜色，或者继续递归
*/
layout(location = 0) rayPayloadInEXT Payload payload;    // rayPayloadInEXT 注意是InEXT

void main()
{
    payload.color = vec3(0.6, 0.8, 1.0);  // 也可以采样天空盒纹理
}
#endif

Cluster Based Lighting

Mon, 24 Nov 2025 11:14:58 +0800

Cluster Based Lighting

这里只介绍原理，实现篇放在游戏引擎开发实践（GPU-Driven）中

将相机视锥体分为若干簇，并为仅为每个簇分配若干有效的光源，可以避免大量无效的光照计算

在着色阶段的流程则比较简单。首先根据像素坐标计算像素所属 Cluster，然后遍历该 Cluster 的 “有效光源” 列表，逐一计算光照

分簇

ComputerShader中每个线程一个簇，XY上分簇，Z上进行切分，每个簇就对应XYZ

所以执行时就是 command->Dispatch( 1, 1, LIGHT_CLUSTER_DEPTH); LIGHT_CLUSTER_DEPTH就是Z坐标划分次数

在Shader中进行每个Group的在XY上进行划分。

#define THREAD_SIZE_X LIGHT_CLUSTER_WIDTH
#define THREAD_SIZE_Y LIGHT_CLUSTER_HEIGHT
#define THREAD_SIZE_Z 1
layout (local_size_x = THREAD_SIZE_X, local_size_y = THREAD_SIZE_Y, local_size_z = THREAD_SIZE_Z) in;

void main(){
    uvec3 gID = gl_GlobalInvocationID.xyz;   // 获得的就是每个簇的索引
}

接下来要找每个簇对应的视锥体范围的角点坐标

根据上边的信息可以屏幕空间上每个簇的角点UV，下面顺序是屏幕UV->NDC->View，最终目的是拿到每个簇在View下的每个角点的坐标（转到世界坐标计算也行）

求交光照剔除

在每个簇中遍历场景中的所有光源范围，如果光源范围覆盖到了这个簇的位置，就把这个光源的索引信息存储到这个簇的信息中，具体怎么存就看具体光源是怎么管理的了

求交可以简单的判断簇的角点在不在光源位置内，或者用簇做一个包围盒，用包围盒与光源的球形包围盒进行求交运算来判断该光源是否会影响当前簇

要学的太多

Mon, 24 Nov 2025 10:49:27 +0800

Pass

TODO

ClipmapPass: 是一个基于光线追踪（Ray Tracing）的体素化（Voxelization）渲染通道，它的核心任务是高效地为体素化全局光照（VXGI）系统构建和更新一个动态的、多层次的体素场景表示
ClusterLightingPass:光照剔除 （2025.11.24 拿捏原理、待整合）
DDGIPass：一点进度没有（2025.12.12 青春版完结，但是没做一些工程化的内容，比如ReLocation）
ExposurePass：自动曝光（2025.12.14 完成）
FXAA、TAA：抗锯齿得来点进度啊（2025.12.7 TAA完成）
GizmoPass：画在屏幕上的Debug信息不急(虽然不急但是很有意思，提前完成了 2025.11.30 完成)
GPUCullingPass：GPU-Driven管线(Working…….)（2025.12.18日完成视锥、阴影的Mesh剔除工作，遮挡剔除还没写）
PathTracingPass：啊，把这东西搬到实时管线么。。。，可能只是研究API怎么用（因为是分帧更新，所以不影响实时渲染管线的工作，2025.12.13 搭建PathTracing完成，但是应该是还有问题，有些像素会过曝）
ReprojectionPass：这个好像就是TAA用的motionVector的实现，待研究（2025.12.7 这东西因为除了TAA别的地方也会用到，所以单独拿出来了，我先自代码还是在TAA代码中）
ReSTIRDIPass：高效地计算场景中的直接光照（Direct Illumination），代替光照pass？
SSSR:更牛逼的SSR? 在 SSR 基础上引入随机采样（Stochastic Sampling）和时空域滤波（Temporal + Spatial Filtering），以低采样率实现高质量软反射
Surface CachePass：优化模型的Pass？
SVGFPass：在不模糊图像细节（如边缘、纹理）的前提下，高效地去除蒙特卡洛渲染中的噪声，应该是配合上边的ReSTIRDIPass
VolumetricFogPass：一直还没做过

Bindless

Fri, 21 Nov 2025 13:33:36 +0800

Bindless（Unbounded）无绑定或者无界绑定，是指不通过传统图形 API 的形如 glBindXXX 函数而直接将 Buffer\Texture 的 GPU 虚拟地址存储在 Bindless Buffer 中，在 Shader 中通过索引 Bindless 而直接访问 Texture\Buffer 数据的技术。Bindless 也是现代渲染技术如 GPU Driven Pipeline 不可或缺的基础组成部分

Bindless可以减少DrawCall

Vulkan创建DescriptorLayout时需要通过VkDescriptorSetLayoutBinding来表示每个绑定点的信息

typedef struct VkDescriptorSetLayoutBinding {
    uint32_t              binding;                // 绑定点编号（从 0 开始）
    VkDescriptorType      descriptorType;         // 描述符类型
    uint32_t              descriptorCount;        // 描述符数量（数组大小）
    VkShaderStageFlags    stageFlags;             // 着色器可见性阶段
    const VkSampler*      pImmutableSamplers;     //  immutable 采样器（可选）
} VkDescriptorSetLayoutBinding;

descriptorCount指定binding的资源描述符数量，也就是这个Binding可以存放多个相同类型的资源。在更新DescriptorSet时

VkWriteDescriptorSet writeDescriptorSet = {};
writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
writeDescriptorSet.dstSet = yourDescriptorSet; 
writeDescriptorSet.dstBinding = 0;           
writeDescriptorSet.dstArrayElement = 2; // 对应layout的descriptorCount的索引，在Shader中  用[descriptorCount]来设置一个资源数组
writeDescriptorSet.descriptorCount = 1;      
writeDescriptorSet.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
writeDescriptorSet.pImageInfo = &imageInfo;

所以在创建布局时，可以指定一个binding位置很大的descriptorCount，在Update时根据索引来更新，并且在Shader中写可以方便索引（当然需要传递索引到Shader）

这种静态的方式带来的问题是无法根据实际情况来决定资源数量，造成复杂的资源驻留管理以及 Descriptor 空间浪费。在从越大佬的文章中，这种方式被称为“有限”Bindless

真bindless其实就是靠Vulkan自己添加的新特性，支持Shader指定数组时不需要填入数量

RayTracingTheNextWeek

Sat, 15 Nov 2025 12:22:52 +0800

Motion Blur

思路是给Ray定义一个时间，表示光线的行进时间，判断光线与模型求交时，先用Ray的持续时间来计算模型在当前时间的位置，在新的位置上计算求交，因为发送的射线的时间是随机设置的，所有他们与球求交的是空间上不一致的，所以移动的物体就会出现模糊，本质也就是渲染时，不同像素收集到的是不同时间段的模型颜色，真实相机拍摄运动物体时，快门从打开到关闭的这段时间（比如 1/100 秒）内，物体一直在移动，传感器会记录下这段时间内物体在不同位置的所有光线信息，所以这种近似属于Hack

Bounding Volume Hierarchies

BVH_node 可以继承 : public hittable，与 sphere 的继承一样。相机遍历hittable_list时，会执行BVH_node本身的hit函数，函数内就有树形检索逻辑，加快击中判定

构建BVH的流程，是一个递归函数，用start和end表示要处理的objects范围，递归时，设置为原来的一半作为子节点

bvh_node(std::vector<shared_ptr<hittable>>& objects, size_t start, size_t end) {
    // 随机选择一个轴方向
    int axis = random_int(0,2);
    // 排序器
    auto comparator = (axis == 0) ? box_x_compare
                    : (axis == 1) ? box_y_compare
                                  : box_z_compare;

    size_t object_span = end - start;

    if (object_span == 1) { // 只有一个物体
        left = right = objects[start];
    } else if (object_span == 2) { // 有两个物体
        left = objects[start];
        right = objects[start+1];
    } else {
        // 在某个轴方向对objects进行排序
        std::sort(std::begin(objects) + start, std::begin(objects) + end, comparator);
        // 划分为两半
        auto mid = start + object_span/2;
        // 递归构建子节点
        left = make_shared<bvh_node>(objects, start, mid);
        right = make_shared<bvh_node>(objects, mid, end);
    }
	// 更新包围盒
    bbox = aabb(left->bounding_box(), right->bounding_box());
}

进一步优化，每次都选择最长的轴方向进行划分，因为物体在最长轴上的离散度最高，这样划分包围盒的重叠最少

bvh_node(std::vector<shared_ptr<hittable>>& objects, size_t start, size_t end) {
        // Build the bounding box of the span of source objects.
        bbox = aabb::empty;
        for (size_t object_index=start; object_index < end; object_index++)
            bbox = aabb(bbox, objects[object_index]->bounding_box());

        int axis = bbox.longest_axis();
        // 排序器
        auto comparator = (axis == 0) ? box_x_compare
                        : (axis == 1) ? box_y_compare
                                      : box_z_compare;

        size_t object_span = end - start;

        if (object_span == 1) { // 只有一个物体
            left = right = objects[start];
        } else if (object_span == 2) { // 有两个物体
            left = objects[start];
            right = objects[start+1];
        } else {
            // 在某个轴方向对objects进行排序
            std::sort(std::begin(objects) + start, std::begin(objects) + end, comparator);
            // 划分为两半
            auto mid = start + object_span/2;
            // 递归构建子节点
            left = make_shared<bvh_node>(objects, start, mid);
            right = make_shared<bvh_node>(objects, mid, end);
        }

        bbox = aabb(left->bounding_box(), right->bounding_box());
    }

纹理

生成球的UV

做法是3D坐标转为球面坐标，再转为UV坐标

3D坐标与球面坐标的转换

四边形

一个点Q+两个方向UV来定义一个四边形

求交运算

找到四边形对应的平面
光线与平面相交
确定交点在四边形内

四边形所在平面方程

定义平面：

法向量：

已知平面的法向量n，另外四边形的uv向量与法线n垂直（也就是说说u*v（叉乘）后的方向就是法线方向，这样就求出了ABC）

进一步，点Q落在平面上（已经知道ABC就是法向量的xyz，这样就可以通过带入法线和Q求解D，就求解了平面的方程）

光线与平面求交

点位置可以表示为光线P+td

求解D时，是用法线和点位置求解的，上一步已经求出D是多少了。现在反过来就可以求t

现在点位置用Ray表示后，求解D的方程表示为：

求解t得到光线相交于平面的时间

判定点是否在四边形内部

判断前需要在2D平面有一个基准坐标系，来表达任何点在平面上的位置

直接用Q点表示原点，UV向量来表示坐标系（不平行即可）

此时平面上任意一点可以表达为（$\alpha,\beta$）

突然用公式求解出（$\alpha,\beta$）的值

推导流程

求解出$（\alpha,\beta）$后，按下图判断点是否在四边形内部

发光材质

给材质一个发光函数，根据击中的位置，返回一个发光颜色。

class material {
  public:
    virtual ~material() = default;
    virtual color emitted(double u, double v, const point3& p) const {
        return color(0,0,0);   
    }

    virtual bool scatter(const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered) const {
        return false;
    }
};

击中物体计算颜色时，首先进行自发光判断，再进行scatter递归

color ray_color(const ray& r, int depth, const hittable& world) const {
    // If we've exceeded the ray bounce limit, no more light is gathered.
    if (depth <= 0)
        return color(0,0,0);
    hit_record rec;
    // If the ray hits nothing, return the background color.
    if (!world.hit(r, interval(0.001, infinity), rec))
        return background;
    ray scattered;
    color attenuation;
    color color_from_emission = rec.mat->emitted(rec.u, rec.v, rec.p);
    if (!rec.mat->scatter(r, rec, attenuation, scattered))
        return color_from_emission;
    color color_from_scatter = attenuation * ray_color(scattered, depth-1, world);
    return color_from_emission + color_from_scatter;
}

平移和旋转

这里介绍的平移旋转并不是对模型进行平移旋转，而是模拟光线与平移后的模型击中来计算着色，也就是说移动光线，达到平移物品的目的

平移变换 (Translation)

平移是最简单的变换。

目标：我们想让一个物体沿着向量 offset 移动。
方法

：
1. 变换光线：在判断光线 r 是否与平移后的物体相交时，我们先将光线 反向平移 offset 个单位，得到一条新的光线 offset_r。
2. 求交：用这条 offset_r 光线与原始位置的物体进行相交测试。
3. 逆变换交点：如果 offset_r 与原始物体相交于点 p，那么这个交点在世界空间中就位于 p + offset 的位置。我们将计算出的交点 rec.p 进行正向平移，得到最终的交点。

旋转变换 (Rotation)

旋转比平移复杂，因为它涉及到三角函数，并且还需要变换光线的方向向量和表面法向量。

目标：我们想让一个物体绕 Y 轴旋转 θ 角。
方法

：
1. 变换光线：在判断光线 r 是否与旋转后的物体相交时，我们先将光线的原点和方向都进行 反向旋转 -θ（即顺时针旋转 θ）。
2. 求交：用这条变换后的光线与原始朝向的物体进行相交测试。
3. 逆变换交点和法向量
  
  ：
  - 如果相交，得到的交点 p 和法向量 normal 是在物体的局部空间中的。
  - 我们需要将它们正向旋转 θ（逆时针旋转 θ），变换回世界空间，作为最终的结果。

初识UE源码（RHI、渲染机制、RDG）

Thu, 13 Nov 2025 20:22:40 +0800

初次简单了解一下UE的代码长什么样子，参考视频https://www.bilibili.com/video/BV1VK411x7bH?spm_id_from=333.788.videopod.sections&vd_source=9df9034e2f1978b1018f5b387ec3eacd

向下

FRHIResource

/** The base type of RHI resources. */

const ERHIResourceType ResourceType; // 说明了那些被认为是RHI资源
enum ERHIResourceType : uint8
{
	RRT_None,

	RRT_SamplerState,
	RRT_RasterizerState,
	RRT_DepthStencilState,
	RRT_BlendState,
	RRT_VertexDeclaration,
	RRT_VertexShader,
	RRT_MeshShader,
	RRT_AmplificationShader,
	RRT_PixelShader,
	RRT_GeometryShader,
	RRT_RayTracingShader,
	RRT_ComputeShader,
	RRT_GraphicsPipelineState,
	RRT_ComputePipelineState,
	RRT_RayTracingPipelineState,
	RRT_BoundShaderState,
	RRT_UniformBufferLayout,
	RRT_UniformBuffer,
	RRT_Buffer,
	RRT_Texture,
	// @todo: texture type unification - remove these
	RRT_Texture2D,
	RRT_Texture2DArray,
	RRT_Texture3D,
	RRT_TextureCube,
	// @todo: texture type unification - remove these
	RRT_TextureReference,
	RRT_TimestampCalibrationQuery,
	RRT_GPUFence,
	RRT_RenderQuery,
	RRT_RenderQueryPool,
	RRT_Viewport,
	RRT_UnorderedAccessView,
	RRT_ShaderResourceView,
	RRT_RayTracingAccelerationStructure,
	RRT_RayTracingShaderBindingTable,
	RRT_StagingBuffer,
	RRT_CustomPresent,
	RRT_ShaderLibrary,
	RRT_PipelineBinaryLibrary,
	RRT_ShaderBundle,
	RRT_WorkGraphShader,
	RRT_WorkGraphPipelineState,
	RRT_StreamSourceSlot,
	RRT_ResourceCollection,

	RRT_Num
};

ERHIResourceType 枚举包含的资源类型可归纳为以下大类：

渲染状态资源（管线状态配置类）
着色器及相关资源（各类着色器程序与绑定布局类）
缓冲与数据存储资源（数据载体及布局描述类）
纹理及纹理访问资源（图像数据及访问接口类）
光线追踪专用资源（光线追踪加速与绑定类）
查询与同步资源（GPU/CPU 交互及数据查询类）
其他辅助资源（视口、自定义呈现、资源集合等）

这里的每个实现都用子类实现

class FRHIUniformBuffer : public FRHIResource
#if ENABLE_RHI_VALIDATION
	, public RHIValidation::FUniformBufferResource
#endif
{
public:
	FRHIUniformBuffer() = delete;
    ...
}

再进一步就到了具体API的子类

class FVulkanUniformBuffer : public FRHIUniformBuffer
{
public:
	FVulkanUniformBuffer(FVulkanDevice& Device, const FRHIUniformBufferLayout* InLayout, const void* Contents, EUniformBufferUsage InUsage, EUniformBufferValidation Validation);
	virtual ~FVulkanUniformBuffer();
	...
}

其他资源都一样的继承思路

这套架构已经简单实现

FDynamicRHI

类似创建操作(上下文无关操作)是在FDynamicRHI，上下文有关的操作（也就是在固定生命周期内执行的操作）是在IRHICommandContext

一些图形渲染场景的操作API都定义在这里，创建shader、更新纹理等等

/** The interface which is implemented by the dynamically bound RHI. */
class FDynamicRHI
{
public:
	using FRHICalcTextureSizeResult = ::FRHICalcTextureSizeResult;

	/** Declare a virtual destructor, so the dynamic RHI can be deleted without knowing its type. */
	RHI_API virtual ~FDynamicRHI();

	/** Initializes the RHI; separate from IDynamicRHIModule::CreateRHI so that GDynamicRHI is set when it is called. */
	virtual void Init() = 0;

	/** Called after the RHI is initialized; before the render thread is started. */
	virtual void PostInit() {}

	/** Shutdown the RHI; handle shutdown and resource destruction before the RHI's actual destructor is called (so that all resources of the RHI are still available for shutdown). */
	virtual void Shutdown() = 0;

	virtual const TCHAR* GetName() = 0;

	virtual ERHIInterfaceType GetInterfaceType() const { return ERHIInterfaceType::Hidden; }
	virtual FDynamicRHI* GetNonValidationRHI() { return this; }

	/** Called after PostInit to initialize the pixel format info, which is needed for some commands default implementations */
	void InitPixelFormatInfo(const TArray<uint32>& PixelFormatBlockBytesIn)
	{
		PixelFormatBlockBytes = PixelFormatBlockBytesIn;
	}

	/////// RHI Methods

	RHI_API virtual void RHIEndFrame_RenderThread(FRHICommandListImmediate& RHICmdList);

	struct FRHIEndFrameArgs
	{
		// Increments once per call to RHIEndFrame
		uint32 FrameNumber;

#if WITH_RHI_BREADCRUMBS
		const TRHIPipelineArray<FRHIBreadcrumbNode*>& GPUBreadcrumbs;
#endif
	};
	virtual void RHIEndFrame(const FRHIEndFrameArgs& Args) = 0;

	// FlushType: Thread safe
	virtual FSamplerStateRHIRef RHICreateSamplerState(const FSamplerStateInitializerRHI& Initializer) = 0;

	// FlushType: Thread safe
	virtual FRasterizerStateRHIRef RHICreateRasterizerState(const FRasterizerStateInitializerRHI& Initializer) = 0;

	// FlushType: Thread safe
	virtual FDepthStencilStateRHIRef RHICreateDepthStencilState(const FDepthStencilStateInitializerRHI& Initializer) = 0;

	// FlushType: Thread safe
	virtual FBlendStateRHIRef RHICreateBlendState(const FBlendStateInitializerRHI& Initializer) = 0;

	// FlushType: Wait RHI Thread
	virtual FVertexDeclarationRHIRef RHICreateVertexDeclaration(const FVertexDeclarationElementList& Elements) = 0;

	// FlushType: Wait RHI Thread
	virtual FPixelShaderRHIRef RHICreatePixelShader(TArrayView<const uint8> Code, const FSHAHash& Hash) = 0;

	// FlushType: Wait RHI Thread
	virtual FVertexShaderRHIRef RHICreateVertexShader(TArrayView<const uint8> Code, const FSHAHash& Hash) = 0;

	// FlushType: Wait RHI Thread
	virtual FGeometryShaderRHIRef RHICreateGeometryShader(TArrayView<const uint8> Code, const FSHAHash& Hash) = 0;

	// FlushType: Wait RHI Thread
	virtual FMeshShaderRHIRef RHICreateMeshShader(TArrayView<const uint8> Code, const FSHAHash& Hash)
      
    ...
}

封装了渲染所需的核心资源创建与管理逻辑，包括：

缓冲（顶点缓冲、索引缓冲、常量缓冲等）的创建 / 更新 / 销毁；
纹理（2D 纹理、立方体贴图等）的加载 / 格式转换 / 内存管理；
渲染管线状态（着色器、混合状态、深度测试等）的配置与绑定；
绘制命令（Draw Call）的提交与执行。

IRHICommandContext

定义上下文相关的操作，比如RHIDispatchComputeShader，这明显需要在Pass中间调用。RHIDrawPrimitive``RHIDrawPrimitiveIndirect``RHIDrawIndexedIndirect这些，内部都是虚函数，由具体平台实现

/** The interface RHI command context. Sometimes the RHI handles these. On platforms that can processes command lists in parallel, it is a separate object. */
class IRHICommandContext : public IRHIComputeContext
{
public:
	virtual ~IRHICommandContext()
	{
	}

	virtual ERHIPipeline GetPipeline() const override
	{
		return ERHIPipeline::Graphics;
	}

	virtual void RHIDispatchComputeShader(uint32 ThreadGroupCountX, uint32 ThreadGroupCountY, uint32 ThreadGroupCountZ) = 0;
	...
}

进入API层，类内部都会有一个用于定义当前上下文的对象，比如FVulkanCommandListContext,在执行上边那些命令时，会使用Manager来获得当前激活的commandBuffer来记录命令

	class FVulkanCommandListContext : public IRHICommandContext{
        ...
    private:
        ...
        FVulkanCommandBufferManager* CommandBufferManager;
        ...
    }

当创建一个IRHICommandContext时，在Vulkan中就是创建一个新的CommandBuffer

1
2
3

// Create CommandBufferManager, contain all active buffers
CommandBufferManager = new FVulkanCommandBufferManager(InDevice, this);
CommandBufferManager->Init(this);

向上

FRHICommand

UE的命令是用链表串起来的

struct FRHICommandBase
{
	FRHICommandBase* Next = nullptr;  // 命令是链表连起来的
	virtual void ExecuteAndDestruct(FRHICommandListBase& CmdList) = 0; // 具体执行方法
};

// 封装了lambda来执行命令
template <typename RHICmdListType, typename LAMBDA>
struct TRHILambdaCommand final : public FRHICommandBase
{
	LAMBDA Lambda;
#if CPUPROFILERTRACE_ENABLED
	const TCHAR* Name;
#endif

	TRHILambdaCommand(LAMBDA&& InLambda, const TCHAR* InName)
		: Lambda(Forward<LAMBDA>(InLambda))
#if CPUPROFILERTRACE_ENABLED
		, Name(InName)
#endif
	{}

	void ExecuteAndDestruct(FRHICommandListBase& CmdList) override final
	{
		TRACE_CPUPROFILER_EVENT_SCOPE_TEXT_ON_CHANNEL(Name, RHICommandsChannel);
		Lambda(*static_cast<RHICmdListType*>(&CmdList));
		Lambda.~LAMBDA();
	}
};

FRHICommand继承Base后只添加了一个函数（调用命令）

template<typename TCmd, typename NameType = FUnnamedRhiCommand>
struct FRHICommand : public FRHICommandBase
{
	void ExecuteAndDestruct(FRHICommandListBase& CmdList) override final
	{
		LLM_SCOPE_BYNAME(TEXT("RHIMisc/CommandList/ExecuteAndDestruct"));
		TRACE_CPUPROFILER_EVENT_SCOPE_ON_CHANNEL_STR(NameType::TStr(), RHICommandsChannel);

		TCmd* ThisCmd = static_cast<TCmd*>(this);
		ThisCmd->Execute(CmdList);   // 调用命令
		ThisCmd->~TCmd(); // 释放命令
	}
};

再下一层就是各种具体命令比如FRHICommandSetShaderParameters、FRHICommandSetViewport等等，每个具体命令都有一个Execute方法

void FRHICommandDrawPrimitive::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(DrawPrimitive);
	INTERNAL_DECORATOR(RHIDrawPrimitive)(BaseVertexIndex, NumPrimitives, NumInstances);
}

void FRHICommandDrawIndexedPrimitive::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(DrawIndexedPrimitive);
	INTERNAL_DECORATOR(RHIDrawIndexedPrimitive)(IndexBuffer, BaseVertexIndex, FirstInstance, NumVertices, StartIndex, NumPrimitives, NumInstances);
}

void FRHICommandSetBlendFactor::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetBlendFactor);
	INTERNAL_DECORATOR(RHISetBlendFactor)(BlendFactor);
}

void FRHICommandSetStreamSource::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetStreamSource);
	INTERNAL_DECORATOR(RHISetStreamSource)(StreamIndex, VertexBuffer, Offset);
}

void FRHICommandSetViewport::Execute(FRHICommandListBase& CmdList)
{
	RHISTAT(SetViewport);
	INTERNAL_DECORATOR(RHISetViewport)(MinX, MinY, MinZ, MaxX, MaxY, MaxZ);
}

再下面就是各个API具体的实现了

FRHICommandList

它内部的函数也是这种API，根据情况Bypass()选择直接调用API还是把命令缓存起来

FORCEINLINE_DEBUGGABLE void DrawPrimitive(uint32 BaseVertexIndex, uint32 NumPrimitives, uint32 NumInstances)
{
	//check(IsOutsideRenderPass());
	if (Bypass())
	{
		GetContext().RHIDrawPrimitive(BaseVertexIndex, NumPrimitives, NumInstances);
		return;
	}
	ALLOC_COMMAND(FRHICommandDrawPrimitive)(BaseVertexIndex, NumPrimitives, NumInstances);
}

主要看两个指针

class FRHICommandListBase{
    protected:
	FRHICommandBase*    Root            = nullptr;  // 命令链表的起始
	FRHICommandBase**   CommandLink     = nullptr; // 命令结束的位置，用于添加新命令
}

// 新建一个命令的流程
FORCEINLINE_DEBUGGABLE void* AllocCommand(int32 AllocSize, int32 Alignment)
{
    checkSlow(!IsExecuting());
    checkfSlow(!Bypass(), TEXT("Invalid attempt to record commands in bypass mode."));
    FRHICommandBase* Result = (FRHICommandBase*) MemManager.Alloc(AllocSize, Alignment);  // 内存中申请空间
    ++NumCommands;
    *CommandLink = Result; 
    CommandLink = &Result->Next;  // 其实就是链表添加一个尾结点的操作
    return Result;
}

Base下一层FRHIComputeCommandList

`1`	`class FRHIComputeCommandList : public FRHICommandListBase{}`

再下一层才是FRHICommandList。听了UE的RHI介绍视频，我觉得这样设计是因为渲染Queue可以进行渲染命令也可以是计算命令（我现在自己的项目的ComputeShader都是放在渲染Queue中进行的）。是有包含关系的。

`1`	`class FRHICommandList : public FRHIComputeCommandList`

再下一层是立即模式

`1`	`class FRHICommandListImmediate : public FRHICommandList`

再进到API层面还有封装

Mesh的DrawCall流程

数据流转：

FPrimitiveSceneProxy->FMeshBatch->FMeshDrawCommand->RHICommandList->GPU

FMeshDrawCommand

存储渲染一个Mesh的具体信息，粒度是DrawCall级别的了，上层的收集工作目的就是生成各种FMeshDrawCommand，FMeshDrawCommand进一步才转化成RHI层指令（CommandList）

class FMeshDrawCommand
{
public:
	
	/**
	 * Resource bindings
	 */
	FMeshDrawShaderBindings ShaderBindings;  // 着色器顶点输入信息
	FVertexInputStreamArray VertexStreams; // 顶点数据
	FRHIBuffer* IndexBuffer; // 索引数据
    
	/**
	 * PSO
	 */
	FGraphicsMinimalPipelineStateId CachedPipelineId; // PSO
    
     /**
	 * Draw command parameters    三角形相关信息
	 */
	uint32 FirstIndex;
	uint32 NumPrimitives;
	uint32 NumInstances;   // 实例数量，这也就是说DrawCommand对应的是一个SubMesh的所有实例

    /** Submits commands to the RHI Commandlist to draw the MeshDrawCommand. */
    /** 提交这个DrawCall到CommandList **/
static bool SubmitDraw(
	const FMeshDrawCommand& RESTRICT MeshDrawCommand,
	const FGraphicsMinimalPipelineStateSet& GraphicsMinimalPipelineStateSet,
	const FMeshDrawCommandSceneArgs& SceneArgs,
	uint32 InstanceFactor,
	FRHICommandList& CommandList,
	class FMeshDrawCommandStateCache& RESTRICT StateCache);
 .....   
}

SubmitDraw主要是一个Begin和一个End组成

// SubmitDraw的实现
bool FMeshDrawCommand::SubmitDraw(
	const FMeshDrawCommand& RESTRICT MeshDrawCommand,
	const FGraphicsMinimalPipelineStateSet& GraphicsMinimalPipelineStateSet,
	const FMeshDrawCommandSceneArgs& SceneArgs,
	uint32 InstanceFactor,
	FRHICommandList& RHICmdList,
	FMeshDrawCommandStateCache& RESTRICT StateCache)
{
#if WANTS_DRAW_MESH_EVENTS
	RHI_BREADCRUMB_EVENT_CONDITIONAL(RHICmdList, GShowMaterialDrawEvents != 0, "%s %s (%u instances)"
		, MeshDrawCommand.DebugData.MaterialRenderProxy->GetMaterialName()
		, MeshDrawCommand.DebugData.ResourceName
		, MeshDrawCommand.NumInstances * InstanceFactor
	);
#endif

	bool bAllowSkipDrawCommand = true;
	if (SubmitDrawBegin(MeshDrawCommand, GraphicsMinimalPipelineStateSet, SceneArgs, InstanceFactor, RHICmdList, StateCache, bAllowSkipDrawCommand))
	{
		SubmitDrawEnd(MeshDrawCommand, SceneArgs, InstanceFactor, RHICmdList);
		return true;
	}

	return false;
}
// Begin 调用RHI设置各种参数
bool FMeshDrawCommand::SubmitDrawBegin(
	const FMeshDrawCommand& RESTRICT MeshDrawCommand, 
	const FGraphicsMinimalPipelineStateSet& GraphicsMinimalPipelineStateSet,
	const FMeshDrawCommandSceneArgs& SceneArgs,
	uint32 InstanceFactor,
	FRHICommandList& RHICmdList,
	FMeshDrawCommandStateCache& RESTRICT StateCache,
	bool bAllowSkipDrawCommand)
{
    // 1. PipeLineState的设置，下到RHI层
    RHICmdList.SetGraphicsPipelineState(PipelineState, Initializer.BoundShaderState, StencilRef, bApplyAdditionalState);
	.....
}

// End中主要就是调用RHI的DrawIndexedPrimitive（上层是把对应的Command存储的RHICommandList而已）
void FMeshDrawCommand::SubmitDrawEnd(const FMeshDrawCommand& MeshDrawCommand, const FMeshDrawCommandSceneArgs& SceneArgs, uint32 InstanceFactor, FRHICommandList& RHICmdList)
{
    .....
	if (MeshDrawCommand.IndexBuffer)
	{
		if (MeshDrawCommand.NumPrimitives > 0 && !bDoOverrideArgs)
		{
			RHICmdList.DrawIndexedPrimitive(
				MeshDrawCommand.IndexBuffer,
				MeshDrawCommand.VertexParams.BaseVertexIndex,
				0,
				MeshDrawCommand.VertexParams.NumVertices,
				MeshDrawCommand.FirstIndex,
				MeshDrawCommand.NumPrimitives,
				MeshDrawCommand.NumInstances * InstanceFactor
			);
		}
	.....
}

FMeshBatch

比如相同材质、相同xxx的一组模型放在一个Batch，一个Batch有一组FMeshBatchElement，FmeshBatch由FSceneRenderer的Gatherxxx这个函数来收集，这个函数有一个参数是

MeshDrawCommand里没有材质信息，材质信息来自MeshBatch

FMeshPassProcessor

上层收集组装成FMeshBatch，通过FMeshPassProcessor的BuildMeshDrawCommands来构建FMeshDrawCommand（有历史原因，4.22之前是没有FMeshDrawCommand的）

// 代码里这个For可以看出来，Batch的每个element都变成了一个FMeshDrawCommand
for (int32 BatchElementIndex = 0; BatchElementIndex < NumElements; BatchElementIndex++)
{
	if ((1ull << BatchElementIndex) & BatchElementMask)
	{
		const FMeshBatchElement& BatchElement = MeshBatch.Elements[BatchElementIndex];
		FMeshDrawCommand& MeshDrawCommand = DrawListContext->AddCommand(SharedMeshDrawCommand, NumElements);

RDG

FRDGResource

RDG层面也封装了一层Resource，其内部就是FRHIResource

/** Generic graph resource. */
class FRDGResource
{
    .....
private:
	FRHIResource* ResourceRHI = nullptr;
	.....
};

FRDGTexture继承来自FRDGResource。但是在RDG层的Resource不能自己创建，必须统一经过RDGBuilder来创建

/** A render graph resource with an allocation lifetime tracked by the graph. May have child resources which reference it (e.g. views). */
class FRDGViewableResource
	: public FRDGResource
{
/** Render graph tracked Texture. */
class FRDGTexture final
	: public FRDGViewableResource
{....}

FRDGPass

把一个Pass的渲染指令进行存储

FRDGBuilder

比如贴图的创建需要RDGBuilder的CreateTexture来创建

`1`	`RENDERCORE_API FRDGTextureRef CreateTexture(const FRDGTextureDesc& Desc, const TCHAR* Name, ERDGTextureFlags Flags = ERDGTextureFlags::None);`

对于已经存在的资源，也需要通过RDGBuilder进行注册，生命周期不经过RDG管理

** Registers a external pooled render target texture to be tracked by the render graph. The name of the registered RDG texture is pulled from the pooled render target. */
RENDERCORE_API FRDGTextureRef RegisterExternalTexture(
    const TRefCountPtr<IPooledRenderTarget>& ExternalPooledTexture,
    ERDGTextureFlags Flags = ERDGTextureFlags::None);

一个Pass需要输出的资源需要经过Extraction来输出

	/** Queues a pooled render target extraction to happen at the end of graph execution. For graph-created textures, this extends
	 *  the lifetime of the GPU resource until execution, at which point the pointer is filled. If specified, the texture is transitioned
	 *  to the AccessFinal state, or kDefaultAccessFinal otherwise.
	 */
	RENDERCORE_API void QueueTextureExtraction(FRDGTextureRef Texture, TRefCountPtr<IPooledRenderTarget>* OutPooledTexturePtr, ERDGResourceExtractionFlags Flags = ERDGResourceExtractionFlags::None);
	RENDERCORE_API void QueueTextureExtraction(FRDGTextureRef Texture, TRefCountPtr<IPooledRenderTarget>* OutPooledTexturePtr, ERHIAccess AccessFinal, ERDGResourceExtractionFlags Flags = ERDGResourceExtractionFlags::None);

上面三种情况就定义了资源在一个Pass的创建、输入、输出设置

添加一个Pass到RDG，ExecuteLambda就是存储具体的渲染流程

template <typename ParameterStructType, typename ExecuteLambdaType>
FRDGPassRef AddPass(FRDGEventName&& Name, const ParameterStructType* ParameterStruct, ERDGPassFlags Flags, ExecuteLambdaType&& ExecuteLambda){
    // 创建一个Pass对象
    FRDGDispatchPass* Pass = Allocators.Root.AllocNoDestruct<DispatchPassType>(
	Forward<FRDGEventName&&>(Name),
	ParametersMetadata,
	ParameterStruct,
	OverridePassFlags(NameString, Flags),
	Forward<LaunchLambdaType&&>(LaunchLambda));

	IF_RDG_ENABLE_DEBUG(ClobberPassOutputs(Pass));
    // 存储Pass数组  	FRDGPassRegistry Passes;
	Passes.Insert(Pass);
    
    
    // 设置Pass的资源	
	SetupParameterPass(Pass);

}

// 收集Passzi
FRDGPass* FRDGBuilder::SetupParameterPass(FRDGPass* Pass)
{
	IF_RDG_ENABLE_DEBUG(UserValidation.ValidateAddPass(Pass, AuxiliaryPasses.IsActive()));
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE_CONDITIONAL(RDGBuilder_SetupPass, GRDGVerboseCSVStats != 0);

#if RDG_EVENTS
	TOptional<TRDGEventScopeGuard<FRDGScope_RHI>> PassNameScope;
	if (ScopeState.ScopeMode == ERDGScopeMode::AllEventsAndPassNames)
	{
		FRDGEventName Name = Pass->GetEventName();
		PassNameScope.Emplace(*this, ERDGScopeFlags::None, FRHIBreadcrumbData(__FILE__, __LINE__, TStatId(), NAME_None), MoveTemp(Name));
	}
#endif

	SetupPassInternals(Pass);

	if (ParallelSetup.bEnabled)
	{
		MarkResourcesAsProduced(Pass);
		AsyncSetupQueue.Push(FAsyncSetupOp::SetupPassResources(Pass));
	}
	else
	{
		SetupPassResources(Pass);
	}

	SetupAuxiliaryPasses(Pass);
	return Pass;
}

RayTracingOneWeek

Wed, 12 Nov 2025 13:26:10 +0800

Ray-Sphere Intersection

显式：“谁等于谁的函数”。
隐式：“变量们满足某个共同等式”

球公式用向量形式表达为：

$$ (\mathbf{C} - \mathbf{P}) \cdot (\mathbf{C} - \mathbf{P}) = (C_x - x)^2 + (C_y - y)^2 + (C_z - z)^2 $$

也就是

$$ (\mathbf{C} - \mathbf{P}) \cdot (\mathbf{C} - \mathbf{P}) = r^2 $$

给一个点P(t)，如果与圆相加，说明这个公式有解

$$ (\mathbf{C} - \mathbf{P}(t)) \cdot (\mathbf{C} - \mathbf{P}(t)) = r^2 $$

P(t)可以用Ray来表示，Ray = Q + td

经过一系列变换，最后用求根公式可以直接算出t的取值，或者用判别式直接获取解的个数

// 判断r是否与这个球体相交
bool hit_sphere(const point3& center, double radius, const ray& r) {
    auto a = dot(r.direction(),r.direction());

    auto b = -2*dot(r.direction(),center-r.origin());

    auto c = dot(center-r.origin(),center-r.origin()) - radius * radius;

    auto discriminant = b*b - 4 *a *c;
    return discriminant > 0;
}

1
2
3

if(hit_sphere(point3(0,0,-1),0.2,r)){
    return color(1,0,0);
}

// 返回t
double hit_sphere(const point3& center, double radius, const ray& r) {
    vec3 oc = center - r.origin();
    auto a = dot(r.direction(), r.direction());
    auto b = -2.0 * dot(r.direction(), oc);
    auto c = dot(oc, oc) - radius*radius;
    auto discriminant = b*b - 4*a*c;
     if (discriminant < 0) {
        return -1.0;
    } else {
        return (-b - std::sqrt(discriminant) ) / (2.0*a);
    }
}

Simplifying Code

求根公式中，把原始b带入发现可以化简

抗锯齿

像素中心击中物体就是一种颜色，没有击中就是另一种颜色，没有过度，锯齿就会出现。（对一个像素进行着色，一条光线只取一个点的颜色，但是一个像素对应世界位置的一片颜色不一定是一样的，而是连续的）

初始采样点为像素中心，每个像素多次调用git_ray(),他会在一个像素中随机进行采样

    vec3 sample_square() const {
        // Returns the vector to a random point in the [-.5,-.5]-[+.5,+.5] unit square.
        return vec3(random_double() - 0.5, random_double() - 0.5, 0);
    }
    ray get_ray(int i, int j) const {
        // Construct a camera ray originating from the origin and directed at randomly sampled
        // point around the pixel location i, j.

        auto offset = sample_square();
        auto pixel_sample = pixel00_loc
                          + ((i + offset.x()) * pixel_delta_u)
                          + ((j + offset.y()) * pixel_delta_v);

        auto ray_origin = center;
        auto ray_direction = pixel_sample - ray_origin;

        return ray(ray_origin, ray_direction);
    }

漫反射材质

hit后，不是直接返回颜色，而是继续发射一根随机半球方向的光线继续进行光线追踪，击中物体后累加，另外需要设置递归深度防止无限递归

        if (world.hit(r, interval(0, infinity), rec)) {
            vec3 direction = random_on_hemisphere(rec.normal);
            return 0.5 * ray_color(ray(rec.p, direction), depth-1, world);
        }

Fixing Shadow Acne

如果光线起点恰好位于表面正下方（浮点数的舍入误差），它可能会再次与该表面相交。

镜面反射

v+2B就是静面反射向量，B可以通过dot(v,n)*n来求

1
2
3

inline vec3 reflect(const vec3& v, const vec3& n) {
    return v - 2*dot(v,n)*n;
}

RT实现这种间接光照太容易了

电介质材质（折射）

当从折射率高的一边看向折射率低的一边，如果入射角度过大，用反射定律计算出来的折射光线角度超过了90°，这时候就应该只进行反射，而不进行折射。（教程有折射相关的内容，本质就是把反射替换成折射来进行二次弹射）

Defocus Blur 景深/散焦模糊

成像平面的距离改用焦距来定义，所以在成像平面位置的渲染才是清晰的

// 根据fov和Near计算视口宽高
auto theta = degrees_to_radians(vfov);
auto h = std::tan(theta/2);
auto viewport_height = 2 * h * focus_dist;
auto viewport_width = viewport_height * (double(image_width)/image_height);

// 构建光线时，先在像素内部随机采样，获得一个摄像终点，但是射线起点不再是相机的位置，而是以相机位置为中心的一个圆盘（可调整半径）上的任意一点作为摄像起点
ray get_ray(int i, int j) const {
    // Construct a camera ray originating from the defocus disk and directed at a randomly
    // sampled point around the pixel location i, j.

    auto offset = sample_square();
    auto pixel_sample = pixel00_loc
                      + ((i + offset.x()) * pixel_delta_u)
                      + ((j + offset.y()) * pixel_delta_v);

    auto ray_origin = (defocus_angle <= 0) ? center : defocus_disk_sample();
    auto ray_direction = pixel_sample - ray_origin;

    return ray(ray_origin, ray_direction);
}

int main() {
    hittable_list world;

    auto ground_material = make_shared<lambertian>(color(0.5, 0.5, 0.5));
    world.add(make_shared<sphere>(point3(0,-1000,0), 1000, ground_material));

    for (int a = -11; a < 11; a++) {
        for (int b = -11; b < 11; b++) {
            auto choose_mat = random_double();
            point3 center(a + 0.9*random_double(), 0.2, b + 0.9*random_double());

            if ((center - point3(4, 0.2, 0)).length() > 0.9) {
                shared_ptr<material> sphere_material;

                if (choose_mat < 0.8) {
                    // diffuse
                    auto albedo = color::random() * color::random();
                    sphere_material = make_shared<lambertian>(albedo);
                    world.add(make_shared<sphere>(center, 0.2, sphere_material));
                } else if (choose_mat < 0.95) {
                    // metal
                    auto albedo = color::random(0.5, 1);
                    auto fuzz = random_double(0, 0.5);
                    sphere_material = make_shared<metal>(albedo, fuzz);
                    world.add(make_shared<sphere>(center, 0.2, sphere_material));
                } else {
                    // glass
                    sphere_material = make_shared<dielectric>(1.5);
                    world.add(make_shared<sphere>(center, 0.2, sphere_material));
                }
            }
        }
    }

    auto material1 = make_shared<dielectric>(1.5);
    world.add(make_shared<sphere>(point3(0, 1, 0), 1.0, material1));

    auto material2 = make_shared<lambertian>(color(0.4, 0.2, 0.1));
    world.add(make_shared<sphere>(point3(-4, 1, 0), 1.0, material2));

    auto material3 = make_shared<metal>(color(0.7, 0.6, 0.5), 0.0);
    world.add(make_shared<sphere>(point3(4, 1, 0), 1.0, material3));

    camera cam;

    cam.aspect_ratio      = 16.0 / 9.0;
    cam.image_width       = 1200;
    cam.samples_per_pixel = 500;
    cam.max_depth         = 50;

    cam.vfov     = 20;
    cam.lookfrom = point3(13,2,3);
    cam.lookat   = point3(0,0,0);
    cam.vup      = vec3(0,1,0);

    cam.defocus_angle = 0.6;
    cam.focus_dist    = 10.0;

    cam.render(world);
}

每个像素采样500次，并且深度为50的结果

博客日记（记录看大佬博客的一些思考）

Tue, 11 Nov 2025 13:43:46 +0800

API差异图

2025.12.16

https://zhuanlan.zhihu.com/p/582237962 全局光照浅析

现实中的反射大部分情况下并不是mirror reflections也不是diffuse reflections，而是介于两者之间，这种反射叫做glossy reflections，对应的材质也叫做glossy 。这下把这些名词都对应上了~

Caustics焦散在图形学中的定义是指光线经过高光物体的反射或折射，然后弹射到漫反射表面，再弹射到眼睛的效果，如上图中书下面阴影中高亮的部分。Caustics很难实现，即便在离线渲染中使用path tracing也很难实现，通常会借助Photon Mapping光子映射技术来实现Caustics。 第一次接触这个词！

下图可以看到在书下面的阴影中也有很亮的地方，叫做焦散

下面是几种离线渲染的全局光照方案

Whitted-Style Ray Tracing

从视点发射光线。
光线碰撞到物体表面，如果表面材质是diffuse材质则光线停止传播，否则沿着反射方向继续传播。
每个碰撞点都需要发射一条shadow ray做遮挡查询。
shading point需要累加所有碰撞点的Irradiance，作为最终的光照结果。

Whitted-Style Ray Tracing算法无法实现右边的glossy reflection效果，因为光线是按照镜面反射的方式传播的，真实世界大部分物体都不是mirror materail。

原来 Mirror和Glossy是要区分的。另外Games101讲的Whitted-Style Ray Tracing原来就是丐版的pathTracing，因为只进行镜面反射，所以没法实现glossy的反射

因为漫反射不递归，所以漫反射全局光照效果肯定是没有的

Distributed Ray Tracing

基本思路和Whitted-Style Ray Tracing一样，只是为了解决漫反射光线传播，在每一个碰撞点上的半球空间都会发射多条光线来模拟漫反射。

算法的缺点非常明显就是计算量爆炸，这个算法即便是离线渲染也是不能接受的，不过这个算法应该是最朴素也是效果最好的光线追踪算法，说不定以后硬件性能爆炸，这个算法也有回春的一天。

Path Tracing

这个算法的最大问题是光线命中光源的概率很低，因此会有很多噪点。

通过加大光源面积和投射光线的数量可以缓解这个问题。另外可以把每个碰撞点的光照分为直接光照和间接光照，直接光照从光源中进行采样以保证命中概率，并且直接光照会做shadow ray，而间接光照还是使用上面的算法，这样噪点仅存在于间接光照的部分

Bidirectional Path Tracing

这里能看出PathTracing的缺点：如果场景主要是间接光照照亮的，那PathTracing效果就会很差

有的时候光源的环境很复杂，使用上面的Path Tracing依然会获得很低的光源命中率，如下图：

现实中这种情形，照亮场景的应该是间接光照，而间接光照的命中率又很低，所以上面的算法不太适用这种场景

双向路径跟踪算法（Bidirectional Path Tracing，BDPT）在路径跟踪算法的基础之上，额外从光源出发创建光路，再连接从照相机追溯的光路和从光源出发的光路上的点，创建多条光路，并根据光线从这些光路传播的概率，合并各个光路传递的辐射亮度，即进行所谓的多重重要性抽样（multiple importance sampling），计算光线最后进入照相机生成图像的光照结果，如下图：

光子映射Photon Mapping

Path Tracing算法最大的问题就是光路命中光源的概率太低，即便是使用大量的SPP也会产生很多高频的噪点。另外在光线传播的过程中光路都是随机生成的，Caustics这种需要先弹射到镜面然后再弹射到漫反射物体的命中概率就更低了，因此Path Tracing很难模拟Caustics效果。

光子映射的基本算法分成两个Pass。

Pass1-光源从随机方向发射光子，并在一切表面上弹射，如果弹射的表面是diffuse材质则记录光子信息包括光子的POS，光子的能量POWER，光子的入射方向Dir，可以把这些光子理解成为次级光源，使用俄罗斯轮盘算法结束光子的递归弹射，这样可以保证能量守恒。这些光子信息与视点无关，所以可以保存起来供后续pass使用，这也是空间换时间的算法。
Pass2-从相机射出的光线，打到非diffuse材质表面进行反射或折射，打到diffuse材质表面则根据收集半径检索附近的光子进行间接光照计算。

下面是实时渲染的全局光照解决方案

Light Probe(Irradiance Volume)

light probe就是在空间中摆放很多的probe，这些probe可以当成次级光源，在离线的时候将irradiance保存到probe中，通常使用球鞋函数来缓存光照信息。

这样空间中的每个点都可以找到离它最近的四个probe，这四个probe可以构成一个四面体，然后计算四面体的重心位置，通过重心位置和坐标点进行差值来计算最终的光照信息，如下图：

DDGI其实就是Irradiance Volume的实时版本，它利用实时光线追踪来计算probe信息，而Irradiance Volume是离线计算的，从这点上来说DDGI是完全支持动态光源的算法，但是它依赖可以做实时光线追踪的硬件或者是使用Ray Marching。另外DDGI使用了切比雪夫不等式来预测probe是否被遮挡，减缓漏光问题。DDGI的核心是优化Irradiance volume的更新

漏光的原因是采样到了实际上被遮挡的探针，DDGI使用切比雪夫不等式原来就是用来预测Probe是否被遮挡

下面还介绍了LPV、VXGI，这个等实现时再看

GIBS

GIBS与VXGI不同之处是VXGI将场景的物体表面离散成了voxel，而GIBS将场景表面离散成了surfel。描述一个surfel的基本数据结构是位置，法线和半径，这就定义了一个2D的圆形表面

PRT

PRT就是将光照方程进行拆解，然后用球谐函数记录每个部分，利用球谐函数的性质还原光照方程，因为light transport部分包含场景的遮挡关系且这部分是预计算的所以PRT只支持静态场景动态光源。

SSGI

ssgi是基于屏幕空间的全局光照算法，利用深度信息进行Ray Marching，效率不如SDF，但是不需要额外的存储空间，因为是基于屏幕空间的光照算法，所以缺少屏幕外的光照信息。

Lumen

ue5的lumen主要是实现了一套软光线追踪算法，其中涉及的内容几乎包括了上面所有介绍的实时全局光照算法，会单独写一篇文章介绍，这里就不详细介绍了。

总结一下实时全局光照算法，基本分为三个步骤：

离散化场景空间或物体表面，probe，voxel，surfel，均匀网格，还有一个lumen的mesh card后面介绍。
计算Irradiance cache。
利用Irradiance cache还原光照方程。

另外有一个东西是 SDF实现的raymarch不太了解

2025.11.21 丛越

https://zhuanlan.zhihu.com/p/73016473

看了人家的管线设计才发现自己费那么多劲琢磨架构是多么的无知，当前阶段还是多输入少输出吧

原来Buffer还能这么复用（在不同时段通过别名资源重用内存）

GPU驱动管线（下一步学习计划！）

Vulkan的内存模型

Vulkan 的内存分为 Host 和 Device 两大类，下图可以看到哪些是Device可见的，哪些是Host可见的

并行 Command

尽管从 API 层面来看 Command 是依次录制的，但 GPU 在执行时是将 Queue 中的指令同时分发给 GPU 多核中的 Pipeline 执行，这就是 GPU 的并行计算机制。而这种并行，是不会保证执行的顺序，所以对于提交到 GPU 执行的 Command，需要了解以下几个事实：

Command 在 Command Buffer 中顺序并不代表在 GPU 内部执行的顺序。
提交到同一 Command Queue 中不同 Command Buffer 的顺序并不代表在 GPU 内部执行的顺序。
不同 Command Queue 的提交顺序不代表在 GPU 内部执行的顺序。

Pipeline Barrier

TODO： https://zhuanlan.zhihu.com/p/100162469

下面图片的每个块表示一个Pipeline Stage

2025.11.11 SaeruHikari

GBuffer压缩

Gbuffer是可以压缩的(https://zhuanlan.zhihu.com/p/95824400)。

GBuffer会带来显卡的带宽压力, 所以现在的游戏一般会把GBuffer压缩到2~3张。比如把法线压缩到2通道并在使用时进行Decode, 或者不保存PosW到GBuffer, 而是在使用时使用深度重建。可以参照顽皮狗在Sig16分享的方案:

不同的BRDF方案

可以学习并实践一下不同的BRDF方案，而不是就还是Lambert + Cook-Torrance

Diffuse

首先看漫反射部分, 目前比较流行的公式有这些可选:

Lambert
Burley(Disney)[sig2012]
Renormalized Disney Diffuse[sig2014]
PBR diffuse for GGX_Smith[GDC 2017]
MultiScattering Diffuse BRDF[sig2018]

在五个模型都尝试一遍过后选择了RenormalizedDisneyDiffuse。

这里特别要提一句的是MultiScattering版本的diffuse BRDF, 在今年的sig也有对它实现的补充以及改进分享。但是实测之后发现效果并不好, 因为多散射对diffuse的影响实在太小, 这个模型并不能带来太多可见的改善。

而Frostbite在14年sig[3]提出的Renormalized Disney Diffuse是带来观感改善较大的一个:

Moving Frostbite To PBRwww.ea.com/frostbite/news/moving-frostbite-to-pb

它主要对Burley模型进行了改进, 根据视角入射角对Diffuse进行补正来维持能量守恒, 在视角移动时产生的视觉效果更加细腻(当然光源太复杂就没那么明显了…)。

Specular

接下来来到BRDF里最重要, 组装起来也最好玩的Specular BRDF项:

(Cook-Torrance)

D(h): 法线分布函数, 描述微面元法线分布的概率, 具有正确朝向，能够将来自l的光反射到v的表面点的相对于表面面积的浓度。
F(l,h) : 菲涅尔方程, 描述不同的表面角下表面所反射的光线所占的比率。
G(l,v,h) : 几何函数/几何遮蔽，描述微平面自成阴影的属性，即m = h的未被遮蔽的表面点的百分比。
**分母 4(n·l)(n·v）：**校正因子，作为微观几何的局部空间和整个宏观表面的局部空间之间变换的微平面量的校正。

这里不再细致解释, 列出常用的模型, 这些模型在UE4几乎都有实现, 可以到BRDF.ush去参考(抄):

Specular D:

Blinn-Phong[1977]
GGX/GTR[2007/2012] (GGX(GTR2)作为GTR的特例)
以及各种各向异性版本…

SpecularF

Cook-Torrance[1982]
Schlick[1994] (一般选用这个, 便宜且曲线非常贴紧参考值)

SpecularG

Cook-Torrance[1982]
Smith[1967] (被拓展为l, v的联合遮蔽函数, 具有多种变体)

TAA

一直没管过引擎的走样问题。。。待学习完善

RGD

https://zhuanlan.zhihu.com/p/97022384 这里有RGD的实现思路，学习RGD可以参考

反射

https://link.zhihu.com/?target=https%3A//github.com/rttrorg/rttr ， SaeruHikari用的这个反射

多线程渲染?

博客提到的多线程是指多个queue，和我现在实现不一样啊

2025.11.12

匿名资源、临时资源

这个东西我的项目有进行规整，所有资源都做了保存（应该：无名未注册的资源会被保持在一个池内, 并由系统进行自动化的复用。）

RDG

蓝色表示PassNode, 白色圆角表示ResourceNode, 实际资源存储在Container中。

纹理、Buffer、Pass创建都是走的RDG

RDG需要处理多帧资源比如TAA

Home on wanfeng

游戏引擎开发实践（空间加速结构）

基础理论

均匀网格划分

四叉树/八叉树

松散八叉树

线性八叉树

Morton Code

BSP树

K-d Tree

BVH

BVH的SAH（表面积启发式的结点划分方法）

八叉树实践

BVH + SAH实践(TODO)

CPU（自顶向下）

GPU(自底向上，线性BVH)

游戏引擎开发实践（FXAA TODO）

边缘检测

基于亮度的混合系数计算

计算混合方向与混合

更准确的混合系数

游戏引擎开发实践（基础架构）

渲染架构

RHI

RDG

多线程渲染

渲染资源管理

Mesh渲染架构（Bindless + 间接渲染 ）

序列化

基础功能

摄像机系统

游戏引擎开发实践（切比雪夫不等式的应用）

VSM

游戏引擎开发实践（降噪算法 SVGF）

降噪算法

高斯滤波器

双边滤波

联合双边滤波

大滤波器优化

拆分2个Pass

小波变换卷积\空洞卷积 À-Trous wavelet

处理过亮像素

SVGF （Spatiotemporal Variance-Guided Filter）时空方差引导滤波

RAE

SVGF实践

Demodulate Albedo

Reconstruction Filter

PBRT（Reflection Models）

BXDF框架

BSDF

BRDF

Hemispherical–Directional Reflectance（半球–方向反射率）

hemispherical–hemispherical reflectance（半球–半球反射率）

BTDF

BSSRDF

基础理论

材料种类

电介质（Dielectrics）

导体（Conductors）

半导体（Semiconductors）

反射定律

折射定律

菲涅耳方程

常见BXDF

完美模型

Diffuse Reflection（完美漫反射）

Conductor BRDF（完美反射）

Dielectric BSDF（完美反射+完美折射）

Thin Dielectric BSDF（薄电介质，比如玻璃（跳过））

Non-Symmetric Scattering and Refraction（跳过）

粗糙模型

PBRT（Monte Carlo Integration）

蒙特卡洛积分

概率论Review

The Monte Carlo Estimator

Error in Monte Carlo Estimators 蒙特卡洛积分的误差

Improving Efficiency 提升效率

Stratified Sampling 分层采样

Importance Sampling 重要性采样

Multiple Importance Sampling 多重重要性采样

Mesh渲染架构（Bindless + 间接渲染）