游戏引擎 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）

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}$对深度做变换，将多峰分布拉成单峰，压缩方差

改完之后确实有效果

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

游戏引擎开发实践（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剔除和灯光分簇

游戏引擎开发实践（资源描述符管理）

Mon, 10 Nov 2025 11:03:46 +0800

这里涉及的整套结构已经废弃，转为研究更轻薄的RHI层，放弃过度封装！

资源描述符管理日志

目标：在创建Pass时，设置好Input的绑定资源，渲染时无需再设置

每个shader每个Set一个资源描述符，读取Shader时自动创建（问题1：一个不一定够）
Resize问题（Resize后图片被销毁）（解决1：在渲染时判断是否被销毁，重新获取）
一个Pass需要多个描述符（绑定图片的不同layer/mip层的VkImageView）（解决1：创建Pass时，提交额外需要的资源描述符数量）（Hazel的解决方案：额外使用的资源描述符集被定义为材质，每次DrawCall切换材质）（Dark的解决方案: pushDescriptorSetKHR渲染时实时创建并推送，这样很方便但是不好整合）

弃坑，整个架构都放弃了