样本方差只是一个估计值，大量的工作都是为了降噪，MC渲染自适应采样和重建的最新进展。总体思路：在附近像素处加入样本方差，可能根据辅助特征（位置、法线等）的接近程度进行加权。高方差是个诅咒，一旦引入了一个高方差样本，就会有大麻烦了，例如考虑对数据进行均匀采样：

6个样本：(1, 1, 1, 1, 1, 100 ) ≈ 17.5，再取6个样本：(1, 1, 1, 1, 1, 100, 1, 1, 1, 1, 1, 1 ) ≈ 9.25，回想一下，方差随样本数呈线性下降…面对这种高方差样本，最hack但也最有效的方式是clamp，如下图所示：

更复杂的选择是基于密度的异常值剔除，保存所有样本，分析并过滤异常值。根据亮度将样本分成几个单独的图像，然后根据统计分析重新加权。

光线追踪从离线到实时的几个重要方面：

• 明智地选择光线。采用蒙地卡罗积分法、方差、重要性采样、多重重要性采样。
• 仔细选择你的（非）随机数。域扭曲、准随机序列、低差异、分层。
• 把你的射线预算花在最有用的地方。自适应采样。
• 理解并防止错误。强度夹紧、路径正则化。

蒙特卡罗快速回顾：

准蒙特卡罗（QMC）：确定性、低差异序列/集合（Halton、Hammersley、Larcher-Pillichshammer）比随机的收敛速度更好，例如Sobol或（0-2）序列不需要知道样本数量，奇妙的分层特性。

下图中有一个大面积的光在倾斜，漫反射地面上。相机正前方是一片薄玻璃片，折射率为1（因此完全透射）。这将是一个相当常见的场景的调试版本，其中场景的大部分（如果不是全部的话）都在一个窗口后面。

因为对光线有一个固定的分裂因子，索引也很容易追踪：对于每个光采样计算，可以使用样本i到i+3。如果每个照明位置都与对应位置非常不同，就像康奈尔盒子的情况一样，不会有太大的区别（但考虑到属性或我们的顺序，至少会同样好）。然而，如果位置更相似（甚至完全相同）。。。

在地面上使用64个相机直接可见的光源样本。

下图是一个稍微不同的场景，使采样预算更容易测试。场景中的薄玻璃片更粗糙，为了更好地欣赏这种粗糙的效果，对地面进行纹理处理。

若使用之前一样的采样方式，由粗糙玻璃产生的BSDF射线的相干度当然不如以前，由此获得了下图那样更加毛躁的图像：

由此遇到了一个像素之间相关性很差的情况，4D序列中的一些维度在一个像素内的相关性很差。为此，需要查看4D点的不同2D投影，遵循Jarosz等人在正交阵列论文中使用的可视化约定：可以在轴上看到对应于每个维度的索引，在数组的每个单元格中，将显示相应的2D切片，是尺寸（0,1）和（2,3）的2D切片，是在采样例程中使用的切片，它们其实是一样的。

现在看看下图的“诊断”切片，（0,3）和（1,2）也是相同的。剩下的（0,2）和（1,3）相当于（0,0）和（1,1）。。。

实际上，需要使用高纬度的Sobol序列。有许多可能的Sobol序列，[Grünschlo?]和[Joe 2008]的Sobol序列优化了低维2D投影的分层特性，用于低样本数量：

虽然样本数量少，但任何维度配对都会产生非常好的结果！在之前的各种填充尝试中，我们注意到的问题已经消失了。

如果上升维度，可以找到质量明显最差的2D切片，以确保对被积函数的最重要部分使用最低维度：

额外的改进包括将Owen指令应用于所有维度，它有助于打破序列特征的对齐模式，并提高收敛速度。由于不是一个快速的过程（特别是对于实时），可以预计算并存储大量样本，这也是HDRP中的操作，256D中有256个点。

锦上添花的做法是增加屏幕空间的蓝色噪点：

白噪点和蓝噪点的对比：

当进入高维时，同时考虑所有维度，避免考虑递归的低维积分（即使这样开始更自然）。实时（预计算）选择序列是一种低差异采样器，将蒙特卡罗方差作为蓝色噪声分布在屏幕空间[Heitz 2019]，渐进式多抖动样本序列[Christensen 2018]。近期在高维集合方面值得注意的工作是蒙特卡罗渲染的正交数组采样[Jarosz 2019]，实时路径跟追踪的未来是实时重构光照传输[Wyman 2020]。

T-ReX: Interactive Global Illumination ofMassive Models on HeterogeneousComputing Resources也提到了利用混合渲染管线的思路，即CPU用几何表达来计算包含完整细节的直接光，而GPU用稀疏体素八叉树为结构的体积表达来计算近似的间接光（下图）。其中直接光和非直接光存在数据转换和传输，而几何表达和体素表达没有。

下图则分别显示了原始网格、近似体积、用原始网格和近似体积计算而得的光照效果（黄色圈表示用体积计算的间接光）。

该文将光线分为C-Ray和G-Ray。其中C-Ray（下图蓝色）对几何细节更敏感，用于生成高频视觉效果，一次光线和在完美镜面材质上反射的二次光线。

而G-Ray（下图深紫色和橙黄色）对几何细节不太敏感，用于生成低频视觉效果，除C-Ray以外的任何射线（例如收集射线、阴影射线）

在数据结构方面，CPU使用HCCMesh，而GPU使用ASVO：

HCCMesh是用来处理C-Ray的高质量几何结构，随机可访问压缩（压缩比7:1~20:1），支持高性能解压缩。

而ASVO是增强稀疏体素八叉树（Augmented SparseVoxel Octree），是G-Ray的GPU侧体积表示，在GPU中高效遍历，近似几何&光子映射。ASVO可以提高分辨率，保存遮挡位图，用作LOD表示——可表示材质、逐节点上的法线。

ASVO采用两级结构：顶层ASVO始终加载在GPU内存上（如300MB），底层ASVO按需异步加载，以进行渐进渲染。采用遮挡位图前后的对比如下：

整体渲染流程如下：

1、GPU侧利用体素追踪光子，将光子信息存储到ASVO中。

2、CPU侧利用HCCMesh追踪C-Ray，完成后（只是博主推测）同步到GPU侧。

3、GPU侧利用体素追踪G-Ray，将结果存储到光子信息中。

4、GPU侧利用ASVO的两级结构中的光子信息着色，生成最终的光照结果。

此方法提出了一种用于大规模模型全局照明的集成渐进渲染框架，使用解耦表示——CPU中的HCCMeshes和GPU中的ASVOs，用于处理大规模模型，降低昂贵的传输成本，实现CPU和GPU的高利用率。限制是体积表示法存在偏倚和不一致，跨越的空间大于其几何模型。

Scalable Real time Global Illumination for Large Scenes讲述了用于大规模场景的可扩展的实时GI解决方案。其解决方案是场景的体素表示（如体素圆锥体追踪），相机周围的初始体素化照明场景尽可能好，尽可能快，如碰撞几何、实体的较低LOD、高度图数据，来自屏幕GBuffer的反馈体素化灯光场景，可见光辐照度volmap（体积图）部分地在每一帧重新计算，使用真实的强力光线投射（无光）。

辐照度图：将辐照度存储在相机周围的嵌套体积贴图中（3d clipmap），每个级联为约64x32x64，单元格大小为\(0.45m \cdot 3^i\)（或在低端设备上为\(0.9m \cdot 3^i\)，i是级联索引），选择了HL2环境立方体基，正交基，但GPU对样本非常友好，可以很容易地更改为其它基。

基本场景参数化：将场景存储在相机周围的嵌套体积贴图（3d clipmap）中，每个级联为128x64x128，单元大小为\(0.25m \cdot 3^i\)（或在低端设备上为\(0.5m \cdot 3^i\)，i是级联索引），要么存储完全照明的结果，要么存储两个体积纹理中的照明+反照率。

Sponza场景参数化：

初始场景填充：当相机移动时，“以环形方式”填充新的体素（类似于纹理包裹），用高度贴图数据和碰撞几何体（顶点着色）或实体的低级LOD填充新的体素，然后立即用太阳光、间接光辐照度和该区域最重要的光照亮这个新的体素。

场景反馈循环：在中等设置下，场景不断更新，随机选择32k GBuffer像素，对于每个随机选择的GBuffer像素，使用它的反照率、法线和位置以及直接光和间接辐照度贴图来照亮它，使用移动平均更新这个新的发光颜色的体素化场景表示。这提供了反馈循环，因为使用重照明GBuffer像素更新场景体素，使用当前辐照度体积图更新它们，并用当前场景体素更新辐照度体积图。它不仅提供多次反弹，还解决了体素化问题（墙比2个体素薄，精度高），此外，环境探针（在渲染时）提供了“主”摄像头无法捕捉到的更多数据。

辐照度贴图初始化：当摄像机移动时，我们填充新的纹理(探针），对于更精细的级联，从更粗糙的级联复制数据，对于“场景相交”和最粗糙的级联贴图，追踪64条光线以获得更好的初始近似，用magic（“不是真正计算的”）值来标记它们的时间收敛权重，所以一旦它们变得可见，它们就会被重新激活。

辐照度图-计算循环：在辐照度体积图中随机选择几百个可见的“探针”（位置），选择的概率取决于“探测”的可见性和探测的收敛因子（上次变化的程度），对于选定的“探针”，在场景中投射1024到2048条光线（取决于设置），用移动平均法累积结果。

辐照度图-计算队列：为了快速收敛，在辐照度图中为不同的“探针”设置不同的队列非常重要，第一次看到，从未计算过要尽快计算，即使质量较低。使用256条射线，但队列中有4096个探针，不相交的场景探针不参与光照传输，但仍然需要为动态对象、体积测量和粒子计算它们。使用1024条射线，队列大小只有64到128个探针。

初始化光照-鸡和蛋问题：当摄像机传送时，它周围的所有级联都是无效的，所以不能用辐照度（第二次反弹）来照亮初始场景，也不能计算没有初始场景的初始辐照度。分两次完成：体素化场景，仅使用直射光照亮，计算天光和第二次反弹的辐照度，然后重新缩放场景，很少发生（剪影）。

使用辐照度贴图进行渲染：选择最好的级联，根据法线符号，从六个辐照度体积贴图纹理中抽取三个进行采样（请参见HL2 Ambient Cube）。在边界上，将其与下一个级联混合，延迟通道和向前通道（以及体积光照）也一样。

另外，使用凸面偏移过滤来解决光照泄漏：

对于室内的过暗问题，添加“孔/窗”体积（永远不会用体素填充）来解决：

总之，此法产生的GI具有多次反弹的一致间接照明，可调质量，从低端PC到超高端硬件支持，但不影响游戏性，可扩展的细节大小，以及光线追踪质量。动态的（在某种程度上），炸毁一堵墙，摧毁一栋建筑，光照可以照进，建造围墙产生反射和间接阴影，快速迭代。

17.4 图形API和GPU

本章将阐述目前市面上的几种流行图形API对光线追踪支持的现状和技术。

17.4.1 DirectX RayTracing（DXR）

DirectX RayTracing（DXR）是DirectX 12引入的用以支持硬件光线追踪的图形API特性集。在最高级别，DXR为DirectX 12 API引入了四个新概念：

• 加速结构是一个对象，它以最适合GPU遍历的格式表示全3D环境。表示为两级层次结构，该结构提供了GPU的优化光线遍历，以及应用程序对动态对象的有效修改。
• DispatchRays是一种新的命令列表方法，是将光线追踪到场景中的起点，也是游戏将DXR工作负载提交给GPU的方式。
• 光线追踪管线状态是当今图形和计算管线状态对象的精神伴侣，它封装了光线追踪着色器和与光线追踪工作负载相关的其他状态。
• 一组新的HLSL着色器类型，包括光线生成、最近命中、任何命中和未命中着色器。它们指定了DXR工作负载在计算上实际执行的操作。调用DispatchRays时，将运行光线生成着色器。使用HLSL中新的TraceRay内部函数，光线生成着色器将光线追踪到场景中。根据光线在场景中的位置，可以在交叉点调用多个命中或未命中着色器中的一个，以允许游戏为每个对象指定其自己的着色器和纹理集，从而产生唯一的材质。

光线追踪在GPU内部的处理流程图。

在DX12的全新图形API中，加入了可编程的光线追踪渲染管线（上图）。和传统光栅化管线一样，光线追踪的管线有固定的逻辑，也有可编程的部分。新管线中新增了5种着色器（Shader），分别是：

• Ray Generation：用于生成射线。在此shader中可以调用TraceRay()递归追踪光线。所有光线追踪工作的起点，从Host启动的线程的简单二维网格，追踪光线，写入最终输出。
• Intersection：当TraceRay()内检测到光线与物体相交时，会调用此shaderr，以便使用者检测此相交的物体是否特殊的图元（球体、细分表面或其它图元类型）。使用应用程序定义的图元计算光线交点，内置光线三角形交点。
• Any Hit：当TraceRay()内检测到光线与物体相交时，会调用此shader，以便使用者检测此相交的物体是否特殊的图元（球体、细分表面或其它图元类型）。在找到交点后调用，以任意顺序调用多个交点。
• Closest Hit和Miss：当TraceRay()遍历完整个场景后，会根据光线相交与否调用这两个Shader。Cloesit Hit可以执行像素着色处理，如材质、纹理查找、光照计算等。Cloesit Hit和Miss都可以继续递归调用TraceRay()。Closest Hit在光线的最近交点上调用，可以读取属性和追踪光线以修改有效载荷。Miss如果未找到并接受命中，则调用，可以追踪射线并修改射线有效载荷。

下面是以上部分shader的应用示例，以便更好说明它们的用途：

// 追踪光线时使用的数据负载，可自定义需要的数据。
struct Payload
{
    float4 color;
    float  hitDistance;
};

// 追踪的加速结构，表示了场景的几何体。
RaytracingAccelerationStructure scene : register(t5);

[shader("raygeneration")]
void RayGenMain()
{
    // 获取已调度二维工作项网格内的位置（通常映射到像素，因此可以表示像素坐标）。
    uint2 launchIndex = DispatchRaysIndex();

    // 定义一条射线，由原点、方向和间隔t组成。
    RayDesc ray;
    ray.Origin = SceneConstants.cameraPosition.
    ray.Direction = computeRayDirection( launchIndex ); // 计算光线方向（非内建函数，实现忽略）
    ray.TMin = 0;
    ray.TMax = 100000;

    Payload payload;

    // 使用我们定义的有效载荷类型追踪射线，由此触发的着色器必须在相同的有效负载类型上运行。
    TraceRay( scene, 0 /*flags*/, 0xFF /*mask*/, 0 /*hit group offset*/,
              1 /*hit group index multiplier*/, 0 /*miss shader index*/, ray, payload );

    outputTexture[launchIndex.xy] = payload.color;
}

// 属性包含命中信息，并由相交着色器填充。对于内置三角形相交着色器，属性始终由命中点的重心坐标组成。
struct Attributes
{
    float2 barys;
};

[shader("closesthit")]
void ClosestHitMain( inout Payload payload, in Attributes attr )
{
    // 读取相交属性并将结果写入有效负载。
    payload.color = float4( attr.barys.x, attr.barys.y, 1 - attr.barys.x - attr.barys.y, 1 );

    // 演示一个新的HLSL指令：沿当前光线的查询距离。
    payload.hitDistance = RayTCurrent();
}

AnyHit和ClosetHit运行机制和区别示意图：

射线可以附带有效载荷——亦即应用程序定义的结构，用于在生成光线的命中阶段和着色器阶段之间传递数据，用于将最终交点信息返回到光线生成着色器：

射线还可以有属性——应用程序定义的结构，用于将交点信息从交集着色器传递到命中着色器：

DXR被设计为允许实现独立地处理射线，包括各种类型的着色器，它们只能看到单条输入光线，不能看到或依赖运行中的其他光线的处理顺序。某些着色器类型可以在给定调用过程中生成多条光线（如果需要），可以查看光线处理的结果。无论如何，运行中生成的光线永远不会相互依赖。这种光线独立性打开了平行性的可能性。为了在执行期间利用这一点，典型的实现将在调度和其他任务之间进行平衡。

执行的调度部分是硬连接的（hard-wired），或者至少以可针对硬件定制的不透明方式实现。通常会使用排序工作等策略，以最大化线程之间的一致性，从API的角度来看，光线调度是内置功能。

光线追踪中的其他任务是固定功能和完全或部分可编程工作的组合，其中最大的固定功能任务是遍历由应用程序提供的几何结构构建的加速结构，目的是有效地找到潜在的射线交点，固定函数也支持三角形相交。着色器可编程性体现在生成射线、确定隐式几何图形的交点（与“固定函数三角形交点”选项相反）、处理光线交点（如曲面着色）或未命中。该应用程序还可以高度控制在任何给定情况下从着色器池中运行哪些着色器，以及每个着色器调用可以访问的纹理等资源的灵活性。

下图展示了硬件光线追踪体系涉及的概念、加速结构、内存布局以及运行机制：

上图中涉及到加速结构（Acceleration Structure），其作用是保存场景的所有几何物体信息，在GPU内提供物体遍历、相交测试、光线构造等等的极限加速算法，使得光线追踪达到实时渲染级别，可以在应用程序通过BuildRaytracingAccelerationStructure()接口构建。

如上图，对于场景中的每个几何体，在GPU内部都存在两个级别的加速结构：

• 底层加速结构（Bottom-Level Acceleration Structure，BLAS）从输入的图元信息构建而成，如三角形、四边形。
• 顶层加速结构（Top-Level Acceleration Structure，TLAS）从底层加速结构创建而来，相当于是底层加速结构的实例，保存了底层结构的变换矩阵和shader偏移。

应用程序可以通过BuildRaytracingAccelerationStructure()中的D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS标记使得加速结构变成可更新的，或更新可更新的加速结构。在光线追踪性能方面，可更新加速结构（在更新之前和之后）不会像从头构建静态加速结构那样最佳，然而更新将比从头构建加速结构更快。

Shader绑定表（Shader Binding Table，SBT）描述了shader与场景的哪个物体关联，也包含了shader中涉及的所有资源（纹理、buffer、常量等）。

在GPU底层，Shader映射表是一个等尺寸的记录体（record），每个记录体关联着带着一组资源的shader（或相交组，Hit group）。通常每个几何体存在一个记录体。

由上图可见，每个记录体由shader编号起始，随后存着CBV、UAV、常量、描述表等shader资源。这种双层架构的好处是将资源和实例化分离，加速实例创建和初始化，降低带宽和显存占用。

SBT针对典型光线追踪器的命中组记录布局，具有两种光线类型，渲染具有两个实例的场景，其中一个实例具有两种几何体。结合下图举个例子，每个命中组记录为32字节，步长为64字节。当追踪光线时，\(R_{stride}=2\)，并且\(R_{offset}\)对于主光线为0，对于遮挡光线为1。

更详细深入的SBT机制参见：The RTX Shader Binding Table Three Ways。

DXR的TraceRay运行流程如下：

上图中：

[1] 此阶段搜索加速结构，以枚举可能与射线相交的图元，保守地：如果图元与射线相交且在当前射线范围内，则保证最终将枚举。如果基本体未与光线相交或在当前光线范围之外，则可以枚举或不枚举该基本体。请注意，提交命中时会更新TMax。

[2] 如果交集着色器正在运行并调用ReportHit()，则后续逻辑将处理交集，然后通过[5]返回交集着色器。

[3] 不透明度是通过检查交点的几何图形和实例标志以及光线标志来确定的。此外，如果没有任何命中着色器，几何体将被视为不透明。

[4] 如果设置了RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH光线标志，或者设置了名为AcceptHitAndEndSearch()的任何命中着色器，将中止在AcceptHitandSearch()调用点执行任何命中着色器。由于至少提交了此命中，因此迄今为止最接近的命中都会在其上运行最近的命中着色器（并且未通过RAY_FLAG_SKIP_CLOSEST_HIT_SHADER禁用）。

[5] 如果相交的图元不是三角形，则相交着色器仍处于活动状态并继续执行，因为它可能包含对ReportHit()的更多调用。

DXR还支持内联管线追踪模式，调用TraceRayInline()执行，是TraceRay()的变体，它的运行流程图如下：

DXIL库和状态对象示例：

PIX作为Microsoft的老牌且强大的图形调试软件，在DXR发布之初就支持了对它的调试。利用PIX可方便调试各类调用栈、渲染状态及资源等信息。

使用DXR的步骤如下：

• 第一步是构建加速结构，它在两级层次结构中运行。在结构的底层，应用程序指定了一组几何图形，基本上是顶点和索引缓冲区，表示世界上不同的对象。在结构的顶层，应用程序指定了一个实例描述列表，其中包含对特定几何体的引用，以及一些附加的每个实例数据，如变换矩阵，这些数据可以以类似于当前游戏执行动态对象更新的方式逐帧更新。它们一起允许有效地遍历多个复杂几何图形。

两个几何体的实例，每个几何体都有自己的变换矩阵。

• 第二步是创建光线追踪管线状态。如今大多数游戏为了提高效率而将它们的绘制调用批处理在一起，例如首先渲染所有金属对象，然后渲染所有塑料对象。但由于无法准确预测特定光线将击中的材质，因此光线追踪不可能进行这样的批处理。相反，光线追踪管线状态允许指定多组光线追踪着色器和纹理资源。例如，与对象A的任何光线交点都应使用着色器P和纹理X，而与对象B的交点应使用着色器Q和纹理Y，使得应用程序可以让光线交点使用它们所击中的材质的正确纹理运行正确的着色器代码。
• 第三步是调用DispatchRays，它调用光线生成着色器。在该着色器中，应用程序调用TraceRay内在函数，触发加速结构的遍历，并最终执行适当的命中或未命中着色器。此外，还可以从命中和未命中着色器中调用TraceRay，允许光线递归或多重反弹效果。

? 场景中光线递归的说明

注意，由于光线追踪管线省略了图形管线的许多固定功能单元，如输入汇编程序和输出合并器，因此由应用程序指定如何解释几何体。为着色器提供了执行此操作所需的最小属性集，即基本体中交点的重心坐标。最终，这种灵活性是DXR的一大优势，允许多种技术，而不需要强制要求特定格式或构造。

所有与光线追踪相关的GPU工作都通过应用程序调度的命令列表和队列进行调度。因此，光线追踪与其他工作（如光栅化或计算）紧密集成，并且可以通过多线程应用程序有效地排队。光线追踪着色器作为工作项网格进行调度，类似于计算着色器，允许实现利用GPU的大规模并行处理吞吐量，并根据给定硬件的情况执行工作项的低级别调度。

应用程序保留在必要时显式同步GPU工作和资源的责任，就像光栅化和计算一样，允许开发人员优化光线追踪、光栅化、计算工作和内存传输之间的最大重叠量。光线追踪和其他调度类型共享所有资源，如纹理、缓冲区和常量，从光线追踪着色器访问资源不需要转换、复制或映射。保存光线追踪特定数据的资源，如加速结构和着色器表，以及内存分配或传输不会隐式发生，着色器编译是显式的，完全受应用程序控制。着色器可以单独编译，也可以成批编译，如果需要，可以跨多个CPU线程并行编译。

17.4.2 Vulkan RayTracing

Vulkan光线追踪和DirectX相似，包含新增的Shader类型、加速结构等。

Vulkan的两层加速结构示意图。

Vulkan光线追踪的shader流程。

此外，Vulkan光线追踪是依靠Vulkan的诸多扩展实现的：

// Vulkan extension specifications
VK_KHR_acceleration_structure
VK_KHR_ray_tracing_pipeline
VK_KHR_ray_query
VK_KHR_pipeline_library
VK_KHR_deferred_host_operations
    
// SPIR-V extensions specifications
SPV_KHR_ray_tracing
SPV_KHR_ray_query
    
// GLSL extensions specifications
GLSL_EXT_ray_tracing
GLSL_EXT_ray_query
GLSL_EXT_ray_flags_primitive_culling

主要的类型：

• VkPhysicalDeviceAccelerationStructureFeaturesKHR：描述可由实现支持的加速结构特征的结构。
• VkPhysicalDeviceRayQueryFeaturesKHR：描述可由实现支持的光线查询功能的结构。
• VkPhysicalDeviceRayTracingPipelineFeaturesKHR：描述可由实现支持的光线追踪功能的结构。
• VkPhysicalDeviceAccelerationStructurePropertiesKHR：用于加速结构的物理设备的属性。
• VkPhysicalDeviceRayTracingPipelinePropertiesKHR：用于光线追踪的物理设备的属性。

其它特殊的类型：

• VK_KHR_deferred_host_operations：允许将高消耗的驱动程序操作卸载到应用程序管理的CPU线程池，以便在后台线程上完成或跨多个内核并行化任务，可用于光线追踪管线编译或基于CPU的加速结构构建。

  VkDeferredOperationKHR对象封装了延迟命令的执行状态，在其整个生命周期中将处于两种状态之一（完成或挂起）。

• VK_KHR_pipeline_library：提供了一组可链接到管线中的着色器的能力，在增量构建光线追踪管线时非常有用。

主机（Host）加速结构构建提供了利用闲置CPU提高性能的机会，考虑一个游戏中的假设情景（下图左），加速结构构造和更新在设备上实现，但应用程序有相当多的CPU空闲时间。将这些操作移动到主机允许CPU执行与前一帧渲染并行的下一帧加速结构，可以提高吞吐量，即使CPU需要更多的挂钟时间来执行相同的任务（下图右）。

在Vulkan中，根据加速结构追踪光线需要经过多个逻辑阶段，从而在如何追踪光线方面具有一定的灵活性。交点候选者最初纯粹基于其几何特性找到——是否存在沿光线与加速结构中描述的几何对象的交点？

相交测试在Vulkan中是无缝的（watertight），意味着对于加速度结构中描述的单个几何对象，光线不能通过三角形之间的间隙泄漏，并且不能报告同一位置不同三角形的多次命中。此举并不能保证邻接的相邻对象，但意味着单个模型中不会有洞或者过度着色。

一旦找到候选点，在确定交点之前会进行一系列剔除操作，这些剔除操作基于用于遍历的标志和加速结构的属性丢弃候选。剩余的不透明三角形候选被确认为有效交点，而AABB和非不透明三角形需要着色器代码以编程方式确定是否发生命中。

遍历继续，直到找到所有可能的候选，并确认或丢弃，并确定最近的命中，也可以使遍历提前结束，以避免不必要的处理。此举可用于检测遮挡，或在某些情况下用作优化。

追踪光线和获得遍历结果可以通过Vulkan中的两种机制之一完成：光线追踪管线和光线查询（下图）：

• 光线查询提供了对任何着色器阶段中光线遍历逻辑的直接访问，允许将它们插入现有着色器中，并增强这些着色器表达的效果。
• 光线追踪管线提供了一种带有动态着色器选择的专用光线追踪机制，使场景和可编程交集逻辑中使用的材质具有极大的灵活性。

光线查询可用于执行光线遍历，并在任何着色器阶段返回结果。除了需要加速结构之外，光线查询仅使用一组新的着色器指令执行。光线查询使用要查询的加速结构、确定遍历属性的光线标志、剔除遮罩和被追踪光线的几何描述进行初始化。在遍历过程中，着色器可以访问潜在交点和提交交点的属性，以及光线查询本身的属性，从而能够根据几何体的相交、相交方式和位置进行复杂决策（下图）。

更详细的教程：NVIDIA Vulkan Ray Tracing Tutorial，示例代码：Ray Tracing In Vulkan。

Vulkan光线追踪效果示例。

17.4.3 Metal RayTracing

Metal光线追踪的流程如下：

Metal性能着色器使用高性能相交器（MPSRayIntersector）解决了相交消耗高的问题，可加速GPU上的光线三角形相交测试，其接受通过Metal缓冲区的光线，并返回沿每个光线穿过金属缓冲区最近的交点（对于主光线）或任何交点（对于阴影光线）。Metal性能着色器构建了一种称为加速结构的数据结构，用于优化计算交点。Metal性能着色器从描述场景中三角形的顶点构建加速结构。若要搜索交点，可向交点提供加速度结构。

MPSRayIntersector在加速结构支持下的检测交点过程的示意图：

在顶点缓冲区中的三角形上构建加速结构（可在GPU上构建），将加速结构传递到MPSRayIntersector。

有了加速结构和交点检测器，流程变成了如下图所示：

对于动态物体，启用了Refit机制，比从头开始建造要快得多，在GPU上运行，无法添加或删除几何体，可能会降低加速结构质量。

对于两级加速结构，场景示例和数据结构如下：

在降噪方面，输入有本帧和上一帧的噪点图像、深度、法线和运动向量，结果降噪器处理后，输出降噪图像：

降噪算法采用了MPSSVGF，高质量的SVGF降噪算法，MPSSVGFDenoiser协调降噪过程，低级别控制：

在渲染过程中，和其他友商一样，采用了混合渲染管线：

在生成光线时，Metal按指定的顺序处理光线，块状线性布局可以提高光线一致性，提升缓存命中率，从而提高性能：

在计算阴影、AO等过程中，也使用了重要性采样来生成光线，相同视觉质量需要的光线更少。重要性采样过程中使用了半球、余弦采样、距离采样：

从左到右：半球、半球+余弦、半球+余弦+距离。

为了降低噪点，使用了Halton、Sobol等低差异序列，相邻像素采样方向不同，可以对所有像素使用相同的低差异采样

对于GI，渲染流程如下：

Metal的优化技巧有：

• 减少带宽占用。合并负载和存储，尽可能使用较小的数据类型，分裂结构。反直觉——使用自己的原点和方向缓冲区，避免加载/存储不需要的结构成员。

• 减少寄存器压力。同时追踪存活的变量数量和大小，不要保留结构数据，小心循环计数器和函数调用。

• 消除非活动光线。如离开场景，不再携带足够能量的光线，无法产生可测量的影响，透明表面的全内反射。经过多次迭代之后，最终存活的光线只有23%：

  线程组变得很少使用，射线相交器仍必须处理非活动射线，控制流语句以剔除非活动光线。可以压实（Compaction）光线——仅将活动光线添加到下一个光线缓冲区，线程组得到充分利用，也适用于阴影光线。

  缓冲区索引不再映射到恒定像素位置，需要追踪每个光线的像素坐标。

  此外，Metal还支持交叉分块（Interleaved Tiling），用于多个GPU：

  较小的分块在GPU上更均匀地分布渲染，伪随机分配避免与场景相关，相同的GPU在每帧渲染相同的块。

  ng)

分块分配时，为每个分块分配一个随机数，与阈值比较以选择GPU。

数据传输的流程如下：

Metal的光线追踪场景通常遵循以下步骤：

1、将主光线从相机投射到场景，并在最近的交点处计算阴影。也就是说，距离摄影机最近的点，光线击中几何体。

2、将阴影光线从交点投射到光源。如果阴影光线由于相交几何体而未到达光源，则交点处于阴影中。

3、在随机方向上从交点投射次光线以模拟光反弹。在次级光线与几何体相交的位置添加照明贡献。

Metal光线追踪的相关示例代码：

• Accelerating ray tracing using Metal
• Rendering reflections in real time using ray tracing
• Control the Ray Tracing Process Using Intersection Queries
• Accelerating ray tracing and motion blur using Metal

17.4.4 Ray tracing X（RTX）

NV作为世界级的图形学界的探索先锋队，在光线追踪方面有着深入的研发，最终抽象成技术标准RTX平台。

随着DirectX 12的DXR和Vulkan的支持，使得支持硬件级的光线追踪技术渐渐普及。NV最先在Turing架构的GPU支持了RTX技术：

由上图可见，最上层是用户层（MDL和USD），包含了深度学习和普通应用开发；中间层是图形API层，支持RTX的有OptiX、DXR、Vulkan，OpenGL并不支持RTX；最底层就是RTX平台，它又包含了4个部分：传统的光栅化器、光线追踪（RT Core）、CUDA计算器、AI核心。

当然，除了Turing架构的GPU，还有PASCAL、VOLTA、TURING RTX等架构的众多款GPU支持RTX技术。（下图）

下图是若干款支持RTX技术的GPU运行同一个Demo（Battlefield）的性能对比：

此外，对于光线追踪，每种光线追踪的特性都会有不同的负载：

上图涉及的BVH（Bounding volume hierarchy）是层次包围盒，是一种加速场景物体查找的算法和结构体。

对于开发者，需要根据质量等级，做好各类指标预选项，以便程序能够良好地运行在各个画质级别的设备中。

TURING RTX的三大核心功能如下：

图灵还引入了新的工作流和效能测试标准：

利用RT Core和Tensor Core（DLSS），可以大幅提升渲染性能，缩减总时长：

NVIDIA Ampere体系架构GPU系列的最新成员GA102和GA104，GA102和GA104是新英伟达“GA10x”级Ampere架构GPU的一部分，GA10x GPU基于革命性的NVIDIA Turing GPU架构。

GeForce RTX 3090是GeForce RTX系列中性能最高的GPU，专为8K HDR游戏设计。凭借10496个CUDA内核、24GB GDDR6X内存和新的DLSS 8K模式，它可以在8K@60fps。GeForce RTX 3080的性能是GeForce RTX 2080的两倍，实现了GPU有史以来最大的一代飞跃，GeForce RTX 3070的性能可与NVIDIA上一代旗舰GPU GeForce RTX 2080 Ti相媲美，GA10x GPU中新增的HDMI 2.1和AV1解码功能允许用户使用HDR以8K的速度传输内容。

NVIDIA A40 GPU是数据中心在性能和多工作负载能力方面的一次革命性飞跃，它将一流的专业图形与强大的计算和AI加速相结合，以应对当今的设计、创意和科学挑战。A40具有与RTX A6000相同的内核数量和内存大小，将为下一代虚拟工作站和基于服务器的工作负载提供动力。NVIDIA A40的能效比上一代高出2倍，它为专业人士带来了光线追踪渲染、模拟、虚拟制作等最先进的功能。

Ampere GA10x体系结构具有巨大的飞跃。

GA102的关键特性有2倍FP32处理、第二代RT Core、第三代Tensor Core、GDDR6X和GDDR6内存、PCIe Gen 4等。

与之前的NVIDIA GPU一样，GA102由图形处理集群（Graphics Processing Cluster，GPC）、纹理处理集群（Texture Processing Cluster，TPC）、流式多处理器（Streaming Multiprocessor，SM）、光栅操作器（Raster Operator，ROP）和内存控制器组成。完整的GA102 GPU包含7个GPC、42个TPC和84个SM。

GPC是主要的高级硬件块，所有关键图形处理单元都位于GPC内部。每个GPC都包括一个专用的光栅引擎，现在还包括两个ROP分区（每个分区包含八个ROP单元），是NVIDIA Ampere Architecture GA10x GPU的一个新功能。GPC包括六个TPC，每个TPC包括两个SM和一个PolyMorph引擎。

GA102 GPU还具有168个FP64单元（每个SM两个），FP64 TFLOP速率是FP32操作TFLOP速率的1/64。包括少量的FP64硬件单元，以确保任何带有FP64代码的程序都能正确运行，包括FP64 Tensor Core代码。

GA10x GPU中的每个SM包含128个CUDA核、四个第三代Tensor核、一个256 KB的寄存器文件、四个纹理单元、一个第二代光线追踪核和128 KB的L1/共享内存，这些内存可以根据计算或图形工作负载的需要配置为不同的容量。GA102的内存子系统由12个32位内存控制器组成（共384位），512 KB的二级缓存与每个32位内存控制器配对，在完整的GA102 GPU上总容量为6144 KB。

Ampere架构还对ROP执行了优化。在以前的NVIDIA GPU中，ROP绑定到内存控制器和二级缓存。从GA10x GPU开始，ROP是GPC的一部分，通过增加ROP的总数和消除扫描转换前端和光栅操作后端之间的吞吐量不匹配来提高光栅操作的性能。每个GPC有7个GPC和16个ROP单元，完整的GA102 GPU由112个ROP组成，而不是先前在384位内存接口GPU（如前一代TU102）中可用的96个ROP。此方法可改进多采样抗锯齿、像素填充率和混合性能。

在SM架构方面，图灵SM是NVIDIA的第一个SM体系结构，包括用于光线追踪操作的专用内核。Volta GPU引入了张量核，Turing包括增强的第二代张量核。Turing和Volta SMs支持的另一项创新是并行执行FP32和INT32操作。GA10x SM改进了上述所有功能，同时还添加了许多强大的新功能。与以前的GPU一样，GA10x SM被划分为四个处理块（或分区），每个处理块都有一个64 KB的寄存器文件、一个L0指令缓存、一个warp调度程序、一个调度单元以及一组数学和其他单元。这四个分区共享一个128 KB的一级数据缓存/共享内存子系统。与每个分区包含两个第二代张量核、总共八个张量核的TU102 SM不同，新的GA10x SM每个分区包含一个第三代张量核，总共四个张量核，每个GA10x张量核的功能是图灵张量核的两倍。与Turing相比，GA10x SM的一级数据缓存和共享内存的组合容量要大33%。对于图形工作负载，缓存分区容量是图灵的两倍，从32KB增加到64KB。

GA10x Streaming Multiprocessor (SM) 。

GA10x SM继续支持图灵支持的双速FP16（HFMA）操作。与TU102、TU104和TU106图灵GPU类似，标准FP16操作由GA10x GPU中的张量核处理。FP32吞吐量的比较X因子如下表：

如前所述，与前一代图灵体系结构一样，GA10x具有用于共享内存、一级数据缓存和纹理缓存的统一体系结构。这种统一设计可以根据工作负载进行重新配置，以便根据需要为L1或共享内存分配更多内存。一级数据缓存容量已增加到每个SM 128 KB。在计算模式下，GA10x SM将支持以下配置：

• 128 KB L1 + 0 KB Shared Memory
• 120 KB L1 + 8 KB Shared Memory
• 112 KB L1 + 16 KB Shared Memory
• 96 KB L1 + 32 KB Shared Memory
• 64 KB L1 + 64 KB Shared Memory
• 28 KB L1 + 100 KB Shared Memory

Ampere架构的RT Core比Turing的RT Core的射线/三角形相交测试速度提高了一倍：

GA10x GPU通过一种新功能增强了先前NVIDIA GPU的异步计算功能，该功能允许在每个GA10x GPU SM中同时处理RT Core和图形或RT Core和计算工作负载。GA10x SM可以同时处理两个计算工作负载，并且不像以前的GPU代那样仅限于同时计算和图形，允许基于计算的降噪算法等场景与基于RT Core的光线追踪工作同时运行。

相比Turing架构，NVIDIA Ampere体系结构在渲染同一游戏中的同一帧时，可大大提高性能：

上：基于图灵的RTX 2080超级GPU渲染Wolfenstein的一帧：仅使用着色器核心（CUDA核心）、着色器核心+RT核心和着色器核心+RT核心+张量核心的Youngblood。请注意，在添加不同的RTX处理内核时，帧时间逐渐减少。

下：基于安培体系结构的RTX 3080 GPU渲染一帧Wolfenstein：Youngblood仅使用着色器核心（CUDA核心）、着色器核心+RT核心和着色器核心+RT核心+张量核心。

GA10x RT Core使光线/三角形相交测试速率比Turing RT Core提高了一倍，还添加了一个新的插值三角形位置加速单元，以协助光线追踪运动模糊操作。

在启用稀疏性的情况下，GeForce RTX 3080提供的FP16 Tensor堆芯操作峰值吞吐量是GeForce RTX 2080 Super的2.7倍，后者具有密集的Tensor堆芯操作：

细粒度结构化稀疏性使用四取二非零模式修剪训练权重，然后是微调非零权重的简单通用方法。对权重进行压缩，使数据占用和带宽减少2倍，稀疏张量核心操作通过跳过零使数学吞吐量加倍。（下图）

下图显示了GDDR6（左）和GDDR6X（右）之间的数据眼（data eye）比较，通过GDDR6X接口可以以GDDR6的一半频率传输相同数量的数据，或者，在给定的工作频率下，GDDR6X可以使有效带宽比GDDR6增加一倍。

GDDR6X使用PAM4信令提高了性能和效率。

为了解决PAM4信令带来的信噪比挑战，开发了一种名为MTA（最大传输消除，见下图）的新编码方案，以限制高速信号的转移。MTA可防止信号从最高电平转换到最低电平，反之亦然，从而提高接口信噪比。它是通过在编码管脚上传输的字节中为每个管脚分配一部分数据突发（时间交错），然后使用明智选择的码字将数据突发的剩余部分映射到没有最大转换的序列来实现的。此外，还引入了新的接口培训、自适应和均衡方案。最后，封装和PCB设计需要仔细规划和全面的信号和电源完整性分析，以实现更高的数据速率。

在传统的存储模型中，游戏数据从硬盘读取，然后从系统内存和CPU传输，然后再传输到GPU，使得IO常常成为游戏的性能瓶颈：

使用传统的存储模型，游戏解压缩可以消耗Threadripper CPU上的所有24个内核。现代游戏引擎已经超过了传统存储API的能力。需要新一代的输入/输出体系结构。数据传输速率为灰色条，所需CPU内核为黑色/蓝色块。需要压缩数据，但CPU无法跟上：

NVIDIA RTX IO插入Microsoft即将推出的DirectStorage API，这是一种新一代存储体系结构，专为配备最先进NVMe SSD的游戏PC和现代游戏所需的复杂工作负载而设计。总之，专门为游戏定制的流线型和并行化API可以显著减少IO开销，并最大限度地提高从NVMe SSD到支持RTX IO的GPU的性能/带宽。具体而言，NVIDIA RTX IO带来了基于GPU的无损解压缩，允许通过DirectStorage进行的读取保持压缩，并传送到GPU进行解压缩。此技术可消除CPU的负载，以更高效、更压缩的形式将数据从存储器移动到GPU，并将I/O性能提高了两倍。

RTX IO提供100倍的吞吐量，20倍的CPU利用率。数据传输速率为灰色和绿色条，所需CPU内核为黑色/蓝色块。

关卡加载时间比较。负载测试在24核Threadripper 3960x平台上运行，原型Gen4 NVMe m.2 SSD，alpha软件。

17.4.5 Radeon Rays / ProRender

Radeon Rays是AMD的高效、高性能光线交点检测加速库，如Radeon ProRender所示。它支持一系列用例，包括用于游戏开发工作流的交互式灯光烘焙和实时间接声音模拟。特性具体有：

• 支持DirectX 12和Vulkan。

• 自定义AABB，GPU BVH加速，几何体更新而不完全重建。

• 全谱渲染。

• AI加速。

• 便于调试的日志记录机制、验证源代码更改的测试集。

• 基于MIT的开源。

Radeon Rays用于计算照明缓存，采用了混合全局照明解决方案，照明缓存使用层次结构，在屏幕空间追踪光线，作为最后手段的世界空间光线追踪，BVH流数据。Radeon ProRender是一种快速的GPU加速全局照明渲染器，游戏内容创建加速有潜力，提供开发人员SDK（C API）、创作者插件。

Radeon ProRender部分特性。

Radeon ProRender渲染样例。

Radeon ProRender利用新的OpenCL硬件加速渲染的函数，性能的提升取决于场景，具有更复杂着色器的场景通常从硬件加速光线追踪中获益较少。下图是一些简单的基准场景，使用AMD Radeon测试了硬件加速开关RX 6800 XT图形卡。

在GPU硬件方面，ZEN 2微体系结构的高级特性包含：

• 从ZEN到ZEN 2的IPC提高了15%。
• 2倍运算缓存容量。
• 重新优化的L1I 缓存（L1指令缓存）。
• 第三代地址生成单元。
• 2倍FP数据路径宽度。
• 2倍L3容量。
• 提高分支预测准确度。
• 硬件优化的安全缓解措施。
• 通过客户模式执行陷阱（GMET）实现安全虚拟化。
• 改善SMT公平性（对于ALU和AGU调度器）。
• 改进的写入组合缓冲区。

“RENOIR”8核处理器流程图如下：

“MATISSE”16核处理器流程图如下：

“CASTLE PEAK” 64核处理器流程图如下：

指令集演化历程如下：

支持软件预取级别指令：

• 将缓存行从指定的内存地址加载到由位置引用T0、T1、T2或NTA指定的数据缓存级别。
• 如果检测到内存故障，则不会启动总线周期，指令被视为NOP。
• 预取电平T0/T1/T2在“Zen”和“Zen 2”微体系结构中的处理方式相同。
• 用预取NTA表示的非临时缓存填充提示减少了仅使用一次的数据的缓存污染。它不适用于小型数据集的缓存阻塞。用预取NTA填充到二级缓存中的行被标记为更快地从二级缓存移出，并且当从二级高速缓存移出时，不会插入三级缓存。
• 本指令的操作取决于实施。预取填充和逐出策略可能因其他处理器供应商或微体系结构代而异。

各种指令的缓存延迟如下表：

重装（refill）支持三种模式：在相同的CCX内、从局部DRAM、从其它CCX。（下图）

AMD Instinct MI200 Graphics Compute Die (GCD)如下所示：

MI200多芯片模块(AMD Instinct? MI250/MI250X)，其包括如图所示的两个图形计算裸片（GCD）。

flagship HPC节点结构图：

HPC/ML节点结构：

ML优化后的节点结构图：

AMD的开源ROCm堆栈包括开发人员为科学计算和机器学习构建高性能应用程序所需的工具：

17.4.6 PowerVR

在2014年前后，ImageTech在PowerVR GR6500的系列GPU芯片中集成了光线追踪的相关单元：光线数据管理、场景加速结构生成、光线追踪单元及缓存加速等。

PowerVR Graphics Wizard硬件架构，新增了光线追踪相关的单元和处理。

Wizard的3个独特功能：固定功能射线盒和射线三角形测试器，一致性驱动的任务形成与调度，流式场景层次生成器。相干引擎（Coherency Engine）可以让我们同时处理下图所示的所有光线：

下图是其渲染效果：

PowerVR并行的是光线而非像素：

光线采用了AABB测试，受“Fast Ray-Axis Aligned Bounding Box Overlap Tests with Plucker Coordinates” （ Jeffrey Mahovsky and Brian Wyvill）的启发。6条线构成了AABB的轮廓，光线原点和每个边向量的6个平面，平面法线和光线方向向量的点积，6个符号必须匹配且为负值。测试流程如下：

USC指令组打包，下图显示了26条指令（如果使用压缩数据格式，则为32条）：

此功能的面积减少了44倍：

光线追踪单元和相干引擎的架构如下所示：

升序虚拟内存地址包含了AABB块、顶点块、变种等，大约100M，用于1百万个三角形，包括可变三角形：

下图是流式场景层次生成器的效果和树形结构：

采用了一致性队列：

自动查找一致性路径：

场景层次生成器如下所示：

限制：场景由三角形表示——与今天相同，BVH采用经过优化的定义格式进行实现和遍历，三角形顺序通常必须遵循空间相干流，需要近似的场景比例估计，几何体着色器不与光线追踪管线内联。

加强的点在于：着色群集工作负荷不高于顶点着色器，只需处理在世界空间中实际移动的几何体，唯一算法仅将工作集约束到内部寄存器，单遍操作：与顶点着色器执行一致，很好地处理“长而瘦的三角形”问题，流式写入外部存储器，由于构建算法，无损压缩输出格式，紧凑逻辑。

基于稀疏的log2八叉树层次结构：

整体执行流程如下：

经过一些三角形处理之后的情形如下：

组装父节点之后：

一个级别的父节点组装后如下所示：

光追硬件架构各个部件的性能如下：

PowerVR光线追踪具有硬件中的场景层次生成器（SHG），SHG生成边界体层次结构数据结构，该数据结构被设计为大大提高检测哪些三角形与哪些光线相交的效率。使用蛮力方法将需要使用世界上的每个三角形测试每一条光线，过于昂贵而无法实时执行。下图是基于PowerVR GPU的实时光线追踪流程图：

作为对比，以下分别是NV和AMD的实时光线追踪架构图：

17.5 UE光线追踪

本章先阐述UE在集成和实现光线追踪时的经验、教训、优化技术等内容。

17.5.1 UE光线追踪集成

17.5.1.1 光线追踪概述

在实时应用程序（如游戏）中使用光线追踪具有挑战性，光线追踪算法的许多步骤成本高昂，包括边界体积层次结构（BVH）构造、BVH遍历和光线/原始相交测试。此外，通常应用于光线追踪技术的随机采样通常需要每像素数百到数千个样本来产生收敛图像，远远超出了现代实时渲染技术的计算预算几个数量级。此外，直到最近，实时图形API还没有光线追踪支持，使得当前游戏中的光线追踪集成具有挑战性。2018年，随着DirectX 12和Vulkan中光线追踪支持的宣布，这一情况发生了变化。

早在2018年，NVIDIA的Edward Liu（文刀秋二）和Epic Games的Juan Ca?ada等人将基于RTX的硬件光线追踪集成进了UE：

• 采用了DirectX光线追踪（DXR）并将其集成到UE4中，可以重用已有的材质着色器代码。
• 利用NVIDIA Turing架构中的RT内核进行硬件加速BVH遍历和光线/三角形相交测试。
• 发明了用于高质量随机渲染效果的新型重建滤波器，包括软阴影、光泽反射、漫反射全局照明、环境遮挡和半透明，每个像素只有一个输入样本。

硬件加速和软件创新的结合赋予开发者能够创建两个基于实时电影质量光线追踪的应用程序，例如“反射”（Lucasfilm）和“光速”（Porsche）。

在大型应用程序（如虚幻引擎）中集成光线追踪框架是一项具有挑战性的任务，实际上是UE4发布以来最大的架构变化之一。在将光线追踪集成到UE4中时，他们的目标如下：

• 性能：是UE4的一个关键因素，因此光线追踪功能应符合用户的期望。一个有助于性能的决定是，G-Buffer是使用已有的基于光栅化的技术计算的。除此之外，追踪光线以计算特定的过程，例如反射或区域光阴影。
• 兼容性：光线追踪过程的输出必须与现有UE4的着色和后处理管线兼容。
• 着色一致性：UE4使用的着色模型必须通过光线追踪精确实现，以产生与UE4中现有着色一致的着色结果。具体而言，严格遵循现有着色代码中的相同数学，对UE4提供的各种着色模型进行BRDF评估、重要性采样和BRDF概率分布函数评估。
• 最小化中断：现有UE4用户应发现集成易于理解和扩展，因此，必须遵循UE设计范式。
• 多平台支持：虽然最初UE4中的实时光线追踪完全基于DXR，但UE4的多平台特性要求他们设计新系统，使其能够最终移植到其他未来解决方案，而无需进行重大重构。

集成过程最具挑战性的是：性能、API、延迟着色光线中的集成、渲染硬件接口（RHI）中所需的更改、将用户从每个硬件平台的细节中抽象出来的薄层、着色器API的更改、可伸缩性等。

在实验性UE4实现中，扩展了渲染硬件接口（RHI），其抽象灵感来自NVIDIA OptiX API，但稍微简化了。该抽象由三种对象类型组成：rtScene、rtObject和rtGeometry。rtScene由RTObject组成，它们实际上是实例，每个都指向rtGeometry。rtScene封装TLAS，而rtGeometry封装BLAS。rtGeometry和指向给定RTGeometrics的任何rtObject都可以由多个部分组成，所有部分都属于相同的UE4基本体对象（静态网格或骨架网格），因此共享相同的索引和顶点缓冲区，但可能使用不同的（材质）命中着色器。rtGeometry本身没有关联的命中着色器。我们在rtObject部分设置命中着色器及其参数。

引擎材质着色器系统和RHI也进行了扩展，以支持DXR中的新光线追踪着色器类型：Ray Generation、Closest Hit、Any Hit、Intersection和Miss。除了Closest Hit和Any Hit着色器外，还扩展了引擎，以支持使用现有的顶点着色器（VS）和像素着色器（PS）。利用了一个Microsoft DirectX编译器的扩展开源实用程序，提供了一种从VS和PS的预编译DXIL表示生成Closest Hit和Any Hit着色器的机制。该实用程序将VS代码、输入汇编阶段的输入布局（包括顶点和索引缓冲区格式和跨距）以及PS代码作为输入。给定该输入，它可以生成最佳代码，执行索引缓冲区提取、顶点属性提取、格式转换和VS评估（对于三角形中的三个顶点中的每一个），然后使用命中时的重心坐标对VS输出进行插值，其结果作为输入提供给PS。该工具还能够生成最小的任意命中着色器以执行alpha测试，允许引擎中的渲染代码继续使用顶点和像素着色器，就像它们将被用于光栅化G缓冲区一样，并像往常一样设置它们的着色器参数。

在UE集成光线追踪的其中重要的一环是注册各种引擎图元的几何体。为了注册用于加速结构构造的几何体，必须确保UE4中的各种图元具有为它们创建的RHI级的rtGeometry和rtObject，通常需要确定创建rtGeometry和rtObject的正确范围。对于大多数图元，可以在与顶点和索引缓冲区几何体相同的范围内创建rtGeometry。对于静态三角形网格，则很简单；但对于其他基本体，可能会涉及更多，例如，粒子系统、景观（地形）基本体和骨架网格（即蒙皮几何体，可能使用变形目标或布料模拟）需要特殊处理。在UE4中，开发组人员利用了现有的GPUSkinCache——一个基于计算着色器的系统，它在每一帧执行蒙皮到临时GPU缓冲区，这些缓冲区可以用作光栅化过程、加速结构更新和命中着色器的输入。还需要注意的是，每个骨架网格实例都需要自己单独的BLAS；因此，在这种情况下，骨架网格的每个实例都需要单独的rtGeometry，并且不可能像静态网格那样实例化或共享这些实例。

另一个重要环节是更新场景的光线追踪表示（representation）。每一帧，UE4渲染器执行其渲染循环体，在其中执行多个过程，例如光栅化G缓冲区、应用直接照明或后处理。开发组人员修改了该循环以更新用于光线追踪目的的场景表示，该表示在最低级别由着色器绑定表、相关内存缓冲区和资源描述符以及加速结构组成。

从高级渲染器的角度来看，第一步涉及确保场景中所有对象的着色器参数都是最新的。为此，利用了现有的基本过程渲染逻辑，通常用于光栅化延迟着色渲染器中的G缓冲区。主要的区别在于，对于光线追踪，必须在场景中的所有对象上执行此循环，而不仅仅是相机截头体内部和潜在可见的对象，基于遮挡剔除结果。第二个区别是，第一个实现使用了前向着色渲染器的VS和PS，而不是使用延迟着色G缓冲区渲染的VS或PS，因为当着色命中反射时，看起来像是一种自然匹配。第三个区别是，必须更新多个光线类型的着色器参数，在某些情况下，使用稍微不同的着色器。

17.5.1.2 光线追踪vs光栅化

在大型场景中，更新所有对象的着色器参数可能会花费大量CPU时间。为了避免它，应该致力于传统上所称的保留模式渲染（retained mode rendering）。即时模式渲染下，CPU在每一帧重新提交许多相同的命令以一个接一个地绘制相同的对象，而在保留模式渲染中，每一帧执行的工作只需要更新场景持久表示中自最后一帧以来发生的任何变化。保留模式渲染更适合光线追踪，因为与光栅化不同，在光线追踪中，需要关于整个场景的全局信息。因此，NVIDIA RTX支持的所有GPU光线追踪API（OptiX、DirectX光线追踪和Vulkan光线追踪）都支持保留模式渲染。然而，当今大多数实时渲染引擎仍然是围绕着自OpenGL以来过去二十年中使用的光栅化API的局限性设计的。因此，渲染器被编写为在每一帧重新执行所有着色器参数设置和绘图代码，理想情况下，只需渲染从相机可见的对象。虽然这种方法对于用来演示实时光线追踪的小场景效果很好，但它无法扩展到巨大的世界。出于这个原因，UE4渲染团队开始了一个改造高级渲染器的项目，旨在实现更高效的保留模式渲染方法。

光线追踪和光栅化渲染之间的第二个区别是，必须从VS和PS代码中构建命中着色器，这些代码为光线追踪目的稍微定制。最初的方法基于UE4中用于前向着色的代码，只是跳过了依赖于与屏幕空间缓冲区关联的信息的任何逻辑，意味着使用访问屏幕空间缓冲区的节点的材质在光线追踪中无法正常工作，在组合光栅化和光线追踪时应避免使用此类材质。虽然最初的实现使用基于UE4前向渲染着色器的命中着色器，随着时间的推移，开发组重构了着色器代码，使得命中着色器看起来更接近延迟着色中用于G缓冲区渲染的着色器。在此新模式中，所有动态照明都在光线生成着色器中执行，而不是在命中着色器中执行。此举减少了hit着色器的大小和复杂性，避免了在hit着色器中执行嵌套的TraceRay()调用，并允许我们修改光线追踪着色的照明代码，迭代时间大大减少，因为不必等待重建数千个材质像素着色器。除此之外，还优化了VS代码，确保在命中(origin + t * direction)时使用射线信息计算的位置，从而避免了与VS中位置相关的内存负载和计算。此外，在可能的情况下，将计算从VS移动到PS，例如在计算变换法线和切线时。总的来说，将VS代码减少到主要用于数据获取和格式转换。

第三个差异是更新多种光线类型的参数，意味着在某些情况下，如果其中一种光线类型需要一组完全独立的VS和PS，必须多次循环场景中的所有对象。然而，在某些情况中，能够显著减少额外光线类型的开销。例如，能够通过允许RHI抽象同时提交多个光线类型的着色器参数来处理两种最常见光线类型（材质求值和Any Hit阴影）的更新，这些类型可以使用具有兼容着色器参数的命中着色器。这一要求由DirectX编译器实用程序保证，该实用程序将VS和PS对转换为命中着色器，因为它确保了Closest Hit着色器和Any Hit着色器的VS和PS参数布局相同（因为两者都是从相同的VS与PS对生成的）。考虑到这一点，以及“Any Hit Shadow”光线类型只是使用与材质评估光线类型相同的Any Hit着色器，并结合空的（null）Closest Hit着色器，因此对于两种光线类型使用相同的着色器绑定表记录数据，但使用不同的着色器标识符是很简单的。

在填充着色器绑定表记录的过程中，开发组还注意在关联的rtObject中记录它们的偏移量。需要将此信息提供给TLAS构建操作，因为DXR实现使用该信息来决定要执行哪些命中着色器以及使用哪些参数。除了更新所有着色器参数，开发组还必须更新与每个rtObject关联的实例变换和标志，这在更新着色器参数之前在单独的循环中完成，实例级标志允许控制掩蔽和背面剔除逻辑。在UE4中使用掩蔽位来实现对照明通道的支持，以允许艺术家将特定的灯光集限制为仅与特定的对象集交互。背面剔除位用于确保光栅化和光线追踪结果在视觉上匹配（剔除对光栅化而言有利于性能，但对光线追踪不一定成立）。

更新所有光线追踪着色器参数、rtObject变换以及剔除和掩蔽位后，包含命中着色器的着色器绑定表已准备就绪，所有rtObject都知道其相应的着色器绑定表格记录。此时，将进入下一步，即调度任何底层加速结构的构建或更新，以及TLAS的重建。在实验实现中，该步骤还处理与加速结构相关联的延迟内存分配。该阶段的一个重要优化是确保BLAS更新后所需的任何资源转换屏障都将延迟到TLAS构建之前执行，而不是在每次BLAS更新之后立即执行。延迟很重要，因为每个转换屏障都是GPU上的同步步骤。将转换合并到命令缓冲区中的单个点可以避免冗余同步，否则会导致GPU频繁空闲。通过合并转换，在所有BLAS更新之后执行一次同步，并允许多个BLAS更新（可能针对许多小三角形网格）在GPU上运行时重叠。

对Miss着色器的使用是有限的，尽管在RHI级别暴露了Miss着色器，但开发组从未在RHI的引擎端使用它们。开发组依赖RHI实现预先初始化一组相同的默认未命中着色器（每种光线类型一个），它只是将有效载荷中的HitT值初始化为特定的负值，以指示光线未命中任何东西。

17.5.1.3 Tier

在创建两个高端光线追踪演示的过程中积累了经验之后，开发组能够进行一次大规模的重构，可以使代码从特定于项目的代码过渡到能够很好地满足所有UE4用户需求的代码。该阶段的最终目标之一是将UE4渲染系统从即时模式移动到保留模式，此举可带来更高的效率，因为只有在给定帧发生变化的对象才能有效更新。由于光栅化管线的限制，UE4最初是按照即时模式风格编写的。然而，这种风格对于光线追踪大型场景来说是一个严重的限制，因为它总是更新每帧的所有对象，即使大多数情况下只有一小部分发生了更改。因此，转向保留模式样式是这一阶段的关键成就之一。为了实现将来在任何平台上集成光线追踪的最终目标，开发组将需求划分为不同的层次，以了解支持每个功能需要什么，以及当存在更先进的硬件时，如何在不牺牲功能的情况下面对任何特定设备的限制。

Tier 1描述了集成基本光线追踪功能所需的最低功能级别，类似于现有的光线追踪API，如Radeon光线或Metal性能着色器。输入是包含光线信息（原点、方向）的缓冲区，着色器输出是包含相交结果的缓冲区。该层中没有内置的TraceRay内部函数，也没有任何可用的命中着色器。Tier 1非常适合于实现简单的光线追踪效果，如不透明阴影或环境遮挡，但超出这些效果具有挑战性，需要对代码进行复杂更改，从而引入限制并难以实现良好的执行效率。

Tier 2支持ray generation着色器，该着色器可以调用TraceRay内部函数，其输出在追踪调用后立即可用。此级别的功能还支持动态着色器调度，该调度使用RTPSO和着色器绑定表进行抽象。Tier 2不支持递归光线追踪，因此无法从命中着色器生成新光线。在阶段1中，开发组发现在实践中并不是一个很大的限制，它具有减少命中着色器的大小和复杂性的积极副作用。Tier 2使得在UE4中实现光线追踪集成中定义的大多数目标成为可能。因此，UE4光线追踪管线的设计是在假设Tier 2能力的情况下完成的。

Tier 3严格遵循DXR规范，支持所有Tier 2功能和具有预定义最大深度的递归调用，还支持追踪ray generation着色器之外的其他着色器类型的光线，以及高级功能，例如可自定义的加速结构遍历。Tier 3是当时（2018前后）功能最强大的一组功能，它支持以模块化方式集成离线渲染的高级光线追踪功能，例如光子映射和辐照度缓存。UE4中的光线追踪集成设计为在硬件支持时使用Tier 3功能。

17.5.1.4 光源和降噪

除了从UE4中的光线追踪集成中吸取的经验教训，初始实验阶段对于探索实时光线追踪的可能性至关重要。开发组从镜面反射和硬阴影开始，接着添加降噪以近似有限光线预算中的光泽反射和区域光阴影，然后添加环境光遮挡、漫反射全局照明和半透明。

基于光栅化的渲染器（离线和实时）通常将渲染方程拆分为多段光路，并分别处理每个段。例如，为屏幕空间反射执行一个单独的过程，为直接照明执行另一个过程。此法在光线追踪渲染器中不太常用，尤其是离线路径追踪器——它通过累积数十、数百或数千条光路进行渲染。一些光线追踪渲染器使用技术来改进收敛性或交互性，例如虚拟点光源（即时辐射度）、路径空间滤波和大量降噪算法。

Zimmer等人将整个光线树拆分为单独的缓冲区，并在合成最终帧之前对每个缓冲区应用降噪滤波器。在UE的场景中，开发组遵循类似的方法，在尝试求解渲染方程时分割出现的光路，并对来自不同光线类型（例如阴影、反射和漫反射光线）的结果应用自定义过滤器。对于每个效果，每像素使用少量光线，并积极地对它们进行降噪，以弥补样本数量不足。利用局部属性来提高降噪质量（例如光源的大小或有光泽的BRDF波瓣的形状），并结合结果生成接近离线渲染器生成的图像。开发组称这种技术为分区光路滤波（Partitioned Light Path Filtering）。

在光线追踪的演示中，使用线性变换余弦（LTC）方法计算区域光的照明评估，该方法提供了照明项的无方差估计，但不包括可见性。为了渲染区域灯光的阴影，开发组使用光线追踪来收集可见性项的噪声估计，然后将高级图像重建算法应用于结果。最后，在照明结果的基础上合成降噪可见性项。在数学上，可以写成渲染方程的以下分割和近似：

其中：

• \(L\left(\omega_{o}\right)\)是沿\(\omega_{o}\)方向离开表面的辐射亮度；
• \(V\left(\omega_{i}\right)\)是方向\(\omega_{i}\)上的二元可见性项；
• 表面特性\(f\)是BRDF（双向反射分布函数）；
• \(L_i\left(\omega_{i}\right)\)是沿\(\omega_{i}\)方向的入射光；
• \(\theta_i\)是表面法线与入射光方向之间的角度为，其中\(|\cos \theta_i|\) 考量了由于该角度引起的几何衰减。

对于漫反射曲面，该近似具有可忽略的偏差，通常用于阴影图技术。对于光泽表面上具有遮挡的区域光阴影，可以使用Heitz等人的比率估计器获得更精确的结果。相反，在“光速”（Porsche）演示中，开发组直接使用光线追踪反射加降噪来处理具有遮挡信息的镜面区域光阴影。

17.5.1.5 阴影

为了获得具有大半影的高质量光线追踪区域光阴影，通常每个像素需要数百个可见性样本，以获得无明显噪点的估计。所需的光线数量取决于光源的大小以及场景中遮光器的位置和大小。对于实时渲染，有更严格的光线预算，数百条光线远远超出了性能预算。“反射”（Lucasfilm）和“光速”（Porsche）演示使用了每个光源每像素一个样本，对于这个数量的样本，结果包含大量的噪声。开发组应用了一个先进的去噪滤波器来重建一个接近基准真相的无噪图像。

开发组设计了一种专用于半影区域光阴影的降噪算法，阴影降噪器具有空间分量和时间分量，空间分量的灵感来自最近基于局部遮挡的频率分析的高效滤波器的工作，例如，Yan等人的轴对齐软阴影滤波（axis-aligned filtering for soft shadows）和剪切滤波器（sheared filter）。降噪器知道光源的相关信息，例如光源的大小、形状和方向、光源离接收器的距离，以及阴影光线的照射距离。降噪器使用该信息来尝试推导出每个像素的最佳空间滤波器足印。足印是各向异性的，每个像素具有不同的方向，下图显示了各向异性空间核的近似可视化。内核形状沿半影方向延伸，从而在降噪后获得高质量图像。降噪器的时间分量将每个像素的有效采样数增加到8–16左右。如果启用时间滤波器，则方差是轻微的时间延迟，但按照Salvi的建议执行时间截取以减少延迟。

阴影降噪器中使用的滤波器内核的可视化（绿色）。注意它是如何各向异性的，并沿着每个半影的方向延伸。

假设降噪器使用每个光源的信息，必须分别降噪每个光源投射的阴影，以至于降噪成本与场景中光源的数量成线性关系。然而，降噪结果的质量高于开发组尝试对多个光源使用公共滤光器的质量，因此在光追的两个演示选择了每个光源一个滤光器。

下图中的输入图像采用每像素一条阴影光线进行渲染，以模拟汽车顶部巨大矩形光源投射的软照明。在这样的采样率下，得到的图像非常明显的噪点。开发组的空间降噪器消除了大部分噪点，但仍存在一些伪影。结合时间和空间降噪分量，结果接近于以每像素2048条光线渲染的基准真相图像。

（a）降噪器工作在每像素一条阴影光线渲染的噪声输入上。（b） 只有降噪器的空间分量，仍然存在一些低频伪影。（c） 时空降噪器进一步改进了结果，并且（d）它与基准真相非常匹配。

对于中等大小的光源，空间降噪器可产生高质量的结果。在“反射”（Lucasfilm）演示中，仅空间降噪就足以产生阴影质量结果。对于在“光速”（Porsche）演示中使用的巨型光源类型，纯空间降噪结果不符合质量标准。因此，还在“光速”（Porsche）演示中使用了时间分量降噪器，以轻微的时间延迟为代价提高了重建质量。

17.5.1.6 反射

真实反射是基于光线追踪渲染的另一个关键承诺。当前基于光栅化的技术，如屏幕空间反射（SSR），经常会受到屏幕外内容中的伪影的影响。其他技术，如预计算光源探针，无法很好地扩展到动态场景，也无法精确模拟光泽反射中存在的所有特征，如沿表面法线方向拉伸和接触硬化。此外，光线追踪可以说是处理任意形状表面上的多次反弹反射的最有效方法。下图展示了“反射”（Lucasfilm）演示中使用光线追踪反射产生的效果类型，注意Phasma盔甲各部分之间的多弹孔相互反射。

使用光线追踪渲染的Phasma上的反射。注意盔甲各部分之间的精确相互反射，以及用降噪器重建的轻微光泽反射。

虽然光线追踪使支持任意曲面上的动态反射变得更容易，即使对于屏幕外内容，但计算反射反弹的命中点处的着色和照明成本很高。为了降低反射命中点的材质评估成本，开发组提供了使用不同的艺术家简化材质进行光线追踪反射着色的选项。这种材质简化对最终感知质量影响很小，因为反射对象通常在凸反射器上最小化，去除材质中的微观细节通常在视觉上不明显，但对性能有利。下图比较了主视图中多个纹理贴图中具有丰富微观细节的常规复杂材质（左）和反射命中着色中使用的简化版本（右）。

左：具有完整微观细节的原始Phasma材质；右：用于对反射光线命中点进行着色的简化材质。

在光泽反射的降噪方面，使用光线追踪获得完全平滑的镜面反射是很好的，但在现实世界中，大多数镜面反射曲面都不是镜像。它们的表面通常具有不同程度的粗糙度和凹凸。根据粗糙度和入射辐射亮度，使用光线追踪，通常会使用数百到数千个样本随机采样材质的局部BRDF。这样做对于实时渲染是不切实际的。

开发组实现了一种自适应多弹跳机制来驱动反射光线的生成。反射反弹射线的发射由撞击表面的粗糙度控制，因此撞击粗糙度较高的几何体的射线会更早被终止。平均而言，开发组只为每个像素指定了两条反射光线，用于两次反射反弹，因此对于每个可见着色点，只有一个BRDF样本。结果非常明显的噪点，开发组再次应用复杂的降噪滤波器来重建接近基准真相的光泽反射。

开发组设计了一种降噪算法，只对反射的入射辐射项有效。光泽反射是入射辐射项L和阴影点周围半球上的BRDF \(f\)的乘积的积分，将乘积的积分分离为两个积分的近似乘积：

它简化了降噪任务，仅对入射辐射项应用降噪\(\int_{S^{2}} L\left(\omega_{i}\right) d \omega_{i}\)，BRDF积分可以分离和预积分，是预集成光照探针的常见近似。此外，反射反照率也包含在BRDF中，因此通过仅过滤辐射项，不必担心过度模糊纹理细节。

滤波器堆栈具有时间和空间分量。对于空间部分，开发组推导了屏幕空间中的各向异性形状核，该核在局部阴影点处遵守BRDF分布。根据命中距离、表面粗糙度和法线，通过将BRDF波瓣投影回屏幕空间来估计核，得到的内核具有不同的内核大小和每个像素的方向，如下图所示。

基于BRDF的反射滤波器内核的可视化。

基于BRDF的过滤器内核的另一个值得注意的特性是，它可以通过仅从镜像表面进行过滤来产生中等粗糙的光滑表面，如下图所示。过滤器从1 spp输入产生令人信服的结果，与16384 spp的基准真相渲染结果非常匹配，参考下图中和下图下。

上：反射空间滤波器的输入，如果它只是一个完美的镜像反射图像；中：左图的反射空间滤波器的输出应用于镜面反射图像，模拟了0.15的GGX平方粗糙度，它产生了光泽反射的所有预期特征，如沿法线方向的接触硬化和延伸；下：使用无偏随机BRDF采样（每像素数千条射线）渲染的GGX平方粗糙度为0.15。

该空间滤波器可以忠实地重建具有中等粗糙度（GGX平方粗糙度小于约0.25）的光滑表面。对于更高的粗糙度值，采用有偏随机BRDF采样，如Stachowiak等人，并将时间分量与空间分量相结合，以获得更好的降噪质量。

反射表面上的时间重投影需要反射对象的运动矢量，可能很难获得。之前，Stachowiak等人使用反射虚拟深度来重建平面反射器内反射物体的摄像机移动引起的运动矢量。然而，这种方法对于曲面反射器（curved reflector）不太有效。Hirvonen等人提出了一种新方法，将每个局部像素邻域建模为薄透镜，然后使用薄透镜方程推导反射物体的运动矢量，它适用于曲面反射器，开发组使用这种方法计算时间滤波器中的运动矢量。

线性变换余弦（LTC）是一种在分析上为任意粗糙度生成真实区域光阴影的技术，但它不处理遮挡。由于反射解决方案产生了每像素一个样本的合理光泽反射，因此可以使用它直接评估面光源材质着色的镜面反射分量。开发组没有使用LTC，而是简单地将面光源视为发射对象，在反射命中点对其进行着色，然后应用降噪滤波器重建包括遮挡信息的镜面着色。下图显示了两种方法的比较。

场景地板是一个纯镜面，GGX平方粗糙度为0.17。（a）使用LTC计算两个区域灯光的照明。当LTC产生正确的高光时，本应遮挡部分高光的汽车反射消失，使汽车看起来不接触地板。（b） 对于光线追踪反射，请注意光线追踪如何处理来自汽车的正确遮挡，同时也从两个区域灯光产生看似合理的光泽高光。

17.5.1.7 全局光照

为了追求照片真实感，“反射”（Lucasfilm）和“光速”（Porsche）演示使用光线追踪计算间接照明，以提高渲染图像的真实感。但在两个演示中使用的技术略有不同。“反射”（Lucasfilm）使用光线追踪从预计算的体积光照贴图中获取辐照度信息，以计算动态角色上的间接照明。“光速”（Porsche）使用了一种更为暴力的方法，直接使用来自G-Buffer的两次间接漫反射光线进行路径追踪。它们都使用了下一事件估计（next event estimation）来加速收敛。

对于AO，环境光遮挡提供了一种近似的全局照明，该照明具有物理灵感且艺术家可控。将照明与遮挡分离会破坏物理正确性，但会提供可测量的效率。环境遮挡直接应用了几十年来一直在电影中使用的相同的、有良好记录的算法——以余弦半球分布发射多条光线，以候选点的着色法线为中心，生成了一个屏幕空间遮挡遮罩，该遮罩全局衰减照明贡献。

虽然虚幻引擎支持屏幕空间环境遮挡（SSAO），但其存在明显的缺陷——对视锥体的依赖导致边界处的暗角（vignetting），并且不能准确捕获主要平行于观察方向的薄遮挡。此外，视锥体外的遮挡物无法对SSAO产生影响。然而，使用DXR，使得我们可以捕获与视锥体无关的方向遮挡。

UE还使用了来自光照贴图的间接漫反射。对于“反射”（Lucasfilm），需要一种能够提供有效颜色渗出的环境遮挡技术。开发组实现了一个间接漫反射过程作为参考比较。对于该算法，以与传统环境遮挡类似的方式，从候选G-Buffer样本中投射光线的余弦半球分布。不记录hit-miss因素，而是记录了可视光线击中发射器时的BRDF加权结果。正如预期的那样，获得有意义的结果所需的射线数量是难以解决的，但它们为更近似的技术提供了基线。

开发组摒弃暴力计算，而采用了UE的光照映射解决方案，以提供近似的间接贡献，将体积光照贴图中的评估替换为环境遮挡光线的发射提供了一个合理的间接结果。与传统环境遮挡算法的加权可见性过程相比，生成的辐照度过程更容易降噪。对比图像如下所示。

全球照明技术比较。上：屏幕空间环境遮挡；中：灯光贴图的间接漫反射；下：用于参考的一次弹跳的路径追踪。

除了使用预计算的光照贴图渲染间接漫射照明，开发组还开发了一种路径追踪解决方案，进一步改进了全局照明效果。在对噪声辐照度应用重建滤波器之前，我们使用路径追踪和下一事件估计来渲染一次反弹间接漫射照明，提供了比之前更准确的颜色渗出。

Mehta等人提出了用于漫反射间接照明的轴对齐滤波器，开发组使用了类似的降噪器。对于“光速”（保时捷）演示，降噪更具挑战性。由于使用的是无需任何预计算的暴力路径追踪，因此将基于Mehta等人的空间滤波器与时间滤波器相结合，以获得所需的质量。对于“反射”（Lucasfilm）演示，由于从附近的光照贴图纹理元素中提取，因此使用时间抗锯齿结合空间滤波器提供了足够好的质量。

开发组仅对照明的间接漫反射分量应用去噪器，以避免过度模糊纹理细节、阴影或镜面高光，因为它们在其他专用降噪器中单独过滤。对于空间滤波器，应用了Mehta等人提出的具有从命中距离导出的足迹的世界空间空间核。根据命中距离调整滤波器大小避免了间接照明中细节的过度模糊，并使间接阴影等特征更清晰。当与时间滤波器相结合时，它还根据像素累积了多少重投影样本来减少空间内核占用。对于具有更多时间累积样本的像素，开发组应用了更小的空间滤波器足迹，从而使结果更接近于基准真相。下图显示了使用恒定半径进行过滤与基于射线命中距离和时间采样计数调整过滤器半径的比较。显然，使用适配的滤波器足迹在接触区域提供了更好的精细细节。

同样的想法也有助于光线追踪环境遮挡降噪。下图（a）具有恒定世界空间半径的去噪光线追踪环境遮挡，下图（b）使用命中距离和时间样本计数引导的自适应核半径的降噪声环境遮挡。

再次清楚的是，使用自适应滤波器大小导致在降噪环境遮挡中更好地保留接触细节。

17.5.1.8 半透明

“光速”（保时捷）演示带来了许多新挑战，最明显的最初挑战是渲染玻璃，传统的实时半透明渲染方法与延迟渲染算法相冲突。通常，开发人员需要在单独的前向通道中渲染半透明几何体，并在主延迟渲染上合成结果。可应用于延迟渲染的技术通常不适用于半透明几何体，从而造成不兼容，使得半透明和不透明几何体的集成变得困难。

幸运的是，光线追踪提供了表示半透明的自然框架。使用光线追踪，半透明几何体可以以统一几何体提交的方式轻松与延迟渲染结合。它提供了任意的半透明深度复杂性以及正确模拟折射和吸收的能力。

开发组在虚幻引擎中实现的光线追踪半透明使用了与光线追踪反射类似的单独光线追踪通道。事实上，大多数着色器代码在这两个通道之间共享。然而，两者的行为方式有一些细微的差别。

第一种差异是使用提前光线终止（early-ray termination），以防止光线能量接近零时不必要地穿越场景；例如，如果移动得更远，其贡献可以忽略不计。

另一个差异在于，半透明光线追踪的最大光线长度可防止碰撞已完全着色并存储在相应像素的不透明几何体。但是，如果执行折射，则半透明命中可能会导致任意方向上的新光线，并且该新光线或其后代可能会命中需要着色的不透明几何体。在对此类不透明命中执行任何照明之前，将不透明命中点重新投影到屏幕缓冲区，如果在该重新投影步骤之后找到有效数据，则使用它们。这个简单的技巧允许我们利用在G-Buffer中对不透明几何体执行所有光线追踪照明和降噪时获得的更高视觉质量。此法可能适用于某些有限的折射量，但由于在这种情况下使用错误的入射方向计算镜面照明，结果可能不正确。

反射过程的另一个关键区别是半透明光线在击中后续界面后递归生成反射光线的能力。由于语言中缺乏对递归的支持，使用HLSL实现这一点并不完全简单。通过递归，并不意味着追踪来自命中着色器的光线的能力，而是简单HLSL函数调用自身的能力。这在HLSL中是不允许的，但在实现一种削减式光线追踪算法时是可取的。为了解决HLSL的这个限制，开发组将相同的代码实例化为两个名称不同的函数，有效地将相关函数代码移动到一个单独的文件中，并将该文件包含两次，由每次设置函数名的预处理器宏包围，导致相同函数的两个不同实例具有不同的名称。然后，让两个函数实例化中的一个调用另一个，从而允许有效地使用一个级别的硬编码限制进行递归。由此产生的实现允许半透明路径，具有可选的折射，其中沿着路径的每个命中可以追踪“递归”反射光线以及阴影光线。沿着该路径从半透明曲面追踪的反射可能会反弹到选定的次数。然而，如果在这些反弹中的任何一次，半透明曲面被击中，则不允许追踪其他递归反射光线。

将符合比尔-朗伯定律（Beer-Lambert）的均匀体积吸收添加到半透明通道中，以模拟厚玻璃并近似基底（substrate）。为了正确建模均匀有界体积，在几何体上放置了附加约束。光线遍历被修改为显式追踪正面和背面多边形，以克服相交、非多边形几何体的问题。改进后的视觉真实感被认为不值得为“光速”（保时捷）演示增加的成本，也没有应用在其最终版本中。

最近引入了用于光线追踪加速的专用硬件，并在图形API中添加了光线追踪支持，这鼓励开发组创新并尝试一种新的混合渲染方式，将光栅化和光线追踪相结合，发明了创新的重建过滤器，用于渲染随机效果，如光泽反射、软阴影、环境遮挡和漫反射间接照明，每个像素只有一条路径，使这些昂贵的效果更适合实时使用。

此外，Practical Solutions for Ray Tracing Content Compatibility in Unreal Engine 4详细阐述了利用光线追踪和光栅化混合管线实现了多层半透明和树叶的技术、过程及优化。（下图）

17.5.2 Fortnite光线追踪

17.5.2.1 概述

2020年初，虚幻引擎光线追踪正在从测试阶段过渡到生产阶段，工程团队决定在具有挑战性的条件下进行战斗测试。Fortnite非常适合这项任务，不仅因为其规模巨大，还因为它具有许多其他特性，使得很难实现游戏中的光线追踪。也就是说，内容创建管线定义得很好，将其更改为包含光线追踪不是一个选项。此外，内容更新经常发生，因此不可能调整参数以使特定版本看起来很好，但任何修改都应该相对永久，并且在未来的更新中表现正确。

该项目的主要目标是在Fortnite中发布光线追踪，以改善游戏的视觉效果，并使用UE4光线追踪技术进行战斗验证。从技术角度来看，最初的目标是在具有8核CPU（i7-7000系列或同等产品）和NVIDIA 2080 Ti图形卡的系统上运行游戏，并满足以下要求：

• 帧速率：60 FPS。
• 分辨率：1080p。
• 光线追踪效果：阴影、环境遮挡和反射。

项目期间发生的改进有助于实现更宏伟的目标。光线追踪反射、全局照明和降噪方面的新发展，加上NVIDIA深度学习超采样（DLSS）的集成，使得可以针对更高分辨率和更复杂的照明效果，如光线追踪全局照明（RTGI）。

从艺术和内容创作的角度来看，团队的目标并不是要在外观上做出巨大的改变，但目标是在关键照明效果上实现特定的改进，通过移除屏幕空间效果引入的一些人瑕疵，使视觉效果更加愉悦。Fortnite是一款非真实感游戏，目的是避免光线追踪和光栅化看起来太不一样的体验。

从性能方面来看，初始测试表明，启用光线追踪时，CPU和GPU都远未达到初始性能目标。在目标硬件上运行时，CPU时间平均约为每帧24毫秒，有些峰值超过30毫秒。GPU性能也远未达到目标。虽然一些场景足够快，但其他具有更复杂照明的场景在30-40毫秒/帧范围内。具有许多动态几何结构（例如树）的一些反面案例在每帧100ms的量级上非常慢。

除了性能，还有其他一些领域提出了有趣的挑战，例如内容创建管线。Fortnite管理着大量以极高频率更新的资产，不可能在光线追踪中更改资产以使其看起来更好，因为内容团队的过载是不可接受的。例如，为了提高光线追踪反射的性能，团队考虑添加一个fag来设置对象是否投射反射光线。然而，经过进一步评估，很明显，这种解决方案不会扩大规模。对于所有现有和未来的内容，任何改进都必须自动运行良好。

17.5.2.2 反射

Fortnite第15季的发行是Epic第一次在游戏中使用光线追踪反射的效果。虽然之前的用例需要实时性能，但目标与游戏完全不同。在NVIDIA 2080 Ti上，Fortnite光线追踪目标在1080p（4K，带DLSS）下至少为60赫兹。为了达到这一目标，必须进行一些优化和牺牲。团队做了一个专门针对游戏的实验性光线追踪反射实现。它共享了原始反射着色器的主要思想，但去掉了大多数高端渲染功能，如多弹跳反射、反射中的半透明材质、基于物理的透明涂层等。下图显示了具有屏幕空间反射和无反射的新光线追踪反射模式的比较。

算法概述：虚幻引擎反射管线使用排序的延迟材质评估方案（下图）。首先，基于G缓冲区数据生成反射光线，然后追踪到最接近的曲面及其关联的材质ID。然后按材质ID/着色器对命中点进行排序。最后，排序的命中点用于调度另一个光线追踪过程，该过程使用全光线追踪管线状态对象（RTPSO）执行材质评估和照明。

该排序管线的目标是提高材质着色器执行一致性（SIMD效率）。因为反射光线是随机化的，所以屏幕空间中靠近的像素通常会生成光线，这些光线击中相距很远的表面，从而增加了它们使用不同材质的可能性。如果不同材质的命中点最终出现在相同的GPU Wave中，性能将与唯一材质的数量大致成比例下降。虽然理论上，高级光线追踪API（如DirectX光线追踪）允许自动排序以避免此性能问题，但实际上，当时可用的驱动程序或硬件均未实现此优化。如后所述，在应用程序级别实现显式排序显著提高了性能。

使用基于G缓冲区数据的GGX分布采样生成反射射线。为了节省GPU时间，使用粗糙度阈值来决定是否可以使用简单的反射环境贴图查找来代替追踪光线。阈值映射到Fortnite图形选项中的反射质量参数——中、高和史诗质量预设选择了0.35、0.55和0.75。所有粗糙度超过0.75的表面都被剔除，因为与视觉改善相比，性能成本太高。还存在一个特殊的低预设，禁用除水以外的所有对象的光线追踪反射。下图显示了这些质量预设及其GPU性能的可视化。

不同粗糙度阈值水平和相应GPU性能的可视化。绿色：中等反射质量预设，粗糙度＜0.35，0.7毫秒。黄色：高预设，粗糙率＜0.55，1.28毫秒。红色：epic预设，粗糙程度＜0.75，1.72毫秒。品红色：粗糙度＞0.75的剔除表面，2.09毫秒。基于1920×1080分辨率下NVIDIA RTX 3090的计时。

因为Fortnite内容在设计时没有考虑光线追踪反射技术，所以大多数资产都是为屏幕空间反射而掌握的，这些反射使用纯镜像光线，因此看起来非常锐利。简单的粗糙度阈值用于从大多数表面中剔除屏幕空间反射，这些表面看起来粗糙/漫射。不幸的是，这意味着基于物理的光线追踪反射在大多数情况下都显得相当迟钝。由于游戏中的内容太多，手动调整所有材质不是一个选项。如下代码所示，实现了一个自动解决方案，在GGX采样过程中偏置表面粗糙度，使表面略微发亮：

float ApplySmoothBias(float Roughness , float SmoothBias)
{
    // SmoothStep -类似于粗糙度值低于SmoothBias的函数，否则为原始粗糙度。.
    float X = saturate(Roughness / SmoothBias);
    return Roughness * X * X * (3.0 - 2.0 * X);
}

如下图所示，该重映射函数将粗糙度值推到某个阈值以下接近零，但保留较高值不变。此特定功能旨在保留材质粗糙度贴图贡献，而无需剪裁，同时在整个粗糙度范围内保持平滑。Fortnite中使用了0.5的偏差值，是理想外观和物理精度之间的良好折衷。作为一个小小的奖励，GPU性能在某些场景中略有改善，因为镜面反射光线自然更连贯（使其追踪速度更快）。

下图比较了通过改变平滑度偏差值产生的视觉结果。

17.5.2.3 材质

虚幻引擎使用专门的轻量级管线状态对象进行初始反射光线追踪。它由一个ray generation着色器、一个微小的miss着色器和一个用于场景中所有几何体的公共微小closest-hit着色器组成。如下所示，该着色器的目标是在不产生任何着色开销的情况下，寻找最接近的交点。

struct FDeferredMaterialPayload
{
    float HitT; // Ray hit depth or -1 on miss
    uint SortKey; // Material ID
    uint PixelCoord; // X in low 16 bits, Y in high 16 bits
};

[shader("closesthit")]
DeferredMaterialCHS(FDeferredMaterialPayload Payload, FDefaultAttributes Attributes)
{
    Payload.SortKey = GetHitGroupUserData(); // Material ID
    Payload.HitT = RayTCurrent();
}

材质ID收集过程的结果以64×64分块顺序写入延迟材质有效负载缓冲区，用于后续排序。

反射光线命中点使用计算着色器按材质ID排序，在64×64像素屏幕空间分块（4096个总像素）中执行排序，光线不是执行完全排序，而是按每个分块合并到桶中。桶的数量是块中的总像素数除以预期线程组大小，例如4096像素/32线程＝128个桶。整个场景中可能有更多不同的材质（平均Fortnite RTPSO中大约有500种材质），但给定的分块不太可能包含所有材质。如果一个分块中有128种以上的不同材质，则无论如何都不可能将它们分类为完全一致的组。除了减少材质ID→ 桶ID映射中发生碰撞的可能性之外，增加箱（bin）的数量并不会有太大的改善。实际上，通过增加桶的数量并不能提高效率。

bin是作为单个计算着色器过程进行的，每个分开一个线程组，使用组共享内存存储中间结果。这里使用了一种简单的装箱算法：

（1）从延迟材质缓冲区加载元素。

（2）使用原子计算每个分拣桶的元素数量。

（3）在计数上建立一个预求和，以计算排序索引。

（4）将元素写回相同的延迟材质缓冲，以进行材质评估。

请注意，原始光线调度索引必须在整个管线中保留，并由命中着色器从光线有效载荷结构中读取（DispatchRaysIndex() 内在属性可能无法在原始（未排序）光线生成着色器之外使用）。

如下面两图所示，排序方案非常有效地减少了着色器执行差异。使用排序时，典型Fortnite帧中的大多数Wave包含单个材质着色器。尽管有效，但注意GPU性能影响非常依赖于场景。对于大多数光线自然照射到同一材质或天空的情况，由于排序开销，可能不会有性能改进，甚至会有轻微的减速。然而，对于具有许多高粗糙度曲面的复杂场景，加速比可能高达3倍，Fortnite的平均性能改善约为1.6倍。分类用于除水以外的所有事物的参考，来自水的反射光线高度相干，通常会射向天空，因此分类几乎没有什么好处。

射线排序提高SIMD执行效率的可视化。深蓝色区域属于完全不需要材质着色器的波（射入天空或被粗糙度阈值剔除的光线），较亮的颜色显示包含1（浅蓝色）和8+（深红色）不同着色器的波。

1920×1080分辨率下NVIDIA RTX 3090的排序性能比较。

“材质评估”步骤从在初始光线生成阶段写入的缓冲区加载光线参数，但缩短光线以仅覆盖先前命中的三角形周围的一小段。然后使用TraceRay调用完整材质着色器。尽管追踪第二条射线有额外成本，但在整体反射管线中，这种方法明显快于原始的TraceRay。

虚幻引擎使用平台特定的API直接启动closest-hit着色器，尽可能不产生遍历成本。在PC上的一个可行的替代路径是使用DXR可调用着色器进行所有closest-hit着色，同时使用any-hit着色器进行alpha遮罩评估。这带来了一组权衡，例如需要所有光线生成着色器通过有效载荷显式地将命中参数传递给可调用着色器。最终，缩短光线方法是当时性能和简单性之间的良好折衷。

光线追踪时，尽可能避免any-hit着色器处理是重要的性能优化。不幸的是，典型的游戏场景确实包含Alpha遮罩材质，这些材质在反射中必须看起来正确。在实践中，绝大多数反射光线倾向于击中完全不透明的材质或alpha遮罩材质的不透明部分，例如树叶遮罩纹理的实心部分。使得可以在closest-hit着色器中评估不透明度，并将不透明度状态写入光线有效载荷。然后，所有初始光线追踪都可以使用RAY_FLAG_FORCE_OPAQUE，光线生成着色器可以决定是否需要在不使用FORCE_ OPAQUE标记的情况下追踪“全脂”（full-fat）光线，如下所示。

TraceRay(TLAS, RAY_FLAG_FORCE_OPAQUE , ..., Payload);
if (GBuffer.Roughness <= Threshold && Payload.IsTransparent())
{
    TraceRay(TLAS, RAY_FLAG_NONE , ..., Payload);
}

Fortnite使用了0.1的进攻性任意命中粗糙度阈值，意味着Alpha遮罩材质（如植被）在粗糙表面上的反射中完全不透明。如下图所示，只有近乎完美的反射镜才能显示正确的Alpha剪纸（cutout）。虽然是质量让步，但在实践中，它对Fortnite非常有效。此优化的性能改进取决于场景，但在Fortnite中平均测量到大约1.2倍的加速，有些场景接近2倍。FORCE_OPAQUE的好处很容易抵消在典型帧中回溯某些光线的成本。

任何命中材质评估的可视化。绿色区域显示命中不透明几何体或alpha遮罩材质的不透明部分的反射光线（由最近的命中着色器报告），黄色区域显示由于粗糙度阈值而跳过非不透明光线追踪的位置，红色区域显示追踪非不透明光线的位置。NVIDIA RTX 3090在1920×1080分辨率下的性能为1.8毫秒，不进行不透明光线优化，为2.4毫秒。

17.5.2.4 光照

虚幻引擎光线追踪效果中的直接照明评估主要分为光线生成和未命中着色器。只有发射和间接照明来自最近的命中着色器，因为它可能涉及从纹理或灯光贴图读取。光线生成着色器包含具有基于栅格的剔除和光源形状采样的光源循环，始终使用光线追踪（而不是阴影贴图）计算反射中光源的阴影，在未命中着色器中计算光辐照度。如果光源不使用阴影，则通过设置TMin=TMax和InstanceInclusionMask=0，光源仍会通过公共追踪光线路径，并强制未命中，类似于启动可调用着色器，但避免了光线生成着色器中的额外转换。以这种方式使用未命中着色器可以精简光线生成着色器代码，并导致更好的占用率，从而提高所有目标平台的性能。

这种设计还提高了照明期间的SIMD效率，因为一个波中的光线可能会击中不同的材质。在材质评估期间，执行会发散，但在照明时会重新会聚。材质分类并不能完全解决发散问题，因为不可能总是完美的填充波，只会留下部分波。

在光线生成着色器中保留所有照明计算允许较小的最近命中着色器，此举有益于多方面，从迭代速度到代码模块化和游戏补丁大小。虚幻引擎为所有光线追踪效果使用一组通用的材质命中着色器和一个主材质光线有效载荷结构，如下代码所示。在光栅图形管线中，存在类似于前向和延迟着色的权衡，其中G-Buffer在不同渲染阶段之间提供不透明接口，并允许解耦/热交换（decoupled/hot-swappable）算法。然而，这是以大G-Buffer存储器占用或更大的射线有效载荷结构为代价的。

struct FPackedMaterialClosestHitPayload
{
    float HitT // 4 bytes
    uint PackedRayCone; // 4 bytes
    float MipBias; // 4 bytes
    uint RadianceAndNormal[3]; // 12 bytes
    uint BaseColorAndOpacity[2]; // 8 bytes
    uint MetallicAndSpecularAndRoughness; // 4 bytes
    uint IorAndShadingModelIDAndBlendingModeAndFlags; // 4 bytes
    uint PackedIndirectIrradiance[2]; // 8 bytes
    uint PackedCustomData; // 4 bytes
    uint WorldTangentAndAnisotropy[2]; // 8 bytes
    uint PackedPixelCoord; // 4 bytes
}; // 64 bytes total

除了优化材质评估成本，还需要平衡照明反射表面的成本。Fortnite广阔的世界创造了大量灯光可能会影响表面的场景，由于曲面通常接近于受到多达256个光源（反射中支持的最大光源）的影响，因此我们需要一种策略，仅选择有意义地影响曲面的光源。我们选择的方法使用世界对齐、以摄影机为中心的3D网格来执行光源剔除。

Fortnite的大世界需要在单元格（cell）大小上进行权衡：大的单元格损害了剔除效率，但由于所需的覆盖面积，小的单元格不实用。一个折衷方案是，单元格的大小根据与摄像机的距离呈指数增长。为了允许单元在网格中一起移动，对每个轴单独应用缩放。在摄像机附近产生了适度的\(8米^3\)（2×2×2）的单元格，而在离摄像机100米的地方仍然有离散的单元格。进一步的调整简化了数学，使前两层单元格保持相同大小。下图显示了网格的二维布局，下面代码显示了用于计算世界空间中任意位置的单元地址的HLSL着色器代码。

光栅格的2D切片，显示四个最接近的单元格环。

int3 ComputeCell(float3 WorldPosition)
{
    float3 Position = WorldPos - View.WorldViewOrigin;
    Position /= CellScale;

    // Use symmetry about the viewer.
    float3 Region = sign(Position);
    Position = abs(Position);

    // Logarithmic steps with the closest cells being 2x2x2 scale units
    Position = max(Position , 2.0f);
    Position = min(log2(Position) - 1.0f, (CellCount/2 - 1));

    Position = floor(Position);
    Position += 0.5f; // Move the edge to the center.
    Position *= Region; // Map it back to quadrants.

    // Remap [-CellCount/2, CellCount/2] to [0, CellCount].
    Position += (CellCount / 2.0f);

    // Clamp to within the volume.
    Position = min(Position , (CellCount - 0.5f));
    Position = max(Position , 0.0f);

    return int3(Position);
}

如下图所示，光源剔除数据的最终表示在GPU上实现为三级结构。网格是最顶层的结构，每个网格单元存储128位，每个网格单元格编码多达11个索引的列表，每个索引10位，或者将计数和偏移量编码到辅助缓冲器中。对于紧凑格式，此辅助缓冲区保存包含过多光源的单元格的索引。最低级别是索引所指的光源数据参数的结构化缓冲区。下面代码显示了如何检索网格单元的索引，网格结构和辅助缓冲区都是由计算着色器针对网格剔除光源生成的。

int GetLightIndex(int3 Cell, int LightNum)
{
    int LightIndex = -1; // Initialized to invalid
    const uint4 LightCellData = LightCullingVolume[Cell];

    // Whether the light data is inlined in the cell
    const bool bPacked = (LightCellData.x & (1 << 31)) > 0;

    const uint LightCount = bPacked ? (LightCellData.w >> 20) & 0x3ff : LightCellData.x;

    if (bPacked)
    {
        // Packed lights store 3 lights per 32-bit quantity.
        uint Shift = (LightNum % 3) * 10;
        uint PackedLightIndices = LightCellData[LightNum / 3];
        uint UnpackedLightIndex = (PackedLightIndices >> Shift) & 0x3ff;

        if (LightNum < LightCount)
        {
            LightIndex = UnpackedLightIndex;
        }
    }
    else
    {
        // Non-packed lights use an external buffer
        // with the offset in the cell data.
        if (LightNum < LightCount)
        {
            LightIndex = LightIndices[LightCellData.y + LightNum];
        }
    }
    
    return LightIndex;
}

17.5.2.5 全局光照

在Fortnite中，全局照明不是光线追踪的初始要求。最初在虚幻引擎4.22中作为实验算法发布，强力全局照明不适用于要求实时性能的应用。相反，蛮力算法仅适用于交互式和电影帧速率，原始算法在虚幻引擎4.24中被重新表述为“最终收集”算法。持续的开发、严格的照明约束以及降噪和放大带来的实质性质量改进导致采用最终收集方法作为Fortnite的潜在实时全局照明解决方案。下图显示了游戏中获得的GI视觉效果。

Fortnite的Risky Reels，在应用光线追踪全局照明之前和之后的对比，请注意从草地到格栅的反弹照明。

实验蛮力算法使用蒙特卡罗积分来求解渲染方程的漫反射分量。与其他光线追踪通道一样，全局照明通道从G-Buffer开始，其中根据光栅化深度缓冲区位置的世界空间法线生成漫反射光线。以这种方式，蛮力算法的行为非常类似于环境遮挡算法。但是，全局照明算法不是投射可见性光线以列表化天空遮挡，而是投射更昂贵的光线，通过调用最近的命中着色器来评估次曲面材质信息。

除了昂贵的最接近命中着色器评估外，该算法还必须将直接照明应用于次级曲面。全局照明算法使用下一事件估计（Next event estimation，NEE），而不是应用传统的光源循环。下一事件估计（NEE）是选择具有一定概率的候选光的随机过程。首个处理过程称为光源选择，根据某种选择概率决定要采样的光。第二个过程类似于传统的光照采样，对光源的出射方向进行采样。NEE过程构造阴影光线，以测试阴影点相对于选定光照的可见性。如果可见性光线成功连接到光源，将记录漫反射照明评估。

NEE产生的每光线成本比传统光照循环小，因为它仅评估候选光源总数的子集。尽管NEE通常被认为是每次调用选择一个光源，但可以调用另一个辅助随机过程来绘制多个NEE样本。绘制多个样本具有降低每射线方差的效果，同时也降低了构造昂贵操作评估射线的成本。每个材质评估射线绘制两个NEE样本在实践中效果良好。如下代码示例。

float3 CalcNextEventEstimation(float3 ShadingPoint, inout FPayload Payload, inout FRandomSampleGenerator RNG, uint SampleCount)
{
    float3 ExitantRadiance = 0;
    for (uint NeeSample = 0; NeeSample < SampleCount; ++NeeSample)
    {
        uint LightIndex;
        float SelectionPdf;
        SelectLight(RNG, LightIndex , SelectionPdf);

        float3 Direction;
        float Distance;
        float SamplePdf;
        SampleLight(LightIndex , RNG, Direction , Distance , SamplePdf);

        RayDesc Ray = CreateRay(ShadingPoint , Direction , Distance);
        bool bIsHit = TraceVisibilityRay(TLAS, Ray);
        if ( !bIsHit )
        {
            float3 Radiance = CalcDiffuseLighting(LightIndex , Ray, Payload);
            float3 Pdf = SelectionPdf * SamplePdf;
            ExitantRadiance += Radiance / Pdf;
        }
    }
    ExitantRadiance /= SampleCount;

    return ExitantRadiance;
}

根据艺术家允许的最大反弹次数，蛮力算法可以从次级曲面释放另一条漫反射光线，并重复该过程以扩展路径链。随后的反弹可能会提前终止，并由俄罗斯轮盘赌（Russian roulette）流程管理。

以这种方式计算的全局照明与路径追踪积分器非常匹配。然而，与路径追踪积分器一样，该过程需要大量样本才能收敛。强大的降噪核有助于生成平滑的最终结果，但实践发现，根据照明条件和整体环境，每像素16到64个样本对于足够的质量仍然是必要的。此种做法有问题，因为每帧投射多个材质评估光线会快速将算法推到实时交互帧率之外，并且仅适用于电影的耗损。下图显示了蛮力全局照明在Fortnite开发级别的应用。

开发测试环境中的蛮力全局照明技术，以屏幕分辨率=50的每像素两个样本进行渲染。请注意，黄色从附近的墙壁溢色到灌木上。

为了保持强力积分器的良好性能，2019年9月对算法进行了修改，以24 Hz的电影帧速率为Archviz内部渲染样本[4]渲染漫反射。

加速蛮力算法的关键洞察涉及将昂贵的材质评估射线转换为相对便宜的可见性射线。为此，Fortnite开发组对连续帧上的材质评估光线进行时间切片。调用蛮力积分器，但每个像素只有一个样本，并使用之前的帧模拟数据进行累积，就像实际激发了每个像素所需的样本数一样。累积先前帧数据需要样本重投影，并且可能导致严重的重影瑕疵，特别是当先前帧的模拟数据不再有效时。为了帮助协调与累积先前帧数据相关的差异，选择使用主路径重新连接来重用先前追踪的路径，以前的路径数据缓存在称为聚集点（gather point）的中间结构中，每个聚集点编码次曲面的位置，以及记录的辐照度和路径创建概率密度函数（PDF）。像素的世界位置也被缓存，并用于对照重投影标准进行测试，以便在后续帧中重用。聚集点缓冲区被解释为环形缓冲区（circular buffer），其中缓冲区长度由算法的每像素采样数决定。以类似于Bekaert等人的方式，发射次级可见性光线，以测试成功的路径重新连接。要正确执行此操作，需要从先前模拟中的活动着色点同时携带激发辐射和聚集点创建的概率密度。与下一个事件估计类似，成功的路径重新连接事件记录聚集点处的漫射照明。

漫反射光线的波作为每帧的一个单独通道被调度。此通道的执行流程与蛮力算法类似，但将照明数据记录到辅助聚集点缓冲区。“聚集点缓冲区”记录随机光评估中的次级表面位置和漫射激发辐射，以及模拟中生成聚集点的概率密度。还提供了原始创建点，以便拒绝不满足在当前帧中重用的足够标准的聚集点。根据这些数据，可以将路径重新连接事件投射到这些点，并合并缓存的照明评估。使用与光线追踪反射相同的排序延迟材质评估管线加速聚集点过程。（参见下面代码）

struct FGatherSample
{
    float3 CreationPoint;
    float3 Position;
    float3 Irradiance;
    float Pdf;
};

struct FGatherPoint
{
    float3 CreationPoint;
    float3 Position;
    uint2 Irradiance;
};

uint2 PackIrradiance(FGatherSample GatherSample)
{
    float3 Irradiance = ClampToHalfFloatRange(GatherSample.Irradiance);
    float Pdf = GatherSample.Pdf;
    uint2 Packed = (uint2)0;
    Packed.x = f32tof16(Irradiance.x) | (f32tof16(Irradiance.y) << 16);
    Packed.y = f32tof16(Irradiance.z) | (f32tof16(Pdf) << 16);
    return Packed;
}

FGatherPoint CreateGatherPoint(FGatherSample GatherSample)
{
    FGatherPoint GatherPoint;
    GatherPoint.CreationPoint = GatherSample.CreationPoint;
    GatherPoint.Position = GatherSample.Position;
    GatherPoint.Irradiance = PackIrradiance(GatherSample);
    return GatherPoint;
}

创建聚集点后，将执行最终聚集通道。最终聚集通道循环通过与当前像素关联的所有聚集点，并将其重新投影到活动帧。成功重新投影的聚集点是路径重新连接的候选点。将发射可见性光线，以潜在地将着色点的世界位置连接到聚集点的世界定位。如果路径重新连接尝试成功，着色点将记录聚集点的漫反射照明。开发组发现，仍然需要大约16个路径重联事件才能获得良好的定性结果。下面两图分别给出了两种全局照明方法的视觉和运行时比较。

来自两种全局照明算法的结果。上图：暴力法；底部：最终聚集方法。为了清晰起见，每个结果以屏幕百分比=100呈现，并以每像素一个样本（左）和每像素16个样本（右）显示。为了可视化的目的，图像已被照亮。

最终聚集算法仅限于扩散互反射的一次反弹。通过允许在给定事件创建随机聚集点，该技术可以扩展到多个弹跳，但为了简单起见，开发组选择了一次弹跳。由于人为限制弹跳计数具有更低的运行时间成本和更低的方差的影响，考虑到该技术的一般成本，是一个适当的折衷方案。不幸的是，重投影和路径重连失败会导致比蛮力法收敛速度慢。当经历显著的相机或对象运动时，是可能发生的。

17.5.2.6 可行性

光线追踪全局照明开发在UE 4.24发布后不久暂停。随着虚幻引擎5技术进入全面开发，扩展一种最终将与新的方案竞争的算法不再有意义。

然而，NVIDIA深度学习超级采样（DLSS）等技术开始了新的讨论。早期的测试Fortnite级别的实验表明，在DLSS处于性能模式的情况下，可以以大约每秒50帧的速度运行整个光线追踪着色器套件！光线追踪阴影、环境遮挡、反射、天光和全局照明算法接近发布的预期预算。最初是非常令人兴奋的，但生产地图仍然要复杂得多。特别是对于全局照明，原始随机光选择方法无法处理Fortnite的大量活动光源数量。即使对光源选择进行了必要的改进，显著的样本噪点（主要是内部照明）也使得最终聚集算法难以采用。

正如在生产中发生的那样，其他功能目标也在开发过程中发生了变化。最值得注意的决定之一是，除了太阳（平行光）之外，所有光源都省略了光线追踪阴影。如果光线追踪阴影仅包含在太阳中，也可以对全局照明应用类似的排除规则。当然，这也限制了外部环境的反弹照明，但如果将全局照明限制为太阳，可以解决光源选择方面的算法效率低下的问题。其他潜在的采样问题，如来自大面积灯光的照明，也消失了。通过将下一个事件估计样本调整为1，避免了发射第二条阴影射线的成本，并获得了额外的节省。由于特征集被显著剔除，采用光线追踪全局照明实际上似乎是可行的。

尽管剔除了大量算法要求，但由于剩余的性能和采样问题，为Fortnite部署最终聚集算法仍然具有挑战性。很明显，开发组需要以更粗糙的决议来运作，以保持预算，预计该项目将需要半分辨率或更小的操作。不幸的是，开发组发现在较小的分辨率下运行通常需要更多的重新连接事件来帮助降低噪点。这样做不符合开发组的临时战略；然而，随着时间延迟的增加，成功重新连接事件的可能性降低。对于像Fortnite这样快速发展的游戏来说，对时间历史的整体依赖被证明是困难的。

开发组开始试验聚集点重投影和路径重连接的扩展策略，使用随时间变化（time-varying）的摄像机投影改进了简单的基于世界的采集点数据重投影，以提高快速移动摄像机运动的稳定性。虽然最终聚集算法的第一个实现利用了聚集点的时间路径重投影，但预计空间和时间重用对于增加每个像素的有效样本是必要的。该领域的先前实验已经失败，正如Bekaert等人之前提出的那样，尽管最终结果中观察到误差减少，但使用规则邻域重建核显示出强烈令人反感的结构化噪声。

由于还必须解决一般的降噪问题，该领域的进一步实验停止了。开发组之前的全局照明降噪器在全分辨率下运行良好，但在较低分辨率下渲染时会迅速退化。值得庆幸的是，NVIDIA提供了时空方差引导滤波（SVGF），SVGF被证明是全局照明算法的游戏规则改变者，比Fortnite开发组的集成降噪器能更好地容忍下采样、噪声图像。SVGF很容易接受新的空间路径重新连接策略中存在的结构化噪声，并在增加每个像素的总体有效样本的同时产生非常令人满意的结果。不幸的是，开发组的SVGF实现在尝试升级到所需分辨率时显示出具有高反照率表面的溢色瑕疵（下图）。

Fortnite’s Misty Meadows在应用光线追踪全局照明之前和之后对比图，注意红色从屋顶溢出到建筑物上。

虽然这种情况并不频繁，但在感兴趣的汗砂点中普遍存在（下图），需要解决。面对艰难的最后期限，开发组选择实现上采样预通道，这样G-Buffer关联不会干扰过滤器。如果在另一个项目中使用SVGF，开发组打算在未来解决这一过高的成本。

Fortnite’s Sweaty Sands在应用光线追踪全局照明之前和之后对照图。共享邻域样本创建了强结构化伪影，但SVGF仍然能够重建平滑结果，同时也抑制了时间瑕疵。

下表左给出了最终聚集算法迭代改进的最终分解，下表右给出了每次通过的最终成本分解。将全局照明限制为定向光显示了避免光选择时的显著成本节约。DLSS允许该方法在分数尺度上工作，应用另一个显著的加速。通过将照明限制到下一个事件估计样本来实现中等速度增益。当使用SVGF应用我们的空间重新连接策略时，重新引入成本以保持时间稳定性。SVGF在半分辨率和四分之一分辨率方面提供了令人满意的结果，这推动了我们的高质量和低质量设置。

17.5.2.7 CPU优化

• GPU缓冲区管理

在分析启用光线追踪时的CPU成本时，开发组很快注意到D3D12数据缓冲区管理代码需要改进。由于网格数据流，Fortnite在游戏过程中花费了大量时间创建和销毁加速结构数据缓冲区。

一种简单的优化方法是从专用堆中分配所有这些资源，而不是使用单个提交或放置的资源，因为加速结构缓冲器必须保持在D3D12光线追踪RAYTRACING_ACCELERATION_STRUCTURE状态，而划痕缓冲器保持在UNORDERED_ACCESS状态。这意味着不需要状态转换，也不需要每个缓冲器的状态追踪。由于较小的对齐开销，这种调整也节省了大量内存（D3D12中放置的资源需要64K对齐，但大多数缓冲区要小得多）。

开发组必须确保在游戏过程中不会创建提交的资源，因为这可能会导致巨大的CPU峰值（有时超过100毫秒）。UE4的D3D12后端中的缓冲池方案进行了调整，以支持顶层和底层加速结构数据所需的大量分配（最大分配大小增加）。读回缓冲区用于获取压缩信息，并作为专用堆中的放置资源进行池化和子分配。

另一个问题是，几乎所有静态底层加速结构（BLAS）缓冲区都是临时以全尺寸创建的，然后进行压缩。压缩要求读回最终BLAS大小，并将其复制到新的压缩加速结构缓冲区中，会导致大量碎片和内存浪费。由于时间限制，开发组没有为Fortnite实现池碎片整理，但后来为虚幻引擎5完成了。

• 动态光线追踪几何

另一个CPU瓶颈是在更新BLAS数据之前收集和更新场景中的所有动态网格。为每个网格运行计算着色器，以生成该帧的动态顶点数据。该临时顶点数据随后用于更新/调整BLAS。在单个帧中可能会启动数百个调度和构建操作。每个调度可能使用不同的计算着色器和输出顶点缓冲区，从而在生成命令列表时造成大量CPU开销，这种性能开销来自切换着色器、状态以及绑定不同的着色器参数。

开发组首先通过按着色器对所有动态几何体更新请求进行排序来优化此过程，但还不足够，额外的开销来自切换每个网格的缓冲区和执行内部资源状态转换。大多数动态网格（如角色或可变形对象）需要在每帧更新，因此更新的顶点数据不必持久存储，这允许我们使用瞬态每帧缓冲区，每个网格内具有简单的线性子分配，最小化状态追踪成本。每个计算着色器调度写入缓冲区的不同部分，因此，调度之间不需要无序访问视图（UAV）屏障。最后，将动态几何体更新命令列表的生成与BLAS更新命令列表并行化，以隐藏惊人的BuildRaytracingAccelerationStructure的CPU成本。

• 构建着色器绑定表

最大的CPU成本（到目前为止）是为每个场景和光线追踪管线状态对象构建光线追踪着色器绑定表（SBT）。虚幻引擎不使用持久着色器资源描述符表，因此必须手动收集所有资源绑定，并将其复制到每个帧的单个共享描述符堆中。

为了降低复制所有网格的所有描述符的成本，开发组引入了几种级别的缓存。最大的收益来自于使用相同的着色器和资源消除重复的SBT条目（例如应用于不同网格或同一网格的多个实例的相同材质）。虚幻引擎将着色器资源绑定分组到高级表（统一缓冲区，Uniform Buffer），典型的着色器引用其中的三个或四个（视图、顶点工厂、材质等），每个统一缓冲区依次可能包含对纹理、缓冲区、采样器等的引用。我们可以通过简单地查看高级统一缓冲区而不检视其内容来缓存SBT记录。

添加了较低级别的缓存以消除描述符堆中的实际资源描述符数据的重复，主要用于消除采样器描述符的重复，因为单个D3D12采样器堆只能有2048个条目，并且一次只能绑定一个采样器。D3D12 CopyDescriptors调用的成本与描述符哈希和哈希表查找/插入的成本大致相同（或大于）。

最后，开发组对SBT记录构建进行了并行化，但发现添加工作线程带来的改进很快就减少了。由于仍然希望使用描述符重复数据消除，每个工作线程需要使用自己的本地描述符缓存，以避免同步开销，然后，全局描述符堆空间由每个工作程序使用原子以块的形式分配。此法降低了缓存效率并增加了使用的描述符堆槽的总数，4或5个工作线程是并行SBT生成的最佳点。

• 几何体裁剪

用于加速CPU和GPU渲染时间的一种简单但有效的技术是，如果实例与当前帧无关，则完全跳过它们。光线追踪时，场景中的每个对象都会影响摄影机看到的内容。然而，在现实生活中，许多对象的贡献可以忽略不计。最初，开发组尝试剔除相机后面的几何体，这些几何体放置在距离阈值更远的位置。然而，这个解决方案被放弃了，因为当具有大覆盖率的对象在一帧中被拒绝并在下一帧中接受时，它会产生跳变瑕疵。解决方案是更改剔除标准，以将实例的边界球体的投影面积也考虑在内，并仅在其足够小时丢弃。这个简单的改变消除了跳变，同时大大提高了速度。平均而言，每帧的增益为2-3毫秒。

• DLSS

NVIDIA DLSS技术的集成有助于提高性能，使启用光线追踪全局照明成为可能，并在更高分辨率下启用光线追踪运行游戏。为集成DLSS而进行的引擎更改现在在公共UE4代码库中可用，而UE4的DLSS插件现在在虚幻引擎商店中可用。

总之，光线追踪在Fortnite第15季（2020年9月）发布，实现了比Fortnite团队最初设定的目标更为雄心勃勃的目标。尽管该项目在许多层面上都具有挑战性，但最终取得了成功。启用光线追踪后，不仅游戏看起来更好，而且所有改进现在都是UE4公共代码库的一部分。

实时光线追踪中存在许多需要更多工作的开放问题，包括具有大量动态几何体的场景，这些几何体必须在每帧更新，需要多次反弹散射的复杂光传输，以及具有大量动态光的场景。这些问题很难解决，需要计算机图形学界多年的努力。Epic Games的工程团队将继续改进为该项目开发的技术，以及路线图上的其他新方法，目标是使光线追踪成为任何类型游戏或实时图形应用的可行解决方案。

17.6 UE光线追踪源码分析

本篇以UE 5.0.3作为分析的源码版本，如果需要同步看源码的童鞋注意了。

17.6.1 UE光追总览

在分析UE的光线追踪的源码之前，先放一张UE4的渲染管线总览图（来自UE官方视频教学，点击可放大）：

如上图所示，光线追踪和光栅化相结合，即所谓的混合渲染管线。其中，与光线追踪相关的模块或特性有阴影、AO、GI、反射、半透明、体积材质等。

在UE 5.0.3版本中，【C++侧】和光线追踪相关的有：

• Shared

  • RayTracingBuiltInResources.h
  • RayTracingDefinitions.h
  • RayTracingTypes.h

• D3D12RHI

  • D3D12RayTracing.h
  • D3D12RayTracing.cpp
  • D3D12RayTracingRootSignature.h

• Engine

  • RayTracingInstance.h
  • RayTracingInstance.cpp
  • RayTracingSkinnedGeometry.cpp

• RenderCore

  • RayGenShaderUtils.h
  • BuiltInRayTracingShaders.h
  • RayTracingGeometryManager.h
  • BuiltInRayTracingShaders.cpp
  • RayTracingGeometryManager.cpp

• Lumen

  • LumenHardwareRayTracingCommon.h
  • LumenHardwareRayTracingCommon.cpp
  • LumenHardwareRayTracingMaterials.cpp
  • LumenRadianceCacheHardwareRayTracing.cpp
  • LumenReflectionHardwareRayTracing.cpp
  • LumenSceneDirectLightingHardwareRayTracing.cpp
  • LumenScreenProbeHardwareRayTracing.cpp
  • LumenTranslucencyVolumeHardwareRayTracing.cpp

• RayTracing

  • RayTracingAmbientOcclusion.cpp
  • RayTracingBarycentrics.cpp
  • RayTracingDeferredMaterials.cpp
  • RayTracingDeferredMaterials.h
  • RayTracingDeferredReflections.cpp
  • RayTracingDynamicGeometry.cpp
  • RayTracingGlobalIllumination.cpp
  • RayTracingIESLightProfiles.cpp
  • RayTracingIESLightProfiles.h
  • RayTracingInstanceBufferUtil.cpp
  • RayTracingInstanceBufferUtil.h
  • RayTracingInstanceCulling.cpp
  • RayTracingInstanceCulling.h
  • RayTracingLighting.h
  • RayTracingLighting.cpp
  • RayTracingMaterialHitShaders.cpp
  • RayTracingMaterialHitShaders.h
  • RaytracingOptions.h
  • RayTracingPrimaryRays.cpp
  • RayTracingReflections.cpp
  • RayTracingReflections.h
  • RayTracingScene.h
  • RayTracingScene.cpp
  • RayTracingShadows.cpp
  • RayTracingSkyLight.h
  • RayTracingSkyLight.cpp
  • RayTracingTranslucency.cpp
  • RayTracingDynamicGeometryCollection.h

• VulkanRHI

  • VulkanRayTracing.h
  • VulkanRayTracing.cpp

【Shader侧】和光线追踪相关的有：

• RayTracing

  • GenerateSkyLightVisibilityRaysCS.usf
  • RayGenUtils.ush
  • RayTracingAmbientOcclusionRGS.usf
  • RayTracingBarycentrics.usf
  • RayTracingBuiltInShaders.usf
  • RayTracingCalcInterpolants.ush
  • RayTracingCommon.ush
  • RayTracingCreateGatherPointsRGS.usf
  • RayTracingDeferredMaterials.usf
  • RayTracingDeferredMaterials.ush
  • RayTracingDeferredReflections.usf
  • RayTracingDeferredReflections.ush
  • RayTracingDeferredShadingCommon.ush
  • RayTracingDirectionalLight.ush
  • RayTracingDiskLight.ush
  • RayTracingDispatchDesc.usf
  • RayTracingDynamicMesh.usf
  • RayTracingFinalGatherRGS.usf
  • RayTracingGatherPoints.ush
  • RayTracingGlobalIlluminationRGS.usf
  • RayTracingHitGroupCommon.ush
  • RayTracingInstanceBufferUtil.usf
  • RayTracingLightCullingCommon.ush
  • RayTracingLightingCommon.ush
  • RayTracingLightingMS.usf
  • RayTracingMaterialDefaultHitShaders.usf
  • RayTracingMaterialHitShaders.usf
  • RayTracingOcclusionRGS.usf
  • RayTracingPointLight.ush
  • RayTracingPrimaryRays.usf
  • RayTracingRectLight.ush
  • RayTracingRectLightRGS.usf
  • RayTracingReflectionEnvironment.ush
  • RayTracingReflectionResolve.usf
  • RayTracingReflections.usf
  • RayTracingReflectionsCommon.ush
  • RayTracingReflectionsGenerateRaysCS.usf
  • RayTracingSkyLightCommon.ush
  • RayTracingSkyLightEvaluation.ush
  • RayTracingSkyLightRGS.usf
  • RayTracingSphereLight.ush
  • RayTracingSpotLight.ush
  • SkyLightVisibilityRaysData.ush
  • TraceRayInline.ush
  • TraceRayInlineCommon.ush
  • TraceRayInlineVulkan.ush
  • VFXTraceRay.ush

• Lumen

  • LumenProbeHierarchyBuildProbeArray.usf
  • LumenRadiosityHardwareRayTracing.usf
  • LumenHardwareRayTracingCommon.ush
  • LumenHardwareRayTracingMaterials.usf
  • LumenHardwareRayTracingPayloadCommon.ush
  • LumenHardwareRayTracingPipeline.usf
  • LumenHardwareRayTracingPipelineCommon.ush
  • LumenHardwareRayTracingPlatformCommon.ush
  • LumenRadianceCacheHardwareRayTracing.usf
  • LumenReflectionHardwareRayTracing.usf
  • LumenSceneDirectLightingHardwareRayTracing.usf
  • LumenScreenProbeHardwareRayTracing.usf
  • LumenTranslucencyVolumeHardwareRayTracing.usf
  • LumenVisualizeHardwareRayTracing.usf

• HairStrands

  • HairStrandsRaytracing.ush

  • HairStrandsRaytracingGeometry.usf

  • HairStrandsVoxelPageRayMarching.usf

涉及面比较广，无法对所有特性进行剖析，只能抽取部分重要的特性分析之。

17.6.2 UE光追基础

从源码可看出，UE5支持D3D12和Vulkan两个图形平台的光线追踪。

17.6.2.1 RHI Raytracing

RHI层抽象出了部分和具体图形平台无关的类型和接口，以便为上层提供统一的访问方式。RHI层有关光线追踪的主要类型和接口如下:

// RHI.h

// 此平台是否可以构建加速结构并使用完整光线追踪管线或内联光线追踪（光线查询）。
inline RHI_API bool RHISupportsRayTracing(const FStaticShaderPlatform Platform);
// 此平台是否可以编译光线追踪着色器（无论项目设置如何）。
inline RHI_API bool RHISupportsRayTracingShaders(const FStaticShaderPlatform Platform);
// 此平台是否可以编译具有内联光线追踪功能的着色器。
inline RHI_API bool RHISupportsInlineRayTracing(const FStaticShaderPlatform Platform);

// RHI是否支持当前硬件上的光线追踪（加速结构构建和新的光线追踪特定着色器类型）。
extern RHI_API bool GRHISupportsRayTracing;
// RHI是否支持光线追踪raygen、miss和hit着色器（即完整的光线追踪管线）。
extern RHI_API bool GRHISupportsRayTracingShaders;
// RHI是否支持向现有RT PSO添加新着色器。
extern RHI_API bool GRHISupportsRayTracingPSOAdditions;
// RHI是否支持间接光线追踪调度命令。
extern RHI_API bool GRHISupportsRayTracingDispatchIndirect;
// RHI是否支持异步构建光线追踪加速结构。
extern RHI_API bool GRHISupportsRayTracingAsyncBuildAccelerationStructure;
// RHI是否支持AMD Hit Token扩展。
extern RHI_API bool GRHISupportsRayTracingAMDHitToken;
// RHI是否支持计算着色器中的内联光线追踪，而不支持完整的光线追踪管线。
extern RHI_API bool GRHISupportsInlineRayTracing;
// 光线追踪加速结构所需的对齐。
extern RHI_API uint32 GRHIRayTracingAccelerationStructureAlignment;
// 光线追踪划痕缓冲区所需的对齐。
extern RHI_API uint32 GRHIRayTracingScratchBufferAlignment;
// 光线追踪着色器绑定表缓冲区需要对齐。
extern RHI_API uint32 GRHIRayTracingShaderTableAlignment;
// 光线追踪实例缓冲区中单个元素的大小。这定义了实例的结构化缓冲区所需的步幅和对齐。
extern RHI_API uint32 GRHIRayTracingInstanceDescriptorSize;

// 转换信息.
struct FRHITransitionInfo : public FRHISubresourceRange
{
    union
    {
        class FRHIResource* Resource = nullptr;
        class FRHITexture* Texture;
        class FRHIBuffer* Buffer;
        class FRHIUnorderedAccessView* UAV;
        // 光追加速结构.
        class FRHIRayTracingAccelerationStructure* BVH;
    };

    (...)
};


// RHICommandList.h

// 光追着色器绑定.
struct FRayTracingShaderBindings
{
    FRHITexture* Textures[64] = {};
    FRHIShaderResourceView* SRVs[64] = {};
    FRHIUniformBuffer* UniformBuffers[16] = {};
    FRHISamplerState* Samplers[16] = {};
    FRHIUnorderedAccessView* UAVs[16] = {};
};

// 光追局部着色器绑定.
struct FRayTracingLocalShaderBindings
{
    uint32 InstanceIndex = 0;
    uint32 SegmentIndex = 0;
    uint32 ShaderSlot = 0;
    uint32 ShaderIndexInPipeline = 0;
    uint32 UserData = 0;
    uint16 NumUniformBuffers = 0;
    uint16 LooseParameterDataSize = 0;
    FRHIUniformBuffer** UniformBuffers = nullptr;
    uint8* LooseParameterData = nullptr;
};

// RayTracingCommon.ush中声明的FBasicRayData的C++计数器部分.
struct FBasicRayData
{
    float Origin[3];
    uint32 Mask;
    float Direction[3];
    float TFar;
};

// RayTracingCommon.ush中声明的FIntersectionPayload的C++计数器部分.
struct FIntersectionPayload
{
    float  HitT;            // 射线方向上从射线原点到交点的距离。如果是负数则表示未命中。
    uint32 PrimitiveIndex;  // 底层加速结构实例内几何体中图元的索引。未命中则是未定义状态。
    uint32 InstanceIndex;   // 顶层结构中当前实例的索引。未命中则是未定义状态。
    float  Barycentrics[2]; // 交点的原始重心坐标。未命中则是未定义状态。
};

// 光追几何体更新信息.
struct FRHIRayTracingGeometryUpdateInfo
{
    FRHIRayTracingGeometry* DestGeometry;
    FRHIRayTracingGeometry* SrcGeometry;
};

struct FRHIResourceUpdateInfo
{
    enum EUpdateType
    {
        UT_Buffer,
        UT_BufferSRV,
        UT_BufferFormatSRV,
        UT_RayTracingGeometry, // 从中间几何体接管底层资源
        UT_Num
    };

    EUpdateType Type;
    union
    {
        FRHIBufferUpdateInfo Buffer;
        FRHIShaderResourceViewUpdateInfo BufferSRV;
        FRHIRayTracingGeometryUpdateInfo RayTracingGeometry; // 光追几何体更新信息.
    };
    
    (...)
};

// 定义光追相关的命令
FRHICOMMAND_MACRO(FRHICommandCopyBufferRegions)
{
    (...)
};

struct FRHICommandBindAccelerationStructureMemory final : public FRHICommand
{
    (...)
};

struct FRHICommandBuildAccelerationStructure final : public FRHICommand
{
    (...)
};

FRHICOMMAND_MACRO(FRHICommandClearRayTracingBindings)
{
    FRHIRayTracingScene* Scene;
    (...)
};

struct FRHICommandBuildAccelerationStructures final : public FRHICommand
{
    (...)
};

FRHICOMMAND_MACRO(FRHICommandRayTraceOcclusion)
{
    (...)
};

FRHICOMMAND_MACRO(FRHICommandRayTraceIntersection)
{
    (...)
};

FRHICOMMAND_MACRO(FRHICommandRayTraceDispatch)
{
    (...)
};

FRHICOMMAND_MACRO(FRHICommandSetRayTracingBindings)
{
    (...)
};

class FRHIComputeCommandList : public FRHICommandListBase
{
public:
    // 构建加速结构和内存.
    void BuildAccelerationStructure(FRHIRayTracingGeometry* Geometry);
    void BuildAccelerationStructures(const TArrayView Params);
    void BuildAccelerationStructures(const TArrayView Params, const FRHIBufferRange& ScratchBufferRange);
    void BuildAccelerationStructure(const FRayTracingSceneBuildParams& SceneBuildParams);
    void BindAccelerationStructureMemory(FRHIRayTracingScene* Scene, FRHIBuffer* Buffer, uint32 BufferOffset);
    
    (...)
};
    
class RHI_API FRHICommandList : public FRHIComputeCommandList
{
public:
    // 光追非直接调度
    void RayTraceDispatchIndirect(FRayTracingPipelineState* Pipeline, FRHIRayTracingShader* RayGenShader, FRHIRayTracingScene* Scene, const FRayTracingShaderBindings& GlobalResourceBindings, FRHIBuffer* ArgumentBuffer, uint32 ArgumentOffset);
    
    void RayTraceOcclusion(FRHIRayTracingScene* Scene, ...);
    void RayTraceIntersection(FRHIRayTracingScene* Scene, ...);
    
    void SetRayTracingHitGroup(FRHIRayTracingScene* Scene, ...);
    void SetRayTracingCallableShader(FRHIRayTracingScene* Scene, ...);
    void SetRayTracingMissShader(FRHIRayTracingScene* Scene, ...);
    
    void ClearRayTracingBindings(FRHIRayTracingScene* Scene);

    (...)
};

template 
struct TRHIResourceUpdateBatcher
{
    void QueueUpdateRequest(FRHIRayTracingGeometry* DestGeometry, FRHIRayTracingGeometry* SrcGeometry);
    (...)
};

// DynamicRHI.h

// FDynamicRHI和光追相关的接口。
class RHI_API FDynamicRHI
{
public:
    virtual FRayTracingAccelerationStructureSize RHICalcRayTracingSceneSize(uint32 MaxInstances, ERayTracingAccelerationStructureFlags Flags);
    virtual FRayTracingAccelerationStructureSize RHICalcRayTracingGeometrySize(const FRayTracingGeometryInitializer& Initializer);
    virtual FRayTracingGeometryRHIRef RHICreateRayTracingGeometry(const FRayTracingGeometryInitializer& Initializer);
    virtual FRayTracingSceneRHIRef RHICreateRayTracingScene(const FRayTracingSceneInitializer& Initializer);
    virtual FRayTracingSceneRHIRef RHICreateRayTracingScene(FRayTracingSceneInitializer2 Initializer);
    virtual FRayTracingShaderRHIRef RHICreateRayTracingShader(TArrayView Code, const FSHAHash& Hash, EShaderFrequency ShaderFrequency);
    virtual FRayTracingPipelineStateRHIRef RHICreateRayTracingPipelineState(const FRayTracingPipelineStateInitializer& Initializer);
    virtual void RHITransferRayTracingGeometryUnderlyingResource(FRHIRayTracingGeometry* DestGeometry, FRHIRayTracingGeometry* SrcGeometry);

    (...)
};

// 和光追相关的全局接口.
TRefCountPtr RHICreateRayTracingPipelineState(const FRayTracingPipelineStateInitializer& Initializer);
FRayTracingAccelerationStructureSize RHICalcRayTracingSceneSize(uint32 MaxInstances, ERayTracingAccelerationStructureFlags Flags);
FRayTracingAccelerationStructureSize RHICalcRayTracingGeometrySize(const FRayTracingGeometryInitializer& Initializer);
FRayTracingGeometryRHIRef RHICreateRayTracingGeometry(const FRayTracingGeometryInitializer& Initializer);
FRayTracingSceneRHIRef RHICreateRayTracingScene(FRayTracingSceneInitializer2 Initializer);
FRayTracingShaderRHIRef RHICreateRayTracingShader(TArrayView Code, const FSHAHash& Hash, EShaderFrequency ShaderFrequency);


// RHIResources.h

// 光追Shader
class FRHIRayTracingShader : public FRHIShader
{
    (...)
};

// 光线生成Shader
class FRHIRayGenShader : public FRHIRayTracingShader
{
    (...)
};

// 光线未命中Shader
class FRHIRayMissShader : public FRHIRayTracingShader
{
    (...)
};

// 光线可调用Shader
class FRHIRayCallableShader : public FRHIRayTracingShader
{
    (...)
};

// 光线命中组shader
class FRHIRayHitGroupShader : public FRHIRayTracingShader
{
    (...)
};

// 光追管线状态.
class FRHIRayTracingPipelineState : public FRHIResource
{
    (...)
};

// 部分类型定义.
typedef TRefCountPtr          FRayTracingShaderRHIRef;
typedef TRefCountPtr   FRayTracingPipelineStateRHIRef;

// 光追实例标记.
enum class ERayTracingInstanceFlags : uint8
{
    None = 0,
    TriangleCullDisable = 1 << 1, // 没有背面剔除。三角形从两侧可见。
    TriangleCullReverse = 1 << 2, // 如果三角形顶点从光线原点逆时针旋转，则使三角形朝前。
    ForceOpaque = 1 << 3, // 禁用此实例的任何命中着色器调用。
    ForceNonOpaque = 1 << 4, // 强制任何命中着色器调用，即使实例中的几何体被标记为不透明。
};

// 光线追踪场景中网格的一个或多个实例的高级描述符。此描述符覆盖的所有实例将共享着色器绑定，但可能具有不同的变换和用户数据。
struct FRayTracingGeometryInstance
{
    // 关联的几何体RHI地址.
    TRefCountPtr GeometryRHI = nullptr;
    // 存储GPU转换的可选缓冲区。用于代替CPU端转换数据。
    FShaderResourceViewRHIRef GPUTransformsSRV = nullptr;

    // 单个物理网格可以使用不同的变换和用户数据在场景中多次复制。所有副本共享相同的着色器绑定表条目，因此将具有相同的材质和着色器资源。
    TArrayView Transforms;
    // 实例在场景数据的偏移.
    TArrayView InstanceSceneDataOffsets;

    // 保守的实例数。如果使用GPU变换，则某些实际实例可能会处于非活动状态。如果使用CPU转换数据，则必须小于或等于转换视图中的条目数。如果GPUTransformsSRV为非空，则必须小于或等于它中的条目数。
    uint32 NumTransforms = 0;

    // 每个几何体副本可以接收用户提供的整数，该整数可用于检索额外的着色器参数或自定义外观。
    uint32 DefaultUserData = 0;
    TArrayView UserData;

    // 每个几何体副本可以有一个位，使其单独停用（从TLA中删除，同时保持命中组索引）。用于剔除。
    TArrayView ActivationMask;

    // 将根据着色器代码中提供给TraceRay()的掩码进行测试。如果具有光线遮罩的实例遮罩的二进制和为零，则该实例被视为不相交/不可见。
    uint8 Mask = 0xFF;

    // 用于控制三角形背面剔除、是否允许任何命中着色器等的标志。
    ERayTracingInstanceFlags Flags = ERayTracingInstanceFlags::None;
};

// 光追几何体类型.
enum ERayTracingGeometryType
{
    // 具有固定函数光线交点的索引或非索引三角形列表。顶点缓冲区必须包含顶点位置，如VET_Float3。顶点步长必须至少为12字节，但可能更大，以支持自定义逐顶点数据. 可以为索引三角形列表提供索引缓冲器, 否则假设隐式三角形列表。
    RTGT_Triangles,

    // 需要交集着色器的自定义基本体类型。程序几何体的顶点缓冲区每个图元必须包含一个AABB，如｛float3 MinXYZ，float3 maxyz｝。顶点跨距必须至少为24字节，但可以更大，以支持自定义每图元数据, 索引缓冲区不能用于程序几何体。
    RTGT_Procedural,
};

// 光追几何体初始化类型.
enum class ERayTracingGeometryInitializerType
{
    Rendering, // 完全初始化RayTracingGeometry对象：创建基础缓冲区并初始化着色器参数。
    StreamingDestination, // 不创建基础缓冲区或着色器参数, 由流传输系统用作流传输到的对象。
    StreamingSource, // 创建缓冲区，但不创建着色器参数, 用于流系统中的中间对象。
};

// 光追几何体分段(子模型).
struct FRayTracingGeometrySegment
{
    DECLARE_TYPE_LAYOUT(FRayTracingGeometrySegment, NonVirtual);
public:
    // 顶点数据.
    LAYOUT_FIELD_INITIALIZED(FBufferRHIRef, VertexBuffer, nullptr);
    LAYOUT_FIELD_INITIALIZED(EVertexElementType, VertexBufferElementType, VET_Float3);
    LAYOUT_FIELD_INITIALIZED(uint32, VertexBufferOffset, 0); // 顶点缓冲区基址的偏移量（字节）。
    LAYOUT_FIELD_INITIALIZED(uint32, VertexBufferStride, 12);
    LAYOUT_FIELD_INITIALIZED(uint32, MaxVertices, 0);

    // 此分段的图元范围.
    LAYOUT_FIELD_INITIALIZED(uint32, FirstPrimitive, 0);
    LAYOUT_FIELD_INITIALIZED(uint32, NumPrimitives, 0);

    LAYOUT_FIELD_INITIALIZED(bool, bForceOpaque, false);
    LAYOUT_FIELD_INITIALIZED(bool, bAllowDuplicateAnyHitShaderInvocation, true);
    LAYOUT_FIELD_INITIALIZED(bool, bEnabled, true);
};

// 光线追踪几何初始化器.
struct FRayTracingGeometryInitializer
{
public:
    LAYOUT_FIELD_INITIALIZED(FBufferRHIRef, IndexBuffer, nullptr);
    LAYOUT_FIELD_INITIALIZED(uint32, IndexBufferOffset, 0);
    LAYOUT_FIELD_INITIALIZED(ERayTracingGeometryType, GeometryType, RTGT_Triangles);
    LAYOUT_FIELD_INITIALIZED(uint32, TotalPrimitiveCount, 0);

    LAYOUT_FIELD(TMemoryImageArray, Segments);
    LAYOUT_FIELD_INITIALIZED(FResourceArrayInterface*, OfflineData, nullptr);
    LAYOUT_FIELD_INITIALIZED(FRHIRayTracingGeometry*, SourceGeometry, nullptr);

    LAYOUT_FIELD_INITIALIZED(bool, bFastBuild, false);
    LAYOUT_FIELD_INITIALIZED(bool, bAllowUpdate, false);
    LAYOUT_FIELD_INITIALIZED(bool, bAllowCompaction, true);
    LAYOUT_FIELD_INITIALIZED(ERayTracingGeometryInitializerType, Type, ERayTracingGeometryInitializerType::Rendering);
};

// 光追场景生命周期.
enum ERayTracingSceneLifetime
{
    RTSL_SingleFrame, // 场景只能在创建时的帧中使用。
    // RTSL_MultiFrame, // 场景可以构建一次，并在任何数量的后续帧中使用（当前未实现）。
};

// 光追加速结构标记.
enum class ERayTracingAccelerationStructureFlags
{
    None = 0,
    AllowUpdate     = 1 << 0,
    AllowCompaction = 1 << 1,
    FastTrace       = 1 << 2,
    FastBuild       = 1 << 3,
    MinimizeMemory  = 1 << 4,
};

// 光追场景初始化器.
struct FRayTracingSceneInitializer
{
    TArrayView Instances;
    uint32 ShaderSlotsPerGeometrySegment = 1;
    uint32 NumCallableShaderSlots = 0;
    uint32 NumMissShaderSlots = 1;
    ERayTracingSceneLifetime Lifetime = RTSL_SingleFrame;
};

// 光追场景初始化器2.
struct FRayTracingSceneInitializer2
{
    TArray> ReferencedGeometries;
    TArray PerInstanceGeometries;
    TArray BaseInstancePrefixSum;
    TArray SegmentPrefixSum;
    uint32 NumNativeInstances = 0;
    uint32 NumTotalSegments = 0;
    uint32 ShaderSlotsPerGeometrySegment = 1;
    uint32 NumCallableShaderSlots = 0;
    uint32 NumMissShaderSlots = 1;
    ERayTracingSceneLifetime Lifetime = RTSL_SingleFrame;
};

// 光追加速结构尺寸.
struct FRayTracingAccelerationStructureSize
{
    uint64 ResultSize = 0;
    uint64 BuildScratchSize = 0;
    uint64 UpdateScratchSize = 0;
};

// 光追加速结构
class FRHIRayTracingAccelerationStructure : public FRHIResource
{
public:
    FRHIRayTracingAccelerationStructure() : FRHIResource(RRT_RayTracingAccelerationStructure) {}
};

// 底层光追加速结构（包含三角形）。
class FRHIRayTracingGeometry : public FRHIRayTracingAccelerationStructure
{
public:
    virtual FRayTracingAccelerationStructureAddress GetAccelerationStructureAddress(uint64 GPUIndex) const = 0;
    virtual void SetInitializer(const FRayTracingGeometryInitializer& Initializer) = 0;
    (...)
    
protected:
    FRayTracingAccelerationStructureSize SizeInfo = {};
    FRayTracingGeometryInitializer Initializer = {};
    ERayTracingGeometryInitializerType InitializedType = ERayTracingGeometryInitializerType::Rendering;
};

typedef TRefCountPtr     FRayTracingGeometryRHIRef;

// 顶层光线追踪加速结构（包含网格实例）.
class FRHIRayTracingScene : public FRHIRayTracingAccelerationStructure
{
public:
    virtual const FRayTracingSceneInitializer2& GetInitializer() const = 0;
    // 返回与此场景关联的RHI特定系统参数的缓冲区视图, 可能需要访问使用光线查询的着色器中的光线追踪几何体数据。如果当前RHI不需要此缓冲区，则返回NULL。
    virtual FRHIShaderResourceView* GetMetadataBufferSRV() const;
};

typedef TRefCountPtr        FRayTracingSceneRHIRef;

// 光追管线状态签名
class FRayTracingPipelineStateSignature
{
public:
    uint32 MaxPayloadSizeInBytes = 24; // sizeof FDefaultPayload declared in RayTracingCommon.ush
    bool bAllowHitGroupIndexing = true;
    
    bool operator==(const FRayTracingPipelineStateSignature& rhs) const;
    friend uint32 GetTypeHash(const FRayTracingPipelineStateSignature& Initializer);
    
    uint64 GetHitGroupHash();
    uint64 GetRayGenHash();
    uint64 GetRayMissHash();
    uint64 GetCallableHash();

    (...)
};

// 光追管线状态初始值设定项.
class FRayTracingPipelineStateInitializer : public FRayTracingPipelineStateSignature
{
public:
    // 部分光线追踪管线可用于运行时异步着色器编译，但不用于渲染。创建部分管线时，可以为任何阶段提供任意数量的着色器，但必须总共存在至少一个着色器（不允许完全空的管线）。
    bool bPartial = false;
    // 光线追踪管线可以通过从现有基础导出来创建。基本管线将通过向其中添加新的着色器来扩展，可能会节省大量CPU时间。在运行时依赖于GRHISupportsRayTracingPSOAdditions支持（如果不支持基本管线，则忽略它）。
    FRayTracingPipelineStateRHIRef BasePipeline;

    (...)

private:
    uint64 ComputeShaderTableHash(const TArrayView& ShaderTable, uint64 InitialHash = 5699878132332235837ull);

    // 着色器表.
    TArrayView RayGenTable;
    TArrayView MissTable;
    TArrayView HitGroupTable;
    TArrayView CallableTable;
};

17.6.2.2 D3D12 Raytracing

D3D12光追相关的核心类型和说明如下：

// D3D12RHIPrivate.h

// 表示各种RTPSO属性的结构（如果未知，则为0）,可用于报告性能特征、按占用率对着色器排序等。
struct FD3D12RayTracingPipelineInfo
{
    // 基于占用率或其他特定于平台的启发式方法估计RTPSO组。0预计表现最差，9预计表现最好。
    uint32 PerformanceGroup = 0;

    uint32 NumVGPR = 0;
    uint32 NumSGPR = 0;
    uint32 StackSize = 0;
    uint32 ScratchSize = 0;
};

// FD3D12DynamicRHI和光线追踪有关的接口.
class FD3D12DynamicRHI : public FDynamicRHI
{
    (...)
    
    // 计算光追场景尺寸.
    virtual FRayTracingAccelerationStructureSize RHICalcRayTracingSceneSize(uint32 MaxInstances, ERayTracingAccelerationStructureFlags Flags) final override;
    // 计算光追几何体大小.
    virtual FRayTracingAccelerationStructureSize RHICalcRayTracingGeometrySize(const FRayTracingGeometryInitializer& Initializer) final override;

    // 创建光追几何体.
    virtual FRayTracingGeometryRHIRef RHICreateRayTracingGeometry(const FRayTracingGeometryInitializer& Initializer) final override;
    // 创建光追场景.
    virtual FRayTracingSceneRHIRef RHICreateRayTracingScene(const FRayTracingSceneInitializer& Initializer) final override;
    virtual FRayTracingSceneRHIRef RHICreateRayTracingScene(FRayTracingSceneInitializer2 Initializer) final override;
    // 创建光追shader.
    virtual FRayTracingShaderRHIRef RHICreateRayTracingShader(TArrayView Code, const FSHAHash& Hash, EShaderFrequency ShaderFrequency) final override;
    // 创建光追管线状态.
    virtual FRayTracingPipelineStateRHIRef RHICreateRayTracingPipelineState(const FRayTracingPipelineStateInitializer& Initializer) final override;
    // 创建光追几何体底层资源.
    virtual void RHITransferRayTracingGeometryUnderlyingResource(FRHIRayTracingGeometry* DestGeometry, FRHIRayTracingGeometry* SrcGeometry) final override;
    
    (...)
};

// RayTracingBuiltInResources.h

struct FHitGroupSystemRootConstants
{
    // 配置由位域组成:
    // uint IndexStride  : 8; // 可以只有1位以标明是16还是32位.
    // uint VertexStride : 8; // 可以只有2位以标明是float3还是half2格式.
    // uint Unused       : 16;
    UINT_TYPE Config;
    
    UINT_TYPE IndexBufferOffsetInBytes; // HitGroupSystemIndexBuffer的偏移.
    UINT_TYPE UserData; // 分配给hit组的用户提供常数
    UINT_TYPE BaseInstanceIndex; // 属于当前批次的第一个几何体实例的索引。可用于在光线追踪着色器中模拟SV_InstanceID.

    (...)
};

// D3D12RayTracing.h

// 始终绑定到所有命中着色器的内置本地根参数.
struct FHitGroupSystemParameters
{
    D3D12_GPU_VIRTUAL_ADDRESS IndexBuffer;
    D3D12_GPU_VIRTUAL_ADDRESS VertexBuffer;
    FHitGroupSystemRootConstants RootConstants;
};

// D3D12光追几何体
class FD3D12RayTracingGeometry : public FRHIRayTracingGeometry, public FD3D12AdapterChild, public FD3D12ShaderResourceRenameListener, public FNoncopyable
{
public:
    // 设置FHitGroupSystemParameters.
    void SetupHitGroupSystemParameters(uint32 InGPUIndex);
    // 转换缓冲区.
    void TransitionBuffers(FD3D12CommandContext& CommandContext);
    // 更新持久数据.
    void UpdateResidency(FD3D12CommandContext& CommandContext);
    // 压缩加速结构.
    void CompactAccelerationStructure(FD3D12CommandContext& CommandContext, uint32 InGPUIndex, uint64 InSizeAfterCompaction);
    // 创建加速结构构建描述体.
    void CreateAccelerationStructureBuildDesc(FD3D12CommandContext& CommandContext, EAccelerationStructureBuildMode BuildMode, D3D12_GPU_VIRTUAL_ADDRESS ScratchBufferAddress, D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC& OutDesc, TArrayView& OutGeometryDescs) const;
    // 释放底层资源.
    void ReleaseUnderlyingResource();
    
    (...)

    // 标记加速结构是否被修改
    bool bIsAccelerationStructureDirty[MAX_NUM_GPUS] = {};
    // 加速结构缓冲区.
    TRefCountPtr AccelerationStructureBuffers[MAX_NUM_GPUS];
    bool bRegisteredAsRenameListener[MAX_NUM_GPUS];
    bool bHasPendingCompactionRequests[MAX_NUM_GPUS];
    // 逐几何体分段命中着色器参数
    TArray HitGroupSystemParameters[MAX_NUM_GPUS];

    // 几何图形描述数组，每段一个（单段几何图形是常见情况）. 它只引用CPU可访问的结构（没有GPU资源）, 稍后用作BuildAccelerationStructure()的模板。
    TArray> GeometryDescs;

    uint64 AccelerationStructureCompactedSize = 0;
    
    (...)
};

// D3D12光追场景
class FD3D12RayTracingScene : public FRHIRayTracingScene, public FD3D12AdapterChild, public FNoncopyable
{
public:
    // 光线追踪着色器绑定可以并行处理。每个并发工作线程都有自己的专用描述符缓存实例，以避免争用或锁定。(Fortnite团队)实践证明，扩展超过5个总线程不会产生任何加速.
    static constexpr uint32 MaxBindingWorkers = 5; // RHI thread + 4 parallel workers.

    // 缓冲区操作.
    void BindBuffer(FRHIBuffer* Buffer, uint32 BufferOffset);
    void ReleaseBuffer();

    // 构建加速结构.
    void BuildAccelerationStructure(FD3D12CommandContext& CommandContext, FD3D12Buffer* ScratchBuffer, uint32 ScratchBufferOffset, FD3D12Buffer* InstanceBuffer, uint32 InstanceBufferOffset);

    // SRV
    FShaderResourceViewRHIRef ShaderResourceView;
    
    // 加速结构数据.
    TRefCountPtr AccelerationStructureBuffers[MAX_NUM_GPUS];
    uint32 BufferOffset = 0;
    D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS BuildInputs = {};
    FRayTracingAccelerationStructureSize SizeInfo = {};

    // 初始化数据.
    const FRayTracingSceneInitializer2 Initializer;

    // 实例数据.
    TResourceArray Instances;
    TArray PerInstanceNumTransforms;

    // Scene keeps track of child acceleration structure buffers to ensure
    // they are resident when any ray tracing work is dispatched.
    TArray GeometryResidencyHandles[MAX_NUM_GPUS];

    // 更新持久数据.
    void UpdateResidency(FD3D12CommandContext& CommandContext);

    // 所有场景实例几何体中每个几何体段的命中组参数数组。作为HitGroupSystemParametersCache[SegmentPrefixSum[InstanceIndex]+SegmentIndex]访问。仅用于GPU 0（辅助GPU采用慢速路径）。
    TArray HitGroupSystemParametersCache;

    // 查找光追着色器表.
    FD3D12RayTracingShaderTable* FindOrCreateShaderTable(const FD3D12RayTracingPipelineState* Pipeline, FD3D12Device* Device);
    FD3D12RayTracingShaderTable* FindExistingShaderTable(const FD3D12RayTracingPipelineState* Pipeline, FD3D12Device* Device) const;
    // 光追着色器表.
    TMap ShaderTables[MAX_NUM_GPUS];

    (...)
};

// 管理所有挂起的BLAS压缩请求.
class FD3D12RayTracingCompactionRequestHandler : FD3D12DeviceChild
{
public:
    void RequestCompact(FD3D12RayTracingGeometry* InRTGeometry);
    bool ReleaseRequest(FD3D12RayTracingGeometry* InRTGeometry);
    void Update(FD3D12CommandContext& InCommandContext);

    (...)
};

17.6.2.3 Vulkan Raytracing

Vulkan光追相关的核心类型和说明如下：

// VulkanRaytracing.h

// 声明光线追踪入口点
namespace VulkanDynamicAPI
{
    ENUM_VK_ENTRYPOINTS_RAYTRACING(DECLARE_VK_ENTRYPOINTS);
}

// Vulkan光追平台相关接口。
class FVulkanRayTracingPlatform
{
public:
    static void GetDeviceExtensions(EGpuVendorId VendorId, TArray& OutExtensions);
    static void EnablePhysicalDeviceFeatureExtensions(VkDeviceCreateInfo& DeviceInfo, FVulkanDevice& Device);
    static bool LoadVulkanInstanceFunctions(VkInstance inInstance);
};

// Vulkan光追分配
struct FVkRtAllocation
{
    VkDevice Device = VK_NULL_HANDLE;
    VkDeviceMemory Memory = VK_NULL_HANDLE;
    VkBuffer Buffer = VK_NULL_HANDLE;
};

// Vulkan光追分配器
class FVulkanRayTracingAllocator
{
public:
    static void Allocate(FVulkanDevice* Device, VkDeviceSize Size, VkBufferUsageFlags UsageFlags, VkMemoryPropertyFlags MemoryFlags, FVkRtAllocation& Result);
    static void Free(FVkRtAllocation& Allocation);
};

// Vulkan光追TLAS.
struct FVkRtTLASBuildData
{
    VkAccelerationStructureGeometryKHR Geometry;
    VkAccelerationStructureBuildGeometryInfoKHR GeometryInfo;
    VkAccelerationStructureBuildSizesInfoKHR SizesInfo;
};

// Vulkan光追BLAS.
struct FVkRtBLASBuildData
{
    TArray> Segments;
    TArray> Ranges;
    VkAccelerationStructureBuildGeometryInfoKHR GeometryInfo;
    VkAccelerationStructureBuildSizesInfoKHR SizesInfo;
};

// Vulkan光追几何体.
class FVulkanRayTracingGeometry : public FRHIRayTracingGeometry
{
public:
    virtual FRayTracingAccelerationStructureAddress GetAccelerationStructureAddress(uint64 GPUIndex) const final override;
    virtual void SetInitializer(const FRayTracingGeometryInitializer& Initializer) final override;
    void Swap(FVulkanRayTracingGeometry& Other);
    void BuildAccelerationStructure(FVulkanCommandListContext& CommandContext, EAccelerationStructureBuildMode BuildMode);

private:
    FVulkanDevice* const Device = nullptr;
    VkAccelerationStructureKHR Handle = VK_NULL_HANDLE;
    VkDeviceAddress Address = 0;
    TRefCountPtr AccelerationStructureBuffer;
    TRefCountPtr ScratchBuffer;
};

// Vulkan光追场景.
class FVulkanRayTracingScene : public FRHIRayTracingScene
{
public:
    void BindBuffer(FRHIBuffer* InBuffer, uint32 InBufferOffset);
    void BuildAccelerationStructure(FVulkanCommandListContext& CommandContext, FVulkanResourceMultiBuffer* ScratchBuffer, uint32 ScratchOffset, FVulkanResourceMultiBuffer* InstanceBuffer, uint32 InstanceOffset);

    FRayTracingAccelerationStructureSize SizeInfo;
private:
    FVulkanDevice* const Device = nullptr;
    const FRayTracingSceneInitializer2 Initializer;
    TRefCountPtr InstanceBuffer;

    // 原生TLAS句柄由Vulkan RHI中的SRV对象拥有。D3D12和其他RHI允许在任何时候从任何GPU地址创建TLAS SRV，并且不需要它们进行构建或更新等操作。FVulkanRayTracingScene无法直接拥有VkaAccelerationStructureKHR，因为需要使用瞬态资源分配器分配TLAS内存，并且场景对象的生存期可能与缓冲区的生存期不同。可以创建多个VkaAccelerationStructureKHR，指向同一缓冲区。
    TRefCountPtr AccelerationStructureView;
    TRefCountPtr AccelerationStructureBuffer;

    // 包含每个实例索引和顶点缓冲区绑定数据的缓冲区.
    TRefCountPtr PerInstanceGeometryParameterBuffer;
    TRefCountPtr PerInstanceGeometryParameterSRV;
    void BuildPerInstanceGeometryParameterBuffer();
};

// Vulkan光追管线状态.
class FVulkanRayTracingPipelineState : public FRHIRayTracingPipelineState
{
private:
    FVulkanRayTracingLayout* Layout = nullptr;
    VkPipeline Pipeline = VK_NULL_HANDLE;
    FVkRtAllocation RayGenShaderBindingTable;
    FVkRtAllocation MissShaderBindingTable;
    FVkRtAllocation HitShaderBindingTable;
};

// Vulkan光追基础管线. 用来处理遮挡.
class FVulkanBasicRaytracingPipeline
{
private:
    FVulkanRayTracingPipelineState* Occlusion = nullptr;
};

17.6.3 UE光追渲染流程

要分析UE的光线追踪的渲染流程，还得搬出我们最熟悉的FDeferredShadingSceneRenderer::Render。下面仅列出主流程中和光线追踪相关的步骤：

// DeferredShadingRenderer.cpp

void FDeferredShadingSceneRenderer::Render(FRDGBuilder& GraphBuilder)
{
    (...)
    
    // 更新图元的GPU场景信息.
    Scene->UpdateAllPrimitiveSceneInfos(GraphBuilder, true);

#if RHI_RAYTRACING
    (...)
    
    if (CurrentMode != Scene->CachedRayTracingMeshCommandsMode || bNaniteCoarseMeshStreamingModeChanged)
    {
        // 如果更改为路径追踪渲染或从路径追踪渲染更改，则需要刷新缓存的光线追踪网格命令，因为它们包含有关当前绑定着色器的数据。这种操作有点昂贵，但只在模式之间转换时发生一次，应该是罕见的。
        Scene->CachedRayTracingMeshCommandsMode = CurrentMode;
        Scene->RefreshRayTracingMeshCommandCache();
    }
    
    (...)
#endif

    (...)

#if RHI_RAYTRACING
    FRayTracingScene& RayTracingScene = Scene->RayTracingScene;
    // 重置内部数组，但不释放任何资源。
    RayTracingScene.Reset(); 
    (...)
    // 为渲染此帧准备场景。收集网格实例、着色器、资源、参数等，并构建光线追踪加速结构.
    GatherRayTracingWorldInstancesForView(GraphBuilder, ReferenceView, RayTracingScene);
#endif
    
    (...)

    RenderPrePass(GraphBuilder, ...);

    (...)

#if RHI_RAYTRACING
    bool bRayTracingSceneReady = false;
#endif

    (...)

#if RHI_RAYTRACING
    // 异步加速结构构建可能与BasePass重叠.
    FRDGBufferRef DynamicGeometryScratchBuffer;
    DispatchRayTracingWorldUpdates(GraphBuilder, DynamicGeometryScratchBuffer);
#endif

    RenderBasePass(GraphBuilder, ...);

    (...)

    // Shadows, lumen and fog after base pass
    if (!bHasRayTracedOverlay)
    {
        (...)
        
         RenderShadowDepthMaps(GraphBuilder, ...);
    
        (...)

#if RHI_RAYTRACING
        // 如果需要硬件光追阴影，Lumen场景照明要求光线追踪场景准备就绪
        if (Lumen::UseHardwareRayTracedSceneLighting(ViewFamily))
        {
            WaitForRayTracingScene(GraphBuilder, DynamicGeometryScratchBuffer);
            bRayTracingSceneReady = true;
        }
#endif
        (...)
    }
        
    (...)

#if RHI_RAYTRACING
    // 如果Lumen没有强制较早的光线追踪场景同步，则必须在此处等待。
    if (!bRayTracingSceneReady)
    {
        WaitForRayTracingScene(GraphBuilder, DynamicGeometryScratchBuffer);
        bRayTracingSceneReady = true;
    }
#endif

    if (bRenderDeferredLighting)
    {
        (...)

    #if RHI_RAYTRACING
        // 渲染抖动的LOD过渡遮罩.
        RenderDitheredLODFadingOutMask(GraphBuilder, Views[0], SceneTextures.Depth.Target);
    #endif

        (...)
        
        // 渲染光源.
        RenderLights(GraphBuilder, ...);
        
        (...)

    #if RHI_RAYTRACING
        // 渲染光追的天空光并组合.
        RenderRayTracingSkyLight(GraphBuilder, ...);
        CompositeRayTracingSkyLight(GraphBuilder, ...);
    #endif
    }
    
    (...)

    // 半透明
    if (!bHasRayTracedOverlay && TranslucencyViewsToRender != ETranslucencyView::None)
    {
        (...)

    #if RHI_RAYTRACING
        // 渲染光追半透明.
        RenderRayTracingTranslucency(GraphBuilder, SceneTextures.Color);
        EnumRemoveFlags(TranslucencyViewsToRender, ETranslucencyView::RayTracing);
    #endif
        
        (...)

        // 渲染非光追半透明.
        RenderTranslucency(GraphBuilder, ...);

        (...)
    }
    
    (...)
    
#if RHI_RAYTRACING
    // 路径追踪
    RenderPathTracing(GraphBuilder, View, ...);
#endif

    (...)

    // 后处理.
    AddPostProcessingPasses(GraphBuilder, View, ...);

    (...)

#if RHI_RAYTRACING
    // 释放光追资源.
    ReleaseRaytracingResources(GraphBuilder, Views, Scene->RayTracingScene);
#endif

    (...)
}

按传统惯例，是时候来一发流程图了：

对应RenderDoc的截帧如下：

由于RenderDoc无法截取硬件光线追踪的详情，博主本想通过Windows PIX截帧，但发现PIX有BUG（也可能是驱动或UE的），无法正常截取UE5.0.3，截帧数据非常不完整：

如果想在UE5中启用PIX截帧调试，可参阅：

• PIX GPU Captures
• PIX for Windows
• NVIDIA Development Tools Solutions - ERR_NVGPUCTRPERM: Permission issue with Performance Counters
• Tips & Tricks: How the Pros Use PIX to Make Their Games Better on Xbox and Windows

光追相关的步骤简要说明如下：

• GatherRayTracingWorldInstancesForView：

  • 通过RayTracingCollector收集view中可用于光追的物体，会区分动态和静态物体。

• DispatchRayTracingWorldUpdates：

  • 获取scene的RayTracingSkinnedGeometryUpdateQueue，通过GraphBuilder提交。
  • GRayTracingGeometryManager处理光追物体的加速结构构建请求。
  • GRayTracingGeometryManager强制构建RayTracingScene.GeometriesToBuild。
  • 创建动态几何体缓冲区。
  • 向GraphBuilder增加RayTracingScene Pass。

• WaitForRayTracingScene：

  • 调用SetupRayTracingPipelineStates以设置光追管线状态。
  • 如果场景有任何内联光追物体，则调用SetupLumenHardwareRayTracingHitGroupBuffer以支持Lumen硬件光追加速。
  • 向GraphBuilder添加WaitForRayTracingScene Pass：
    • 利用TaskGraph等待ReferenceView.RayTracingMaterialBindingsTask处理完成。执行于Local渲染线程。
    • 处理ReferenceView.RayTracingMaterialBindings，尝试合并它们。
    • 调用RHICmdList.SetRayTracingHitGroups，以设置光追命中组。
    • 处理Lumen光追硬件加速。
    • 调用SetupRayTracingLightingMissShader以设置未命中着色器。
    • 处理GPU资源转换。

• RenderLights：

  • 如果光源是光追模式，且启用了光追阴影，则调用RenderRayTracingShadows执行光追阴影计算。
  • 对光追阴影执行降噪（如果启用）。

• RenderRayTracingSkyLight：

  • GenerateSkyLightVisibilityRays生成天空光可见光线。
  • 根据上一步骤生成的天空光可见光线构建加速结构。
  • 向GraphBuilder添加SkyLightRayTracing的Pass。
  • 对天空光的追踪结果执行降噪。

• CompositeRayTracingSkyLight：

  • 将天空光追踪降噪后的结果组合到场景颜色中。

• RenderRayTracingTranslucency：

  • 遍历每个view，对存在半透明光追物体的view调用RenderRayTracingPrimaryRaysView，以绘制半透明物体的光照结果。
  • 将半透明纹理结合到场景颜色中。

• RenderPathTracing：

  • 检测view的状态是否改变，如果是，则置之前的追踪结果为无效，并重现开始路径追踪。

  • 向GraphBuilder添加路径追踪的Pass。

    • 如果反弹此处大于0，则调用RHICmdList.RayTraceDispatchIndirect。
    • 否则，调用RHICmdList.RayTraceDispatch。

  • 如果需要降噪，则对路径追踪结果执行降噪。

  • 执行全屏绘制，以显示路径追踪结果。

• ReleaseRaytracingResources：

  • 向GraphBuilder添加释放光追资源的Pass，释放的资源包含光追场景、次表面、光照数据等。

主要的流程和步骤已经阐述完毕。下面小节将对部分重要的特性进行剖析。

17.6.4 UE光追光影

17.6.4.1 RenderLights

光追光影的渲染过程集成在了FDeferredShadingSceneRenderer::RenderLights中：

// LightRendering.cpp

void FDeferredShadingSceneRenderer::RenderLights(FRDGBuilder& GraphBuilder, ...)
{
    (...)
    
    // 非合批光源，处理RHI预处理阴影遮罩纹理PreprocessedShadowMaskTextures。
    if (RHI_RAYTRACING && bDoShadowBatching)
    {
        (...)
        
        // 分配PreprocessedShadowMaskTextures
        if (!View.bStatePrevViewInfoIsReadOnly)
        {
            View.ViewState->PrevFrameViewInfo.ShadowHistories.Empty();
            View.ViewState->PrevFrameViewInfo.ShadowHistories.Reserve(SortedLights.Num());
        }

        PreprocessedShadowMaskTextures.SetNum(SortedLights.Num());

        (...)
    }
    
    (...)
    
    for (int32 LightIndex = UnbatchedLightStart; LightIndex < SortedLights.Num(); LightIndex++)
    {
        (...)
        
        // 确定此灯光是否还没有预处理阴影，如果需要，执行批处理以摊销成本.
        if (RHI_RAYTRACING && bWantsBatchedShadow && (PreprocessedShadowMaskTextures.Num() == 0 || !PreprocessedShadowMaskTextures[LightIndex - UnbatchedLightStart]))
        {
            (...)

            // 处理降噪批次.
            const auto QuickOffDenoisingBatch = [&]
            {
                (...)

                TStaticArray Outputs;

                // 降噪阴影遮罩纹理.
                DenoiserToUse->DenoiseShadowVisibilityMasks(GraphBuilder, View, ...);

                for (int32 i = 0; i < InputParameterCount; i++)
                {
                    const FLightSceneInfo* LocalLightSceneInfo = DenoisingQueue[i].LightSceneInfo;

                    int32 LocalLightIndex = LightIndices[i];
                    FRDGTextureRef& RefDestination = PreprocessedShadowMaskTextures[LocalLightIndex - UnbatchedLightStart];
                    check(RefDestination == nullptr);
                    RefDestination = Outputs[i].Mask;
                    DenoisingQueue[i].LightSceneInfo = nullptr;
                }
            };

            // 光线追踪需要的光线阴影，并快速关闭降噪批次。
            for (int32 LightBatchIndex = LightIndex; LightBatchIndex < SortedLights.Num(); LightBatchIndex++)
            {
                const FSortedLightSceneInfo& BatchSortedLightInfo = SortedLights[LightBatchIndex];
                const FLightSceneInfo& BatchLightSceneInfo = *BatchSortedLightInfo.LightSceneInfo;

                // 降噪器不支持纹理矩形光源的重要性采样。
                const bool bBatchDrawShadows = BatchSortedLightInfo.SortKey.Fields.bShadowed;

                (...)

                // 如果降噪器不支持此光线追踪配置，则不值得进行批处理并增加内存压力。
                if (bRequiresDenoiser && DenoiserRequirements != IScreenSpaceDenoiser::EShadowRequirements::PenumbraAndClosestOccluder)
                {
                    continue;
                }

                (...)

                // 执行光线追踪阴影.
                FRDGTextureUAV* RayHitDistanceUAV = GraphBuilder.CreateUAV(FRDGTextureUAVDesc(RayDistanceTexture));
                {
                    // 光线追踪不透明几何体投射到发丝几何体上的阴影. 注意：此输出不需要降噪器，因为发丝具有几何噪声，因此很难降噪.
                    RenderRayTracingShadows(GraphBuilder, SceneTextureParameters, View, BatchLightSceneInfo, BatchRayTracingConfig, DenoiserRequirements, LightingChannelsTexture, RayTracingShadowMaskUAV, RayHitDistanceUAV, SubPixelRayTracingShadowMaskUAV);

                    (...)
                }

                bool bBatchFull = false;

                // 将光线追踪从排队取出以对阴影降噪。
                if (bRequiresDenoiser)
                {
                    for (int32 i = 0; i < IScreenSpaceDenoiser::kMaxBatchSize; i++)
                    {
                        if (DenoisingQueue[i].LightSceneInfo == nullptr)
                        {
                            DenoisingQueue[i].LightSceneInfo = &BatchLightSceneInfo;
                            DenoisingQueue[i].RayTracingConfig = RayTracingConfig;
                            DenoisingQueue[i].InputTextures.Mask = RayTracingShadowMaskTexture;
                            DenoisingQueue[i].InputTextures.ClosestOccluder = RayDistanceTexture;
                            LightIndices[i] = LightBatchIndex;

                            // 如果此灯类型的队列已满，则快速批处理。
                            if ((i + 1) == MaxDenoisingBatchSize)
                            {
                                QuickOffDenoisingBatch();
                                bBatchFull = true;
                            }
                            break;
                        }
                        else
                        {
                            check((i - 1) < IScreenSpaceDenoiser::kMaxBatchSize);
                        }
                    }
                }
                else // 不需要降噪, 直接存到处理预处理阴影遮罩纹理数组中.
                {
                    PreprocessedShadowMaskTextures[LightBatchIndex - UnbatchedLightStart] = RayTracingShadowMaskTexture;
                }

                // 如果填充的降噪批次或达到最大光批次，则终止批次.
                ProcessShadows++;
                if (bBatchFull || ProcessShadows == MaxRTShadowBatchSize)
                {
                    break;
                }
            }

            // 确保处理所有降噪队列。
            if (DenoisingQueue[0].LightSceneInfo)
            {
                QuickOffDenoisingBatch();
            }
        }
        
        (...)
    }
    
    (...)
}

对光追阴影补充以下几点说明：

• 不同类型的光源开启光追阴影的条件有所不同：

  // LightRendering.cpp
  
  // 根据不同类型的光源判断是否可以开启光追阴影。
  static bool ShouldRenderRayTracingShadowsForLightType(ELightComponentType LightType)
  {
      switch(LightType)
      {
      case LightType_Directional:
          return !!CVarRayTracingShadowsDirectionalLight.GetValueOnRenderThread();
      case LightType_Point:
          return !!CVarRayTracingShadowsPointLight.GetValueOnRenderThread();
      case LightType_Spot:
          return !!CVarRayTracingShadowsSpotLight.GetValueOnRenderThread();
      case LightType_Rect:
          return !!CVarRayTracingShadowsRectLight.GetValueOnRenderThread();
      default:
          return true;    
      }    
  }
  
  // 判断是否可以渲染光追阴影。
  bool ShouldRenderRayTracingShadows()
  {
      const bool bIsStereo = GEngine->StereoRenderingDevice.IsValid() && GEngine->StereoRenderingDevice->IsStereoEnabled();
      const bool bHairStrands = IsHairStrandsEnabled(EHairStrandsShaderType::Strands);
  
      return ShouldRenderRayTracingEffect((CVarRayTracingOcclusion.GetValueOnRenderThread() > 0) && !(bIsStereo && bHairStrands), ERayTracingPipelineCompatibilityFlags::FullPipeline, nullptr);
  }
  
  // 判断光源场景代表是否可开启光追阴影。
  bool ShouldRenderRayTracingShadowsForLight(const FLightSceneProxy& LightProxy)
  {
      const bool bShadowRayTracingAllowed = ShouldRenderRayTracingEffect(true, ERayTracingPipelineCompatibilityFlags::FullPipeline, nullptr);
      return (LightProxy.CastsRaytracedShadow() == ECastRayTracedShadow::Enabled || (ShouldRenderRayTracingShadows() && LightProxy.CastsRaytracedShadow() == ECastRayTracedShadow::UseProjectSetting))
          && ShouldRenderRayTracingShadowsForLightType((ELightComponentType)LightProxy.GetLightType())
          && bShadowRayTracingAllowed;
  }
  
  // 判断光源信息是否可开启光追阴影。
  bool ShouldRenderRayTracingShadowsForLight(const FLightSceneInfoCompact& LightInfo)
  {
      const bool bShadowRayTracingAllowed = ShouldRenderRayTracingEffect(true, ERayTracingPipelineCompatibilityFlags::FullPipeline, nullptr);
      return (LightInfo.CastRaytracedShadow == ECastRayTracedShadow::Enabled || (ShouldRenderRayTracingShadows() && LightInfo.CastRaytracedShadow == ECastRayTracedShadow::UseProjectSetting))
          && ShouldRenderRayTracingShadowsForLightType((ELightComponentType)LightInfo.LightType)
          && bShadowRayTracingAllowed;
  }
  

• 阴影降噪时会进行合批，以减少批次和状态切换，提升效率。

• 并非所有阴影都需要降噪。阴影降噪的条件包含：

  • 光源类型满足特定条件：矩形光源、角度大于0的平行光或半径大于0的点光源或聚光灯。

    static bool LightRequiresDenosier(const FLightSceneInfo& LightSceneInfo)
    {
        ELightComponentType LightType = ELightComponentType(LightSceneInfo.Proxy->GetLightType());
        if (LightType == LightType_Directional)
        {
            return LightSceneInfo.Proxy->GetLightSourceAngle() > 0;
        }
        else if (LightType == LightType_Point || LightType == LightType_Spot)
        {
            return LightSceneInfo.Proxy->GetSourceRadius() > 0;
        }
        else if (LightType == LightType_Rect)
        {
            return true;
        }
        return false;
    }
    

  • 阴影需求类型是IScreenSpaceDenoiser::EShadowRequirements::PenumbraAndClosestOccluder。

  • 不是带有重要性采样的纹理矩形光源类型。

17.6.4.2 RenderRayTracingShadows

本小节阐述光追阴影的具体过程。

// RayTracingShadows.cpp

void FDeferredShadingSceneRenderer::RenderRayTracingShadows(FRDGBuilder& GraphBuilder, ...)
#if RHI_RAYTRACING
{
    FLightSceneProxy* LightSceneProxy = LightSceneInfo.Proxy;
    
    (...)

    // 阴影遮挡的光线生成Pass。
    {
        (...)
        
        // 填充FOcclusionRGS参数。
        FOcclusionRGS::FParameters* PassParameters = GraphBuilder.AllocParameters();
        PassParameters->RWOcclusionMaskUAV = OutShadowMaskUAV;
        PassParameters->RWRayDistanceUAV = OutRayHitDistanceUAV;
        PassParameters->RWSubPixelOcclusionMaskUAV = SubPixelRayTracingShadowMaskUAV;
        PassParameters->SamplesPerPixel = RayTracingConfig.RayCountPerPixel;
        PassParameters->NormalBias = GetRaytracingMaxNormalBias();
        PassParameters->LightingChannelMask = LightSceneProxy->GetLightingChannelMask();
        
        (...)

        // FOcclusionRGS的shader。
        TShaderMapRef RayGenerationShader(GetGlobalShaderMap(FeatureLevel), PermutationVector);

        // 清理无用的RDG资源。
        ClearUnusedGraphResources(RayGenerationShader, PassParameters);

        (...)

        // 增加RayTracedShadow的通道。
        GraphBuilder.AddPass(
            RDG_EVENT_NAME("RayTracedShadow (spp=%d) %dx%d", RayTracingConfig.RayCountPerPixel, Resolution.X, Resolution.Y),
            PassParameters,
            // Pass标记是Compute。
            ERDGPassFlags::Compute,
            [this, &View, RayGenerationShader, PassParameters, Resolution](FRHIRayTracingCommandList& RHICmdList)
        {
            FRayTracingShaderBindingsWriter GlobalResources;
            SetShaderParameters(GlobalResources, RayGenerationShader, *PassParameters);

            FRHIRayTracingScene* RayTracingSceneRHI = View.GetRayTracingSceneChecked();

             // 启用光追材质.
            if (GRayTracingShadowsEnableMaterials)
            {
                // 向RHI派发光追命令.
                RHICmdList.RayTraceDispatch(View.RayTracingMaterialPipeline, RayGenerationShader.GetRayTracingShader(), RayTracingSceneRHI, GlobalResources, Resolution.X, Resolution.Y);
            }
            // 不启用光追材质.
            else 
            {
                // 初始化光追管线状态.
                FRayTracingPipelineStateInitializer Initializer;
                Initializer.MaxPayloadSizeInBytes = RAY_TRACING_MAX_ALLOWED_PAYLOAD_SIZE; 

                FRHIRayTracingShader* RayGenShaderTable[] = { RayGenerationShader.GetRayTracingShader() };
                Initializer.SetRayGenShaderTable(RayGenShaderTable);

                FRHIRayTracingShader* HitGroupTable[] = { View.ShaderMap->GetShader().GetRayTracingShader() };
                Initializer.SetHitGroupTable(HitGroupTable);
                // 禁用SBT索引，以便对场景中的所有几何体使用相同的命中着色器。
                Initializer.bAllowHitGroupIndexing = false; 

                FRayTracingPipelineState* Pipeline = PipelineStateCache::GetAndOrCreateRayTracingPipelineState(RHICmdList, Initializer);

                // 向RHI派发光追命令.
                RHICmdList.RayTraceDispatch(Pipeline, RayGenerationShader.GetRayTracingShader(), RayTracingSceneRHI, GlobalResources, Resolution.X, Resolution.Y);
            }
        });
    }
}

光追阴影的着色器是FOcclusionRGS，其对应的shader文件是RayTracingOcclusionRGS.usf。下面对其进行分析：

// RayTracingOcclusionRGS.usf

RAY_TRACING_ENTRY_RAYGEN(OcclusionRGS)
{
    uint2 PixelCoord = DispatchRaysIndex().xy + View.ViewRectMin.xy + PixelOffset;

    FOcclusionResult Occlusion = InitOcclusionResult();
    FOcclusionResult HairOcclusion = InitOcclusionResult();

    const uint RequestedSamplePerPixel = ENABLE_MULTIPLE_SAMPLES_PER_PIXEL ? SamplesPerPixel : 1;
    uint LocalSamplesPerPixel = RequestedSamplePerPixel;

    if (all(PixelCoord >= LightScissor.xy) && all(PixelCoord <= LightScissor.zw)) // 确保不越界
    {
        // 随机序列.
        RandomSequence RandSequence;
        uint LinearIndex = CalcLinearIndex(PixelCoord);
        RandomSequence_Initialize(RandSequence, LinearIndex, View.StateFrameIndex);

        FLightShaderParameters LightParameters = GetRootLightShaderParameters(PrimaryView.PreViewTranslation);

        // 获取GBuffer数据.
        float2 InvBufferSize = View.BufferSizeAndInvSize.zw;
        float2 BufferUV = (float2(PixelCoord) + 0.5) * InvBufferSize;
        float3 WorldNormal = 0;
        uint ShadingModelID = SHADINGMODELID_UNLIT;
        
        (...)

        // 屏蔽掉无限远的深度值.
        float DeviceZ = SceneDepthTexture.Load(int3(PixelCoord, 0)).r;
        const bool bIsDepthValid = SceneDepthTexture.Load(int3(PixelCoord, 0)).r > 0.0;
        const bool bIsValidPixel = ShadingModelID != SHADINGMODELID_UNLIT && bIsDepthValid;
        const uint LightChannel = GetSceneLightingChannel(PixelCoord);
        const bool bTraceRay = bIsValidPixel && (LightChannel & LightingChannelMask) != 0;
        if (!bTraceRay)
        {
            LocalSamplesPerPixel = 0;
        }

        (...)

        // 计算遮挡.
        Occlusion = ComputeOcclusion(PixelCoord, ShadingModelID, RAY_TRACING_MASK_SHADOW | RAY_TRACING_MASK_THIN_SHADOW, DeviceZ, WorldNormal, LightParameters, TransmissionProfileParams, LocalSamplesPerPixel);

        (...)
    }

    (...)

    // 计算遮挡到阴影.
    const float Shadow = OcclusionToShadow(Occlusion, LocalSamplesPerPixel);

    // 根据不同的降噪输出维度, 保存不同的结果. 
    if (DIM_DENOISER_OUTPUT == 2)
    {
        RWOcclusionMaskUAV[PixelCoord] = float4(Shadow, Occlusion.ClosestRayDistance, 0, Occlusion.TransmissionDistance);

    }
    else if (DIM_DENOISER_OUTPUT == 1)
    {
        float AvgHitDistance = -1.0;
        if (Occlusion.HitCount > 0.0)
        {
            AvgHitDistance = Occlusion.SumRayDistance / Occlusion.HitCount;
        }
        else if (Occlusion.RayCount > 0.0)
        {
            AvgHitDistance = 1.0e27;
        }

        RWOcclusionMaskUAV[PixelCoord] = float4(Shadow, Occlusion.TransmissionDistance, Shadow, Occlusion.TransmissionDistance);
        RWRayDistanceUAV[PixelCoord] = AvgHitDistance;
    }
    else
    {
        const float ShadowFadeFraction = 1;
        float SSSTransmission = Occlusion.TransmissionDistance;

        // 0为阴影，1为非阴影，除非写入SceneColor，否则不需要RETURN_COLOR.
        float FadedShadow = lerp(1.0f, Square(Shadow), ShadowFadeFraction);
        float FadedSSSShadow = lerp(1.0f, Square(SSSTransmission), ShadowFadeFraction);

        // 通道指定记录在ShadowRendering.cpp（寻找光衰减信道分配）.
        float4 OutColor;
        if (LIGHT_TYPE == LIGHT_TYPE_DIRECTIONAL)
        {
            OutColor = EncodeLightAttenuation(half4(FadedShadow, FadedSSSShadow, 1.0, FadedSSSShadow));
        }
        else
        {
            OutColor = EncodeLightAttenuation(half4(FadedShadow, FadedSSSShadow, FadedShadow, FadedSSSShadow));
        }

        RWOcclusionMaskUAV[PixelCoord] = OutColor;
    }
}

上述涉及了几个重要的函数，继续分析之：

// 遮挡变成阴影，就是可见样本/总样本。
float OcclusionToShadow(FOcclusionResult In, uint LocalSamplesPerPixel)
{
    return (LocalSamplesPerPixel > 0) ? In.Visibility / LocalSamplesPerPixel : In.Visibility;
}

// 计算光线遮挡.
FOcclusionResult ComputeOcclusion(...)
{
    FOcclusionResult Out = InitOcclusionResult();
    const float3 WorldPosition = ReconstructWorldPositionFromDeviceZ(PixelCoord, DeviceZ);
    
    (...)

    uint TimeSeed = View.StateFrameIndex;

    // 根据不同的样本数量进行可见性测试.
#if ENABLE_MULTIPLE_SAMPLES_PER_PIXEL
    LOOP for (uint SampleIndex = 0; SampleIndex < LocalSamplesPerPixel; ++SampleIndex)
#else 
    do if (LocalSamplesPerPixel > 0)
#endif
    {
        // 处理随机序列.
        RandomSequence RandSequence;
#if ENABLE_MULTIPLE_SAMPLES_PER_PIXEL
        RandomSequence_Initialize(RandSequence, PixelCoord, SampleIndex, TimeSeed, LocalSamplesPerPixel);
#else
        RandomSequence_Initialize(RandSequence, PixelCoord, 0, TimeSeed, 1);
#endif
        float2 RandSample = RandomSequence_GenerateSample2D(RandSequence);

        // 生成光线.
        RayDesc Ray;
        bool bIsValidRay = GenerateOcclusionRay(LightParameters, ...);
            
        uint Stencil = SceneStencilTexture.Load(int3(PixelCoord, 0)) STENCIL_COMPONENT_SWIZZLE;
        bool bDitheredLODFadingOut = Stencil & 1;
        
        (...)

        BRANCH
        if (!bIsValidRay && (DIM_DENOISER_OUTPUT == 0))
        {
            // 降噪器仍然必须追踪无效的光线，以获得正确的最近命中距离.
            continue;
        }
        else if (bApplyNormalCulling && dot(WorldNormal, Ray.Direction) <= 0.0)
        {
            continue;
        }

        // 衰减检测.
        if (LightParameters.InvRadius > 0.0)
        {
            const float MaxAttenuationDistance = 1.0 / LightParameters.InvRadius;
            if (Ray.TMax > MaxAttenuationDistance)
            {
                continue;
            }
        }

        uint RayFlags = 0;

        // 如果不在双面阴影投射模式中使用，则启用背面剔除。
        if (bTwoSidedGeometry != 1)
        {
            RayFlags |= RAY_FLAG_CULL_BACK_FACING_TRIANGLES;
        }

        (...)

        uint RayFlagsForOpaque = bAcceptFirstHit != 0 ? RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH : 0;

        // 追踪可见光线.
        FMinimalPayload MinimalPayload = TraceVisibilityRay(TLAS, RayFlags | RayFlagsForOpaque, RaytracingMask, PixelCoord, Ray);

        (...)

        Out.RayCount += 1.0;
        // 有命中物体.
        if (MinimalPayload.IsHit())
        {
            float HitT = MinimalPayload.HitT;

            Out.ClosestRayDistance = (Out.ClosestRayDistance == DENOISER_INVALID_HIT_DISTANCE) || (HitT < Out.ClosestRayDistance) ? HitT : Out.ClosestRayDistance;
            Out.SumRayDistance += HitT;
            Out.HitCount += 1.0;

            if (ShadingModelID == SHADINGMODELID_SUBSURFACE || ShadingModelID == SHADINGMODELID_HAIR)
            {
                (...)
            }
        }
        // 未命中物体.
        else
        {
            Out.ClosestRayDistance = (Out.ClosestRayDistance == DENOISER_INVALID_HIT_DISTANCE) ? DENOISER_MISS_HIT_DISTANCE : Out.ClosestRayDistance;
            Out.TransmissionDistance += 1.0;
            Out.Visibility += 1.0;
        }
    }
    
    (...)

    // 输出结果.
    if (ENABLE_TRANSMISSION && LocalSamplesPerPixel > 0 && ShadingModelID == SHADINGMODELID_SUBSURFACE_PROFILE)
    {
        (...)
    }
    else if (ShadingModelID == SHADINGMODELID_SUBSURFACE || ShadingModelID == SHADINGMODELID_HAIR)
    {
        (...)
    }
    else
    {
        Out.TransmissionDistance = (LocalSamplesPerPixel > 0) ? Out.Visibility / LocalSamplesPerPixel : Out.Visibility;
    }
    return Out;
}

下面对生成随机序列、生成光线、追踪可见光线进行分析：

// PathTracingRandomSequence.ush

// 生成二维随机序列。
float2 RandomSequence_GenerateSample2D(inout RandomSequence RandSequence)
{
    float2 Result;
    // 纯随机.
#if RANDSEQ == RANDSEQ_PURERANDOM
    Result.x = Rand(RandSequence.SampleSeed);
    Result.y = Rand(RandSequence.SampleSeed);
    // Halton随机序列.
#elif RANDSEQ == RANDSEQ_HALTON
    Result.x = Halton(RandSequence.SampleIndex, Prime512(RandSequence.SampleSeed + 0));
    Result.y = Halton(RandSequence.SampleIndex, Prime512(RandSequence.SampleSeed + 1));
    RandSequence.SampleSeed += 2;
    // Sobol随机序列.
#elif RANDSEQ == RANDSEQ_OWENSOBOL
    Result = SobolSampler(RandSequence.SampleIndex, RandSequence.SampleSeed).xy;
#endif
    return Result;
}

// RayTracingDirectionalLight.ush

// 生成平行光遮挡光线.
void GenerateDirectionalLightOcclusionRay(...)
{
    // 绘制随机变量并在单位圆盘上选择一个点.
    float2 BufferSize = View.BufferSizeAndInvSize.xy;

    float2 DiskUV = UniformSampleDiskConcentric(RandSample) * LightParameters.SourceRadius;

    // 在单位球体上按用户定义的半径排列灯光方向.
    float3 LightDirection = LightParameters.Direction;
    float3 N = LightDirection;
    float3 dPdu = float3(1, 0, 0);
    if (dot(N, dPdu) != 0)
    {
        dPdu = cross(N, dPdu);
    }
    else
    {
        dPdu = cross(N, float3(0, 1, 0));
    }
    float3 dPdv = cross(dPdu, N);
    LightDirection += dPdu * DiskUV.x + dPdv * DiskUV.y;
    
    RayOrigin = WorldPosition;
    RayDirection = normalize(LightDirection);
    RayTMin = 0.0;
    RayTMax = 1.0e27;
}

// RayTracingPointLight.ush

// 生成点光源遮挡光线.
bool GeneratePointLightOcclusionRay(...)
{
    float3 LightDirection = LightParameters.Position - WorldPosition;
    float RayLength = length(LightDirection);
    LightDirection /= RayLength;

    // 定义光线时应用法线扰动.
    RayOrigin = WorldPosition;
    RayDirection = LightDirection;
    RayTMin = 0.0;
    RayTMax = RayLength;
    return true;
}

// RayTracingSphereLight.ush

// 用区域采样生成球体光源遮挡光线.
bool GenerateSphereLightOcclusionRayWithAreaSampling(...)
{
    float4 Result = UniformSampleSphere(RandSample);
    float3 LightNormal = Result.xyz;
    float3 LightPosition = LightParameters.Position + LightNormal * LightParameters.SourceRadius;
    float3 LightDirection = LightPosition - WorldPosition;
    float RayLength = length(LightDirection);
    LightDirection /= RayLength;

    RayOrigin = WorldPosition;
    RayDirection = LightDirection;
    RayTMin = 0.0;
    RayTMax = RayLength;

    float SolidAnglePdf = Result.w * saturate(dot(LightNormal, -LightDirection)) / (RayLength * RayLength);
    RayPdf = SolidAnglePdf;
    return true;
}

// 用立体角采样生成球体光源遮挡光线.
bool GenerateSphereLightOcclusionRayWithSolidAngleSampling(...)
{
    (...)
    
    // 确定着色点是否包含在球体灯光中.
    float3 LightDirection = LightParameters.Position - WorldPosition;
    float RayLength2 = dot(LightDirection, LightDirection);
    float Radius2 = LightParameters.SourceRadius * LightParameters.SourceRadius;

    BRANCH
    if (RayLength2 <= Radius2)
    {
        return GenerateSphereLightOcclusionRayWithAreaSampling(...);
    }

    // 围绕与z轴对齐的圆锥体均匀采样.
    float SinThetaMax2 = Radius2 / RayLength2;
    float4 DirAndPdf = UniformSampleConeConcentricRobust(RandSample, SinThetaMax2);
    float CosTheta = DirAndPdf.z;
    float SinTheta2 = 1.0 - CosTheta * CosTheta;

    RayOrigin = WorldPosition;
    // 将光线方向投影到世界空间，使z轴与光照方向对齐.
    float RayLength = sqrt(RayLength2);
    LightDirection *= rcp(RayLength + 1e-4);
    RayDirection = TangentToWorld(DirAndPdf.xyz, LightDirection);

    RayTMin = 0.0;
    // 裁剪到与球体最近交点的长度.
    RayTMax = RayLength * (CosTheta - sqrt(max(SinThetaMax2 - SinTheta2, 0.0)));
    RayPdf = DirAndPdf.w;
    
    return true;
}

// RayTracingOcclusionRGS.usf

// 生成遮挡光线.
bool GenerateOcclusionRay(...)
{
    // 根据不同光源类型生成光线.
    #if LIGHT_TYPE == LIGHT_TYPE_DIRECTIONAL
    {
        GenerateDirectionalLightOcclusionRay(...);
    }
    #elif LIGHT_TYPE == LIGHT_TYPE_POINT
    {
        if (LightParameters.SourceRadius == 0)
        {
            return GeneratePointLightOcclusionRay(...);
        }
        else
        {
            float RayPdf;
            return GenerateSphereLightOcclusionRayWithSolidAngleSampling(...);
        }
    }
    #elif LIGHT_TYPE == LIGHT_TYPE_SPOT
    {
        return GenerateSpotLightOcclusionRay(...);
    }
    #elif LIGHT_TYPE == LIGHT_TYPE_RECT
    {
        float RayPdf = 0.0;
        return GenerateRectLightOcclusionRay(..);
    }
    #endif
    return true;
}

// RayTracingCommon.ush

void TraceVisibilityRayPacked(inout FPackedMaterialClosestHitPayload PackedPayload, ...)
{
    const uint RayContributionToHitGroupIndex = RAY_TRACING_SHADER_SLOT_SHADOW;
    const uint MultiplierForGeometryContributionToShaderIndex = RAY_TRACING_NUM_SHADER_SLOTS;
    const uint MissShaderIndex = 0;

    // 通过启用最小有效载荷模式，忽略所有其他有效载荷信息，意味着这些功能不需要有效载荷输入.
    PackedPayload.SetMinimalPayloadMode();
    PackedPayload.HitT = 0;
    PackedPayload.SetPixelCoord(PixelCoord);

    // 追踪光线(图形API内建函数).
    TraceRay(TLAS, RayFlags, InstanceInclusionMask, RayContributionToHitGroupIndex, MultiplierForGeometryContributionToShaderIndex, MissShaderIndex, Ray, PackedPayload);
}

FMinimalPayload TraceVisibilityRay(in RaytracingAccelerationStructure TLAS, ...)
{
    FPackedMaterialClosestHitPayload PackedPayload = (FPackedMaterialClosestHitPayload)0;
    
    if ((PayloadFlags & RAY_TRACING_PAYLOAD_INPUT_FLAG_IGNORE_TRANSLUCENT) != 0)
    {
        PackedPayload.SetIgnoreTranslucentMaterials();
    }

    // 追踪可见性光线.
    TraceVisibilityRayPacked(PackedPayload, TLAS, RayFlags, InstanceInclusionMask, PixelCoord, Ray);

    // 解压负载.
    FMinimalPayload MinimalPayload = (FMinimalPayload)0;
    // 理论上，由于FPackedMaterialClosestHitPayload源自FminiMallPayLoad，因此不需要此解包setp，但编译器目前不喜欢它们之间的直接转换。此外，如果将来HitT以不同的方式打包，并且FMinimalPayload不是直接从中继承的，则需要更改。
    MinimalPayload.HitT = PackedPayload.HitT;

    return MinimalPayload;
}

以上可知，追踪阴影的过程比较复杂，下面直接画个流程图，以便更加清晰明了：

17.6.4.3 光追阴影降噪

光追阴影的降噪器根据不同的降噪类型而定：

// LightRendering.cpp

(...)

const int32 DenoiserMode = CVarShadowUseDenoiser.GetValueOnRenderThread();
const IScreenSpaceDenoiser* DefaultDenoiser = IScreenSpaceDenoiser::GetDefaultDenoiser();
const IScreenSpaceDenoiser* DenoiserToUse = DenoiserMode == 1 ? DefaultDenoiser : GScreenSpaceDenoiser;

(...)

const auto QuickOffDenoisingBatch = [&]
{
    (...)

    // 执行降噪处理。
    DenoiserToUse->DenoiseShadowVisibilityMasks(GraphBuilder, View, &View.PrevViewInfo, SceneTextureParameters, DenoisingQueue, InputParameterCount, Outputs);

    (...)
};

(...)

由此可知，有两种阴影降噪器：IScreenSpaceDenoiser::GetDefaultDenoiser()和GScreenSpaceDenoiser。不过博主搜索了整个UE工程，发现它们其实都是同一个类型：IScreenSpaceDenoiser，下面对它进行分析：

// ScreenSpaceDenoise.cpp

class FDefaultScreenSpaceDenoiser : public IScreenSpaceDenoiser
{
public:
    virtual void DenoiseShadowVisibilityMasks(FRDGBuilder& GraphBuilder, const FViewInfo& View, ...) const
    {
        // 设置渲染纹理.
        FViewInfoPooledRenderTargets ViewInfoPooledRenderTargets;
        SetupSceneViewInfoPooledRenderTargets(View, &ViewInfoPooledRenderTargets);

        FSSDSignalTextures InputSignal;

        // 设置降噪数据.
        DECLARE_FSSD_CONSTANT_PIXEL_DENSITY_SETTINGS(SSDShadowVisibilityMasksEffectName);
        Settings.SignalProcessing = ESignalProcessing::ShadowVisibilityMask;
        (...)

        // 批处理ID.
        for (int32 BatchedSignalId = 0; BatchedSignalId < InputParameterCount; BatchedSignalId++)
        {
            Settings.MaxInputSPP = FMath::Max(Settings.MaxInputSPP, InputParameters[BatchedSignalId].RayTracingConfig.RayCountPerPixel);
        }

        // 降噪历史数据.
        TStaticArray PrevHistories;
        TStaticArray NewHistories;
        for (int32 BatchedSignalId = 0; BatchedSignalId < InputParameterCount; BatchedSignalId++)
        {
            (...)
        }

        (...)

        FSSDSignalTextures SignalOutput;
        
        // 恒定像素密度下的信号降噪.
        DenoiseSignalAtConstantPixelDensity(GraphBuilder, View, SceneTextures, ViewInfoPooledRenderTargets, InputSignal, Settings, PrevHistories, NewHistories, &SignalOutput);

        // 保存输出数据.
        for (int32 BatchedSignalId = 0; BatchedSignalId < InputParameterCount; BatchedSignalId++)
        {
            Outputs[BatchedSignalId].Mask = SignalOutput.Textures[BatchedSignalId];
        }
    }
};

以上代码涉及的DenoiseSignalAtConstantPixelDensity非常复杂，下面简单地阐述其主要步骤：

static void DenoiseSignalAtConstantPixelDensity(FRDGBuilder& GraphBuilder, const FViewInfo& View, ...)
{
    (...)

    // 创建内部降噪缓冲区的描述符和缓冲区.
    bool bHasReconstructionLayoutDifferentFromHistory = false;
    TStaticArray InjestDescs;
    TStaticArray ReconstructionDescs;
    TStaticArray HistoryDescs;
    (...)

    // 设置公共着色器参数.
    FSSDCommonParameters CommonParameters;
    {
        Denoiser::SetupCommonShaderParameters(View, SceneTextures, ...);
        (...)
    }

    // 设置所有元数据以进行空间卷积。
    FSSDConvolutionMetaData ConvolutionMetaData;
    if (Settings.SignalProcessing == ESignalProcessing::ShadowVisibilityMask)
    {
        for (int32 BatchedSignalId = 0; BatchedSignalId < Settings.SignalBatchSize; BatchedSignalId++)
        {
            FLightSceneProxy* LightSceneProxy = Settings.LightSceneInfo[BatchedSignalId]->Proxy;
            
            (...)
            
            ConvolutionMetaData.LightPositionAndRadius[BatchedSignalId] = FVector4f(TranslatedWorldPosition, Parameters.SourceRadius);
            ConvolutionMetaData.LightDirectionAndLength[BatchedSignalId] = FVector4f(Parameters.Direction, Parameters.SourceLength);
            GET_SCALAR_ARRAY_ELEMENT(ConvolutionMetaData.HitDistanceToWorldBluringRadius, BatchedSignalId) = 
                FMath::Tan(0.5 * FMath::DegreesToRadians(LightSceneProxy->GetLightSourceAngle()) * LightSceneProxy->GetShadowSourceAngleFactor());
            GET_SCALAR_ARRAY_ELEMENT(ConvolutionMetaData.LightType, BatchedSignalId) = LightSceneProxy->GetLightType();
        }
    }

    // 压缩元数据以实现更低的内存带宽、半分辨率的一致内存访问和更低的VGPR占用空间.
    ECompressedMetadataLayout CompressedMetadataLayout = GetSignalCompressedMetadata(Settings.SignalProcessing);
    if (CompressedMetadataLayout == ECompressedMetadataLayout::FedDepthAndShadingModelID)
    {
        CommonParameters.CompressedMetadata[0] = Settings.CompressedDepthTexture;
        CommonParameters.CompressedMetadata[1] = Settings.CompressedShadingModelTexture;
    }
    else if (CompressedMetadataLayout != ECompressedMetadataLayout::Disabled)
    {
        (...)
        FComputeShaderUtils::AddPass(GraphBuilder,RDG_EVENT_NAME("SSD CompressMetadata %dx%d", ...);
    }

    FSSDSignalTextures SignalHistory = InputSignal;

    // 在重建过程中预计算重建过程的某些值.
    if (SignalUsesInjestion(Settings.SignalProcessing))
    {
        (...)
        FComputeShaderUtils::AddPass(GraphBuilder,RDG_EVENT_NAME("SSD Injest(MultiSPP=%i)", ...);
        SignalHistory = NewSignalOutput;
    }

    // 使用比率估计器进行空间重建，以在历史剔除中更精确.
    if (Settings.bEnableReconstruction)
    {
        (...)
        TShaderMapRef ComputeShader(View.ShaderMap, PermutationVector);
        FComputeShaderUtils::AddPass(GraphBuilder,RDG_EVENT_NAME("SSD Reconstruction(MaxSamples=%i Scissor=%ix%i%s%s)", ...);
        SignalHistory = NewSignalOutput;
    }

    // 空间预卷积.
    for (int32 PreConvolutionId = 0; PreConvolutionId < Settings.PreConvolutionCount; PreConvolutionId++)
    {
        (...)
        TShaderMapRef ComputeShader(View.ShaderMap, PermutationVector);
        FComputeShaderUtils::AddPass(GraphBuilder,RDG_EVENT_NAME("SSD PreConvolution(MaxSamples=%d Spread=%f)", ...);
        SignalHistory = NewSignalOutput;
    }

    (...)

    // 时间Pass.
    // 注意：即使没有ViewState，也总是这样做，因为它已经不是降噪质量的理想情况，因此并不真正关心性能，并且重建可能具有与时间累积输出不同的布局。
    if (bHasReconstructionLayoutDifferentFromHistory || Settings.bUseTemporalAccumulation)
    {
        FSSDSignalTextures RejectionPreConvolutionSignal;

        // 时间拒绝可能利用可分离的预卷积.
        if (SignalUsesRejectionPreConvolution(Settings.SignalProcessing))
        {
            (...)
            TShaderMapRef ComputeShader(View.ShaderMap, PermutationVector);
            FComputeShaderUtils::AddPass(GraphBuilder,RDG_EVENT_NAME("SSD RejectionPreConvolution(MaxSamples=5)"), ...);
        }

        (...)

        TShaderMapRef ComputeShader(View.ShaderMap, PermutationVector);

        (...)

        // 设置信号的前一帧历史缓冲区.
        for (int32 BatchedSignalId = 0; BatchedSignalId < Settings.SignalBatchSize; BatchedSignalId++)
        {
            FScreenSpaceDenoiserHistory* PrevFrameHistory = PrevFilteringHistory[BatchedSignalId] ? PrevFilteringHistory[BatchedSignalId] : &DummyPrevFrameHistory;
            
            (...)
            
            PassParameters->HistoryBufferScissorUVMinMax[BatchedSignalId] = FVector4f(
                float(PrevFrameHistory->Scissor.Min.X + 0.5f) / float(PrevFrameBufferExtent.X),
                float(PrevFrameHistory->Scissor.Min.Y + 0.5f) / float(PrevFrameBufferExtent.Y),
                float(PrevFrameHistory->Scissor.Max.X - 0.5f) / float(PrevFrameBufferExtent.X),
                float(PrevFrameHistory->Scissor.Max.Y - 0.5f) / float(PrevFrameBufferExtent.Y));

            PrevFrameHistory->SafeRelease();
        }

        // 手动清除未使用的资源，以找出着色器在下一帧中实际需要什么.
        {
            ClearUnusedGraphResources(ComputeShader, PassParameters);

            (...)

            for (int32 i = 0; i < kCompressedMetadataTextures; i++)
                bExtractCompressedMetadata[i] = PassParameters->PrevCompressedMetadata[i] != nullptr;
        }

        // 增加时间累积通道.
        FComputeShaderUtils::AddPass(GraphBuilder, RDG_EVENT_NAME("SSD TemporalAccumulation%s", ...);

        SignalHistory = SignalOutput;
    } 
    
    // 空间过滤器，更快地收敛历史.
    int32 MaxPostFilterSampleCount = FMath::Clamp(Settings.HistoryConvolutionSampleCount, 1, kStackowiakMaxSampleCountPerSet);
    if (MaxPostFilterSampleCount > 1)
    {
        (...)

        TShaderMapRef ComputeShader(View.ShaderMap, PermutationVector);
        FComputeShaderUtils::AddPass(GraphBuilder,RDG_EVENT_NAME("SSD HistoryConvolution(MaxSamples=%i)", ...);

        SignalHistory = SignalOutput;
    }

    (...)

    // 最终卷积/输出校正
    if (SignalUsesFinalConvolution(Settings.SignalProcessing))
    {
        (...)

        TShaderMapRef ComputeShader(View.ShaderMap, PermutationVector);
        FComputeShaderUtils::AddPass(GraphBuilder,RDG_EVENT_NAME("SSD SpatialAccumulation(Final)"), ...);
    }
    else
    {
        *OutputSignal = SignalHistory;
    }
}

以上可知，屏幕空间降噪（SSD）过程非常复杂，涉及诸多Pass：压缩元数据、注入、重建、预卷积、拒绝预卷积、时间累积、历史卷积、空间累积等。限于篇幅，下面选取时间累积进行分析：

// SSDTemporalAccumulation.usf

void TemporallyAccumulate(...)
{
    (...)

    // 采样当前帧数据.
    FSSDCompressedSceneInfos CompressedRefSceneMetadata = SampleCompressedSceneMetadata(SceneBufferUV, BufferUVToBufferPixelCoord(SceneBufferUV));

    (...)

    // 重新投影到上一帧.
    float3 HistoryScreenPosition = float3(DenoiserBufferUVToScreenPosition(SceneBufferUV), DeviceZ);
    bool bIsDynamicPixel = false;

    float4 ThisClip = float4(HistoryScreenPosition, 1);
    float4 PrevClip = mul(ThisClip, View.ClipToPrevClip);
    float3 PrevScreen = PrevClip.xyz * rcp(PrevClip.w);
    float3 Velocity = HistoryScreenPosition - PrevScreen;

    float4 EncodedVelocity = GBufferVelocityTexture.SampleLevel(GlobalPointClampedSampler, SceneBufferUV, 0);
    bIsDynamicPixel = EncodedVelocity.x > 0.0;
    if (bIsDynamicPixel)
    {
        Velocity = DecodeVelocityFromTexture(EncodedVelocity);
    }
    HistoryScreenPosition -= Velocity;

    // 采样多路复用信号.
    FSSDSignalArray CurrentFrameSamples;
    FSSDSignalFrequencyArray CurrentFrameFrequencies;
    SampleMultiplexedSignals(SignalInput_Textures_0, SignalInput_Textures_1, ...);

    // 采样历史缓冲区.
    FSSDSignalArray HistorySamples = CreateSignalArrayFromScalarValue(0.0);
    {
        float2 HistoryBufferUV = HistoryScreenPosition.xy * ScreenPosToHistoryBufferUV.xy + ScreenPosToHistoryBufferUV.zw;
        float2 ClampedHistoryBufferUV = clamp(HistoryBufferUV, HistoryBufferUVMinMax.xy, HistoryBufferUVMinMax.zw);
        bool bIsPreviousFrameOffscreen = any(HistoryBufferUV != ClampedHistoryBufferUV);

        BRANCH
        if (!bIsPreviousFrameOffscreen)
        {
            FSSDKernelConfig KernelConfig = CreateKernelConfig();
            
            // 内核的编译时配置.
            KernelConfig.SampleSet = CONFIG_HISTORY_KERNEL;
            KernelConfig.bSampleKernelCenter = true;
            (...)

            // 在进行历史记录的双边拒绝时允许有一点错误，以容忍每帧TAA抖动.
            KernelConfig.WorldBluringDistanceMultiplier = max(CONFIG_BILATERAL_DISTANCE_MULTIPLIER, 3.0);
            
            // 设置双边预设.
            SetBilateralPreset(CONFIG_HISTORY_BILATERAL_PRESET, KernelConfig);

            // 内核的SGPR配置.
            KernelConfig.BufferSizeAndInvSize = HistoryBufferSizeAndInvSize;
            KernelConfig.BufferBilinearUVMinMax = HistoryBufferUVMinMax;
            (...)
            
            // 内核的VGPR配置.
            KernelConfig.BufferUV = HistoryBufferUV + BufferUVBilinearCorrection;
            KernelConfig.bIsDynamicPixel = bIsDynamicPixel;
            (...)

            // 计算随机信号.
            KernelConfig.Randoms[0] = InterleavedGradientNoise(SceneBufferUV * BufferUVToOutputPixelPosition, View.StateFrameIndexMod8);
            
            FSSDSignalAccumulatorArray SignalAccumulators = CreateSignalAccumulatorArray();
            FSSDCompressedSignalAccumulatorArray UnusedCompressedAccumulators = CreateUninitialisedCompressedAccumulatorArray();

            // 累积内核.
            AccumulateKernel(KernelConfig, PrevHistory_Textures_0, ...);
        
            // 从累加器导出历史样本.
            for (uint BatchedSignalId = 0; BatchedSignalId < CONFIG_SIGNAL_BATCH_SIZE; BatchedSignalId++)
            {
                (...)
            }

    (...)

    // 拒绝历史. (跟上面类似, 忽略)
    #if (CONFIG_HISTORY_REJECTION == HISTORY_REJECTION_MINMAX_BOUNDARIES || CONFIG_HISTORY_REJECTION == HISTORY_REJECTION_VAR_BOUNDARIES)
    {
        (...)
    }
    
    // 屏蔽应该输出的内容，以确保编译器编译出最终不需要的所有内容。
    uint MultiplexCount = 1;
    FSSDSignalArray OutputSamples = CreateSignalArrayFromScalarValue(0.0);
    FSSDSignalFrequencyArray OutputFrequencies = CreateInvalidSignalFrequencyArray();
    {
        MultiplexCount = CONFIG_SIGNAL_BATCH_SIZE;

        for (uint BatchedSignalId = 0; BatchedSignalId < MultiplexCount; BatchedSignalId++)
        {
            OutputSamples.Array[BatchedSignalId] = HistorySamples.Array[BatchedSignalId];
            OutputFrequencies.Array[BatchedSignalId] = CurrentFrameFrequencies.Array[BatchedSignalId];
        }
    }
    
    // 不需要保持DispatchThreadId，而SceneBufferUV处于最高VGPR峰值，因为内核的中心。
    uint2 OutputPixelPostion = BufferUVToBufferPixelCoord(SceneBufferUV);
    
    if (all(OutputPixelPostion < ViewportMax))
    {
        OutputMultiplexedSignal(SignalHistoryOutput_UAVs_0, ...);
    }
} 

上述的降噪过程和6.6.1 Temporal Super Resolution、7.4.8.2 SSGI降噪比较相似，综合使用了滤波、采样的若干种技术（双边滤波、空间卷积、时间卷积、随机采样、信号和频率等等）。

17.6.5 UE光追天空光

启用Cast Ray Traced Shadow并指定 Source Type时，天空照明支持软环境阴影。天光捕捉关卡的距离部分，并将其作为光源应用于场景中。

17.6.5.1 RenderRayTracingSkyLight

RenderRayTracingSkyLight是渲染天空光的主逻辑，其C++侧逻辑如下：

// RaytracingSkylight.cpp

void FDeferredShadingSceneRenderer::RenderRayTracingSkyLight(FRDGBuilder& GraphBuilder, ...)
{
    (...)
    
    // 填充天空光参数
    if (!SetupSkyLightParameters(GraphBuilder, Scene, Views[0], bShouldRenderRayTracingSkyLight, &SkylightParameters, &SkyLightData))
    {
        (...)
        return;
    }

    (...)
    
    // 如果解耦采样生成, 则单独生成天空光可见光线.
    if (CVarRayTracingSkyLightDecoupleSampleGeneration.GetValueOnRenderThread() == 1)
    {
        GenerateSkyLightVisibilityRays(GraphBuilder, Views[0], SkylightParameters, SkyLightData, SkyLightVisibilityRaysBuffer, SkyLightVisibilityRaysDimensions);
    }

    (...)

    for (FViewInfo& View : Views)
    {
        (...)

        TShaderMapRef RayGenerationShader(GetGlobalShaderMap(FeatureLevel), PermutationVector);

        (...)
        
        GraphBuilder.AddPass(RDG_EVENT_NAME("SkyLightRayTracing %dx%d", ...)
        {
            FRayTracingShaderBindingsWriter GlobalResources;
            SetShaderParameters(GlobalResources, RayGenerationShader, *PassParameters);

            FRayTracingPipelineState* Pipeline = View.RayTracingMaterialPipeline;
            if (CVarRayTracingSkyLightEnableMaterials.GetValueOnRenderThread() == 0)
            {
                FRayTracingPipelineStateInitializer Initializer;
                Initializer.MaxPayloadSizeInBytes = RAY_TRACING_MAX_ALLOWED_PAYLOAD_SIZE;
                // 着色器表.
                FRHIRayTracingShader* RayGenShaderTable[] = { RayGenerationShader.GetRayTracingShader() };
                Initializer.SetRayGenShaderTable(RayGenShaderTable);

                // 命中组.
                FRHIRayTracingShader* HitGroupTable[] = { View.ShaderMap->GetShader().GetRayTracingShader() };
                Initializer.SetHitGroupTable(HitGroupTable);
                Initializer.bAllowHitGroupIndexing = false;

                Pipeline = PipelineStateCache::GetAndOrCreateRayTracingPipelineState(RHICmdList, Initializer);
            }

            FRHIRayTracingScene* RayTracingSceneRHI = View.GetRayTracingSceneChecked();
            // 派发光追.
            RHICmdList.RayTraceDispatch(Pipeline, RayGenerationShader.GetRayTracingShader(), RayTracingSceneRHI, GlobalResources, RayTracingResolution.X, RayTracingResolution.Y);
        });

        // 降噪.
        if (GRayTracingSkyLightDenoiser != 0)
        {
            // 使用默认降噪器(即屏幕空间降噪器)
            const IScreenSpaceDenoiser* DefaultDenoiser = IScreenSpaceDenoiser::GetDefaultDenoiser();
            const IScreenSpaceDenoiser* DenoiserToUse = DefaultDenoiser;

            (...)

            IScreenSpaceDenoiser::FDiffuseIndirectOutputs DenoiserOutputs = DenoiserToUse->DenoiseSkyLight(GraphBuilder, ...);
        }

        (...)
    }
}

降噪过程和阴影一样，之后就不再阐述。下面分析其使用的shader代码：

// RayTracing\RayTracingSkyLightRGS.usf

RAY_TRACING_ENTRY_RAYGEN(SkyLightRGS)
{
    (...)
    
    // 获取GBuffer数据.
    FScreenSpaceData ScreenSpaceData = GetScreenSpaceData(UV);
    FGBufferData GBufferData = GetGBufferDataFromSceneTexturesLoad(PixelCoord);

    float DeviceZ = SceneDepthTexture.Load(int3(PixelCoord, 0)).r;
    float3 WorldPosition;
    float3 CameraDirection;
    ReconstructWorldPositionAndCameraDirectionFromDeviceZ(PixelCoord, DeviceZ, WorldPosition, CameraDirection);
    float3 WorldNormal = GBufferData.WorldNormal;
    float3 Albedo = GBufferData.DiffuseColor;

    (...)

    // 遮罩无限远的深度值
    bool IsFiniteDepth = DeviceZ > 0.0;
    bool bTraceRay = (IsFiniteDepth && GBufferData.ShadingModelID != SHADINGMODELID_UNLIT);
    uint SamplesPerPixel = SkyLight.SamplesPerPixel;
    if (!bTraceRay)
    {
        SamplesPerPixel = 0;
    }

    // 评估表面点处的天空光
    const bool bGBufferSampleOrigin = true;
    const bool bDecoupleSampleGeneration = DECOUPLE_SAMPLE_GENERATION != 0;
    float3 ExitantRadiance;
    float3 DiffuseExitantRadiance;
    float AmbientOcclusion;
    float HitDistance;

    // 估算天空光.
    SkyLightEvaluate(DispatchThreadId, ...);

    // 预除以反照率，在合成中恢复.
    DiffuseExitantRadiance.r = Albedo.r > 0.0 ? DiffuseExitantRadiance.r / Albedo.r : DiffuseExitantRadiance.r;
    DiffuseExitantRadiance.g = Albedo.g > 0.0 ? DiffuseExitantRadiance.g / Albedo.g : DiffuseExitantRadiance.g;
    DiffuseExitantRadiance.b = Albedo.b > 0.0 ? DiffuseExitantRadiance.b / Albedo.b : DiffuseExitantRadiance.b;

    DiffuseExitantRadiance.rgb *= View.PreExposure;

    RWSkyOcclusionMaskUAV[DispatchThreadId] = float4(ClampToHalfFloatRange(DiffuseExitantRadiance.rgb), AmbientOcclusion);
    RWSkyOcclusionRayDistanceUAV[DispatchThreadId] = float2(HitDistance, SamplesPerPixel);
}

下面分析SkyLightEvaluate：

// RayTracingSkyLightEvaluation.ush

void SkyLightEvaluate(...)
{
    // 初始化数据.
    float3 CurrentWorldNormal = WorldNormal;
    (...)

    // 在策略之间分割样本，除非天空光pdf由于MIS(多重要性采样)而为0（意味着恒定贴图）.
    const float SkyLightSamplingStrategyPdf = SkyLight_Estimate() > 0 ? 0.5 : 0.0;

    // 迭代到请求的样本计数.
    for (uint SampleIndex = 0; SampleIndex < SamplesPerPixel; ++SampleIndex)
    {
        RayDesc Ray;
        float RayWeight;

        if (bDecoupleSampleGeneration)
        {
            // 从预计算的可见性光线缓冲区中获取当前采样的可见性光线
            const uint SkyLightVisibilityRayIndex = GetSkyLightVisibilityRayTiledIndex(SampleCoord, SampleIndex, SkyLightVisibilityRaysDimensions.xy);
            FSkyLightVisibilityRays SkyLightVisibilityRay = SkyLightVisibilityRays[SkyLightVisibilityRayIndex];

            Ray.Origin = WorldPosition;
            Ray.Direction = SkyLightVisibilityRay.DirectionAndPdf.xyz;
            Ray.TMin = 0.0;
            Ray.TMax = SkyLight.MaxRayDistance;
            RayWeight = SkyLightVisibilityRay.DirectionAndPdf.w;
        }
        else // 非解耦样本生成模式.
        {
            RandomSequence RandSequence;
            RandomSequence_Initialize(RandSequence, PixelCoord, SampleIndex, View.StateFrameIndex, SamplesPerPixel);

            // 确定天光或朗伯光线.
            float2 RandSample = RandomSequence_GenerateSample2D(RandSequence);

            // 为当前采样生成可见性光线.
            float SkyLightPdf = 0;
            float CosinePdf = 0;
            BRANCH
            if (RandSample.x < SkyLightSamplingStrategyPdf)
            {
                RandSample.x /= SkyLightSamplingStrategyPdf;

                // 采样光源.
                FSkyLightSample SkySample = SkyLight_SampleLight(RandSample);
                Ray.Direction = SkySample.Direction;
                SkyLightPdf = SkySample.Pdf;

                CosinePdf = saturate(dot(CurrentWorldNormal, Ray.Direction)) / PI;
            }
            else
            {
                RandSample.x = (RandSample.x - SkyLightSamplingStrategyPdf) / (1.0 - SkyLightSamplingStrategyPdf);

                // 余弦采样半球.
                float4 CosSample = CosineSampleHemisphere(RandSample, CurrentWorldNormal);
                Ray.Direction = CosSample.xyz;
                CosinePdf = CosSample.w;

                // 计算pdf.
                SkyLightPdf = SkyLight_EvalLight(Ray.Direction).w;
            }

            Ray.Origin = WorldPosition;
            Ray.TMin = 0.0;
            Ray.TMax = SkyLight.MaxRayDistance;
            // MIS / pdf
            RayWeight = 1.0 / lerp(CosinePdf, SkyLightPdf, SkyLightSamplingStrategyPdf);
        }

        (...)

        // 基于采样世界位置是否来自GBuffer，应用深度偏移.
        float NoL = dot(CurrentWorldNormal, Ray.Direction);
        if (NoL > 0.0)
        {
            if (bGBufferSampleOrigin)
            {
                ApplyCameraRelativeDepthBias(Ray, PixelCoord, DeviceZ, CurrentWorldNormal, SkyLight.MaxNormalBias);
            }
            else
            {
                ApplyPositionBias(Ray, CurrentWorldNormal, SkyLight.MaxNormalBias);
            }
        }
        else
        {
            ApplyPositionBias(Ray, -CurrentWorldNormal, SkyLight.MaxNormalBias);
        }
        NoL = saturate(NoL);

        (...)

        // 追踪一条可见性光线.
        FMinimalPayload MinimalPayload = TraceVisibilityRay(TLAS, RayFlags, InstanceInclusionMask, PixelCoord, Ray);

        (...)
        
        if (MinimalPayload.IsHit()) // 如果命中了物体, 说明该光线不能触达到天空盒.
        {
            RayDistance += MinimalPayload.HitT;
            HitCount += 1.0;
        }
        else // 没有命中物体, 则说明该光线命中了天空盒.
        {
            BentNormal += Ray.Direction;

            // 估算材质.
            const half3 N = WorldNormal;
            const half3 V = -ViewDirection;
            const half3 L = Ray.Direction;
            FDirectLighting LightingSample;
            if (GBufferData.ShadingModelID == SHADINGMODELID_HAIR)
            {
                (...)
            }
            else
            {
                FShadowTerms ShadowTerms = { 0.0, 0.0, 0.0, InitHairTransmittanceData() };
                // 计算BxDF
                LightingSample = EvaluateBxDF(GBufferData, N, V, L, NoL, ShadowTerms);
            }
            
            float3 Brdf = LightingSample.Diffuse + LightingSample.Transmission + LightingSample.Specular;
            // 计算天空光.
            float3 IncomingRadiance = SkyLight_EvalLight(Ray.Direction).xyz;

            ExitantRadiance += IncomingRadiance * Brdf * RayWeight;
            float3 DiffuseThroughput = LightingSample.Diffuse;
            if (SkyLight.bTransmission)
            {
                DiffuseThroughput += LightingSample.Transmission;
            }
            DiffuseExitantRadiance += IncomingRadiance * DiffuseThroughput * RayWeight;
        }
    } // for

    // 样本数的平均值
    if (SamplesPerPixel > 0)
    {
        const float SamplesPerPixelInv = rcp(SamplesPerPixel);
        ExitantRadiance *= SamplesPerPixelInv;
        DiffuseExitantRadiance *= SamplesPerPixelInv;
        AmbientOcclusion = HitCount * SamplesPerPixelInv;
    }

    (...)

    // 如果碰撞到任何遮挡几何体，则计算碰撞距离.
    if (HitCount > 0.0)
    {
        HitDistance = RayDistance / HitCount;
    }

    (...)
}

上述代码调用了两次SkyLight_EvalLight，第一次为了计算天空光的pdf，第二次为了计算辐射率。SkyLight_EvalLight的解析如下：

// MonteCarlo.ush

// 逆向的等面积球面映射.
// Based on: [Clarberg 2008, "Fast Equal-Area Mapping of the (Hemi)Sphere using SIMD"]
float2 InverseEquiAreaSphericalMapping(float3 Direction)
{
    float3 AbsDir = abs(Direction);
    float R = sqrt(1 - AbsDir.z);
    float Epsilon = 5.42101086243e-20;
    float x = min(AbsDir.x, AbsDir.y) / (max(AbsDir.x, AbsDir.y) + Epsilon);

    // Coefficients for 6th degree minimax approximation of atan(x)*2/pi, x=[0,1].
    const float t1 = 0.406758566246788489601959989e-5f;
    const float t2 = 0.636226545274016134946890922156f;
    const float t3 = 0.61572017898280213493197203466e-2f;
    const float t4 = -0.247333733281268944196501420480f;
    const float t5 = 0.881770664775316294736387951347e-1f;
    const float t6 = 0.419038818029165735901852432784e-1f;
    const float t7 = -0.251390972343483509333252996350e-1f;

    // Polynomial approximation of atan(x)*2/pi
    float Phi = t6 + t7 * x;
    Phi = t5 + Phi * x;
    Phi = t4 + Phi * x;
    Phi = t3 + Phi * x;
    Phi = t2 + Phi * x;
    Phi = t1 + Phi * x;

    Phi = (AbsDir.x < AbsDir.y) ? 1 - Phi : Phi;
    float2 UV = float2(R - Phi * R, Phi * R);
    UV = (Direction.z < 0) ? 1 - UV.yx : UV;
    UV = asfloat(asuint(UV) ^ (asuint(Direction.xy) & 0x80000000u));
    return UV * 0.5 + 0.5;
}

// RayTracingSkyLightCommon.ush

float4 SkyLight_EvalLight(float3 Dir)
{
    // 利用逆向的等面积球面映射算出天空光的UV，并采样出天空光纹理的颜色.
    float2 UV = InverseEquiAreaSphericalMapping(Dir.yzx);
    float4 Result = SkylightTexture.SampleLevel(SkylightTextureSampler, UV, 0);
    float3 Radiance = Result.xyz;
    
    // 计算pdf.
#if USE_HIERARCHICAL_IMPORTANCE_SAMPLING
    float Pdf = Result.w > 0 ? Result.w / (4 * PI * SkylightPdf.Load(int3(0, 0, SkylightMipCount - 1))) : 0.0; 
#else
    float Pdf = 1.0 / (4.0 * PI);
#endif
    return float4(Radiance, Pdf);
}

17.6.5.2 CompositeRayTracingSkyLight

CompositeRayTracingSkyLight是组合RenderRayTracingSkyLight计算的结果到场景颜色中，其C++侧逻辑如下：

// RaytracingSkylight.cpp

void FDeferredShadingSceneRenderer::CompositeRayTracingSkyLight(FRDGBuilder& GraphBuilder, ...)
{
    for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
    {
        const FViewInfo& View = Views[ViewIndex];
        
        (...)
        
        GraphBuilder.AddPass(RDG_EVENT_NAME("GlobalIlluminationComposite"), ...)
        {
            // VS和PS实例.
            TShaderMapRef VertexShader(View.ShaderMap);
            TShaderMapRef PixelShader(View.ShaderMap);
            
            (...)
            
            // 叠加性(Additive)混合模式.
            GraphicsPSOInit.BlendState = TStaticBlendState::GetRHI();
            
            (...)

            DrawRectangle(RHICmdList, ...);
        });
    }
}

下面直接进入PS使用的shader代码：

// CompositeSkyLightPS.usf

void CompositeSkyLightPS(in noperspective float2 UV : TEXCOORD0, out float4 OutColor : SV_Target0)
{
    // 获取GBuffer数据.
    FGBufferData GBufferData = GetGBufferDataFromSceneTextures(UV);
    float3 Albedo = GBufferData.StoredBaseColor - GBufferData.StoredBaseColor * GBufferData.Metallic;
    // 从天空光纹理采样出数据.
    float4 SkyLight = SkyLightTexture.Sample(SkyLightTextureSampler, UV);
    // 降噪后应用反照率
    SkyLight.rgb *= Albedo;
    OutColor = SkyLight;
}

17.6.6 UE光追GI

17.6.6.1 UE光追GI开启条件

UE 5.0.3的标准光追GI已被Lumen硬件光追取代（下图），而Lumen的全局光照支持两种光线追踪模式：软件光线追踪（需要在项目设置中开启Generate Mesh Distance Fields）和硬件光线追踪（需要在项目设置中开启Support Hardware Ray Tracing）。后面只分析Lumen硬件光线追踪。

其中决定是否使用Lumen GI的代码如下：

void FDeferredShadingSceneRenderer::Render(FRDGBuilder& GraphBuilder)
{
    (...)
    
    InitViews(...);
    
    // 计算并提交渲染器的整个依赖拓扑的最终状态。
    CommitFinalPipelineState();
    
    (...)
}

void FDeferredShadingSceneRenderer::CommitFinalPipelineState()
{
    (...)

    CommitIndirectLightingState();

    (...)
}

// IndirectLightRendering.cpp

bool ShouldRenderLumenDiffuseGI(const FScene* Scene, const FSceneView& View, bool bSkipTracingDataCheck, bool bSkipProjectCheck) 
{
        // 是否可启用Lumen特性.
    return Lumen::IsLumenFeatureAllowedForView(Scene, View, bSkipTracingDataCheck, bSkipProjectCheck)
        // 动态全局光照方法是否Lumen
        && View.FinalPostProcessSettings.DynamicGlobalIlluminationMethod == EDynamicGlobalIlluminationMethod::Lumen
        // 控制台变量是否开启.
        && CVarLumenGlobalIllumination.GetValueOnAnyThread()
        // 视图家族的GI标记是否开启.
        && View.Family->EngineShowFlags.GlobalIllumination 
        && View.Family->EngineShowFlags.LumenGlobalIllumination
        // 是否使用硬件光追探针收集或者支持软件光追.
        && (bSkipTracingDataCheck || Lumen::UseHardwareRayTracedScreenProbeGather() || Lumen::IsSoftwareRayTracingSupported());
}

void FDeferredShadingSceneRenderer::CommitIndirectLightingState()
{
    for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
    {
        const FViewInfo& View = Views[ViewIndex];
        TPipelineState& ViewPipelineState = ViewPipelineStates[ViewIndex];

        EDiffuseIndirectMethod DiffuseIndirectMethod = EDiffuseIndirectMethod::Disabled;
        EAmbientOcclusionMethod AmbientOcclusionMethod = EAmbientOcclusionMethod::Disabled;
        EReflectionsMethod ReflectionsMethod = EReflectionsMethod::Disabled;
        IScreenSpaceDenoiser::EMode DiffuseIndirectDenoiser = IScreenSpaceDenoiser::EMode::Disabled;
        bool bUseLumenProbeHierarchy = false;

        // 检测是否使用Lumen GI.
        if (ShouldRenderLumenDiffuseGI(Scene, View))
        {
            DiffuseIndirectMethod = EDiffuseIndirectMethod::Lumen;
            bUseLumenProbeHierarchy = CVarLumenProbeHierarchy.GetValueOnRenderThread() != 0;
        }
        else if (ScreenSpaceRayTracing::IsScreenSpaceDiffuseIndirectSupported(View))
            
        (...)
    }
}

UseHardwareRayTracedScreenProbeGather代码如下：

// LumenScreenProbeHardwareRayTracing.cpp

bool UseHardwareRayTracedScreenProbeGather()
{
#if RHI_RAYTRACING
        // 光线追踪是否开启.
    return IsRayTracingEnabled()
        // 是否使用硬件光线追踪.
        && Lumen::UseHardwareRayTracing()
        // Lumen的屏幕探针收集硬件光追的控制台变量不为0
        && (CVarLumenScreenProbeGatherHardwareRayTracing.GetValueOnAnyThread() != 0);
#else
    return false;
#endif
}

17.6.6.2 RenderDiffuseIndirectAndAmbientOcclusion

一旦满足所有条件，则Lumen的硬件光追GI会在RenderBasePass和RenderLights之间调用RenderDiffuseIndirectAndAmbientOcclusion渲染相关GI：

void FDeferredShadingSceneRenderer::Render(FRDGBuilder& GraphBuilder)
{
    (...)
    
    RenderBasePass(...);
    
    (...)
    
    RenderDiffuseIndirectAndAmbientOcclusion(GraphBuilder, ...);
    
    (...)
    
    RenderLights(...);
    
    (...)
}

下面进入RenderDiffuseIndirectAndAmbientOcclusion分析和Lumen GI相关的逻辑：

// IndirectLightRendering.cpp

void FDeferredShadingSceneRenderer::RenderDiffuseIndirectAndAmbientOcclusion(FRDGBuilder& GraphBuilder, ...)
{
    (...)

    for (FViewInfo& View : Views)
    {
        const FPerViewPipelineState& ViewPipelineState = GetViewPipelineState(View);

        (...)

        else if (ViewPipelineState.DiffuseIndirectMethod == EDiffuseIndirectMethod::Lumen)
        {
            FLumenMeshSDFGridParameters MeshSDFGridParameters;
            LumenRadianceCache::FRadianceCacheInterpolationParameters RadianceCacheParameters;

            // 渲染Lumen屏幕探针收集.
            DenoiserOutputs = RenderLumenScreenProbeGather(GraphBuilder, ...);

            if (ViewPipelineState.ReflectionsMethod == EReflectionsMethod::Lumen)
            {
                DenoiserOutputs.Textures[2] = RenderLumenReflections(GraphBuilder, View, ...);
            }

            // Lumen需要它自己的深度历史，因为像半透明速度这样的东西会写入深度.
            StoreLumenDepthHistory(GraphBuilder, SceneTextures, View);

            if (!DenoiserOutputs.Textures[2])
            {
                DenoiserOutputs.Textures[2] = DenoiserOutputs.Textures[1];
            }
        }
        
        (...)

        // 将漫反射间接和环境光遮挡应用于场景颜色。
        if (... ViewPipelineState.DiffuseIndirectMethod == EDiffuseIndirectMethod::Lumen ...)
        {
            FDiffuseIndirectCompositePS::FParameters* PassParameters = GraphBuilder.AllocParameters();
            
            (...)
            
            else if (ViewPipelineState.DiffuseIndirectMethod == EDiffuseIndirectMethod::Lumen)
            {
                PermutationVector.Set(4);
                PermutationVector.Set(ScreenBentNormalParameters.UseScreenBentNormal != 0);
                DiffuseIndirectSampling = TEXT("ScreenProbeGather");
            }

            (...)

            FPixelShaderUtils::AddFullscreenPass(GraphBuilder, View.ShaderMap,RDG_EVENT_NAME("DiffuseIndirectComposite(DiffuseIndirect=%s%s%s%s) %dx%d", ...);
        }

        (...)
    } // for
}

17.6.6.3 RenderLumenScreenProbeGather

下面对RenderLumenScreenProbeGather的硬件光追部分进行分析：

// LumenScreenProbeGather.cpp

FSSDSignalTextures FDeferredShadingSceneRenderer::RenderLumenScreenProbeGather(FRDGBuilder& GraphBuilder, ...)
{
    (...)

    if (GLumenIrradianceFieldGather != 0)
    {
        return RenderLumenIrradianceFieldGather(GraphBuilder, SceneTextures, FrameTemporaries, View);
    }

    (...)

    auto ComputeShader = View.ShaderMap->GetShader(0);

    // 增加全局探针下采样的Pass.
    FComputeShaderUtils::AddPass(GraphBuilder,RDG_EVENT_NAME("UniformPlacement DownsampleFactor=%u", ScreenProbeParameters.ScreenProbeDownsampleFactor), ...);

    (...)

    if (ScreenProbeParameters.MaxNumAdaptiveProbes > 0 && AdaptiveProbeMinDownsampleFactor < ScreenProbeParameters.ScreenProbeDownsampleFactor)
    { 
        uint32 PlacementDownsampleFactor = ScreenProbeParameters.ScreenProbeDownsampleFactor;
        do
        {
            PlacementDownsampleFactor /= 2;
            FScreenProbeAdaptivePlacementCS::FParameters* PassParameters = GraphBuilder.AllocParameters();
            
            (...)

            auto ComputeShader = View.ShaderMap->GetShader(0);

            // 增加自适应探针放置的Pass.
            FComputeShaderUtils::AddPass(GraphBuilder,RDG_EVENT_NAME("AdaptivePlacement DownsampleFactor=%u", PlacementDownsampleFactor), ...);
        }
        while (PlacementDownsampleFactor > AdaptiveProbeMinDownsampleFactor);
    }
    
    (...)

    auto ComputeShader = View.ShaderMap->GetShader(0);

    // 设置自适应探索非直接参数的Pass.
    FComputeShaderUtils::AddPass(GraphBuilder, RDG_EVENT_NAME("SetupAdaptiveProbeIndirectArgs"), ...);

    (...)
    
    // 生成BRDF的pdf.
    GenerateBRDF_PDF(GraphBuilder, View, SceneTextures, BRDFProbabilityDensityFunction, BRDFProbabilityDensityFunctionSH, ScreenProbeParameters);

    (...)
    
    if (LumenScreenProbeGather::UseRadianceCache(View))
    {
        (...)

        // 渲染辐射率缓存.
        RenderRadianceCache(GraphBuilder, ...);

        (...)
    }

    // 生成重要性采样的光线.
    if (LumenScreenProbeGather::UseImportanceSampling(View))
    {
        GenerateImportanceSamplingRays(GraphBuilder, View, ...);
    }

    (...)

    // 追踪屏幕探针.
    TraceScreenProbes(GraphBuilder, Scene, ...);
    
    FScreenProbeGatherParameters GatherParameters;
    // 过滤屏幕探针.
    FilterScreenProbes(GraphBuilder, View, SceneTextures, ScreenProbeParameters, GatherParameters);

    (...)

    // 在屏幕空间探针中插值并集成.
    InterpolateAndIntegrate(GraphBuilder, ...);

    (...)
    
    // 降噪.
    if (GLumenScreenProbeTemporalFilter)
    {
        if (GLumenScreenProbeUseHistoryNeighborhoodClamp)
        {
            (...)

            auto ComputeShader = View.ShaderMap->GetShader(0);

            // 生成压缩的GBuffer数据.
            FComputeShaderUtils::AddPass(GraphBuilder, RDG_EVENT_NAME("GenerateCompressedGBuffer"), ...);

            (...)

            // 对非直接探针层级进行降噪.
            DenoiserOutputs = IScreenSpaceDenoiser::DenoiseIndirectProbeHierarchy(GraphBuilder, View, ...);
            bLumenUseDenoiserComposite = true;
        }
        else
        {
            // 更新历史屏幕探针收集.
            UpdateHistoryScreenProbeGather(GraphBuilder, View, ...);

            DenoiserOutputs.Textures[0] = DiffuseIndirect;
            DenoiserOutputs.Textures[1] = RoughSpecularIndirect;
        }
    }

    (...)
    
    return DenoiserOutputs;
}

17.6.6.4 TraceScreenProbes

从上可知，Lumen的GI使用了屏幕空间的光照探针，其中和硬件光追相关的是TraceScreenProbes，其它和软件光追应该是一样。下面就只分析TraceScreenProbes：

// LumenScreenProbeTracing.cpp

void TraceScreenProbes(FRDGBuilder& GraphBuilder, const FScene* Scene, ...)
{
    (...)
    
    // 清理追踪结果.
    auto ComputeShader = View.ShaderMap->GetShader(0);
    FComputeShaderUtils::AddPass(GraphBuilder, RDG_EVENT_NAME("ClearTraces %ux%u", ...);
    
    (...)
         
    // 追踪屏幕空间的探针.
    auto ComputeShader = View.ShaderMap->GetShader(PermutationVector);
    FComputeShaderUtils::AddPass(GraphBuilder, RDG_EVENT_NAME("TraceScreen(%s)", ...);
                                 
    (...)
    
    // 是否使用硬件光线追踪.
    const bool bUseHardwareRayTracing = Lumen::UseHardwareRayTracedScreenProbeGather();
    if (bUseHardwareRayTracing)
    {
        FCompactedTraceParameters CompactedTraceParameters = CompactTraces(GraphBuilder, View, ...);
        // 硬件追踪屏幕探针.
        RenderHardwareRayTracingScreenProbe(GraphBuilder, Scene, ...);
    }
    else
    {
        // 软件追踪屏幕探针.
        (...)
    }

    (...)

    // 屏幕空间追踪体素, 也分硬件和软件模式.
    PermutationVector.Set< FScreenProbeTraceVoxelsCS::FTraceVoxels>(!bUseHardwareRayTracing && Lumen::UseGlobalSDFTracing(*View.Family));
    auto ComputeShader = View.ShaderMap->GetShader(PermutationVector);
    FComputeShaderUtils::AddPass(GraphBuilder, RDG_EVENT_NAME("%s%s", ...);
}

17.6.6.5 RenderHardwareRayTracingScreenProbe

从上得知如果是硬件光追模式，则会进入RenderHardwareRayTracingScreenProbe：

// LumenScreenProbeHardwareRayTracing.cpp

void RenderHardwareRayTracingScreenProbe(FRDGBuilder& GraphBuilder, const FScene* Scene, ...)
{
    (...)
    
    // 转换光线分配器
    TShaderRef ComputeShader = View.ShaderMap->GetShader();
    FComputeShaderUtils::AddPass(GraphBuilder,RDG_EVENT_NAME("FConvertRayAllocatorCS"), ...);
    
    (...)
    
    // 【近场(near-field)】、提取表面缓存和材质id的默认追踪.
    PermutationVector.Set(true);
    PermutationVector.Set(false);
    if (bInlineRayTracing)
    {
        DispatchComputeShader(GraphBuilder, Scene, ...);
    }
    else
    {
        DispatchRayGenShader(GraphBuilder, Scene, ...);
    }
    
    (...)
    
    // 使用【远场】进行屏幕探针采集
    if (bUseFarFieldForScreenProbeGather)
    {
        // 硬件压缩光线, 以提升缓存一致性和命中率, 提升效率.
        LumenHWRTCompactRays(GraphBuilder, Scene, ...);
    
        (...)
        
        PermutationVector.Set(false);
        PermutationVector.Set(true);
        
        if (bInlineRayTracing)
        {
            DispatchComputeShader(GraphBuilder, Scene, ...);
        }
        else
        {
            DispatchRayGenShader(GraphBuilder, Scene, ...);
        }
    }
}

以上需要执行两次光线追踪，第一次是追踪近场（Near Field），第二次是追踪远场（Far Field）。追踪时支持两种模式：使用Compute Shader的内联模式和使用Ray Generate的硬件模式。下面分析它们的区别，先分析Compute Shader模式：

// LumenScreenProbeHardwareRayTracing.cpp

void DispatchComputeShader(FRDGBuilder& GraphBuilder, const FScene* Scene, ...)
{
    (...)
    
    TShaderRef ComputeShader = ...;
    
    (...)
    
    GraphBuilder.AddPass(RDG_EVENT_NAME("HardwareInlineRayTracing %s %s", ..., ERDGPassFlags::Compute,
        [PassParameters, &View, ComputeShader, DispatchResolution](FRHIRayTracingCommandList& RHICmdList)
        {
            (...)

            if (IsHardwareRayTracingScreenProbeGatherIndirectDispatch())
            {
                // 非直接模式，注意参数是PassParameters->CommonParameters.HardwareRayTracingIndirectArgs
                DispatchIndirectComputeShader(RHICmdList, ComputeShader.GetShader(), PassParameters->CommonParameters.HardwareRayTracingIndirectArgs->GetIndirectRHICallBuffer(), 0);
            }
            else
            {
                (...)
                // 直接模式.
                DispatchComputeShader(RHICmdList, ComputeShader.GetShader(), GroupCount.X, GroupCount.Y, 1);
            }

            (...)
        }
    );
}

以上可知，CS模式又支持非直接和直接两种，注意它们虽然使用同一个shader，但PassParameters的参数不一样！非直接的开启条件如下：

// LumenScreenProbeHardwareRayTracing.cpp

bool IsHardwareRayTracingReflectionsIndirectDispatch()
{
    return GRHISupportsRayTracingDispatchIndirect && (CVarLumenReflectionsHardwareRayTracingIndirect.GetValueOnRenderThread() == 1);
}

// WindowsD3D12Device.cpp

if (D3D12Caps5.RaytracingTier >= D3D12_RAYTRACING_TIER_1_1)
{
    GRHISupportsRayTracingDispatchIndirect = true;
}

也就是说需要D3D12光线追踪Tier 1.1以上（其它图形API暂不支持）以及相关控制台变量为1才开启。

相关说明可参见DX 12光追说明文档：DispatchRays和 ExecuteIndirect。

非直接模式相当于异步模式，可以提升GPU的并行度，通常效率更高。

17.6.6.6 LumenScreenProbeGatherHardwareRayTracing

下面继续分析使用Ray Generation的硬件模式：

void DispatchRayGenShader(FRDGBuilder& GraphBuilder, const FScene* Scene, ...)
{
    (...)
    
    // 生成非直接参数.
    DispatchLumenScreenProbeGatherHardwareRayTracingIndirectArgs(...);
    // 设置屏幕追踪参数.
    SetLumenHardwareRayTracingScreenProbeParameters(...);
    
    (...)
    
    TShaderRef RayGenerationShader = ...;
    
    (...)
    
    GraphBuilder.AddPass(RDG_EVENT_NAME("HardwareRayTracing %s %s", ...
        {
            (...)

            // 非直接模式
            if (IsHardwareRayTracingScreenProbeGatherIndirectDispatch())
            {
                RHICmdList.RayTraceDispatchIndirect(Pipeline, ...);
            }
            // 直接模式.
            else
            {
                RHICmdList.RayTraceDispatch(Pipeline, ...);
            }
        }
    );
}

以上可知，硬件光追也支持非直接和直接模式，如果支持非直接，则优先用之。下面分析FLumenScreenProbeGatherHardwareRayTracingRGS的shader：

// LumenScreenProbeHardwareRayTracing.usf

LUMEN_HARDWARE_RAY_TRACING_ENTRY(LumenScreenProbeGatherHardwareRayTracing)
{
    // 计算线程组和线程id.
    uint ThreadIndex = DispatchThreadIndex.x;
    uint GroupIndex = DispatchThreadIndex.y;

#if DIM_INDIRECT_DISPATCH
    uint Iteration = 0;
    uint DispatchedThreads = RayAllocator[0];
#else
    uint DispatchedThreads = ThreadCount * GroupCount;
    uint IterationCount = (RayAllocator[0] + DispatchedThreads - 1) / DispatchedThreads;
    // 直接模式则需要用for循环来实现迭代多条光线.
    for (uint Iteration = 0; Iteration < IterationCount; ++Iteration)
#endif
    {
        uint RayIndex = Iteration * DispatchedThreads + GroupIndex * ThreadCount + ThreadIndex;
        if (RayIndex >= RayAllocator[0])
        {
            return;
        }

        // 获取追踪数据.
#if (DIM_LIGHTING_MODE == LIGHTING_MODE_HIT_LIGHTING) || ENABLE_FAR_FIELD_TRACING
        FTraceData TraceData = UnpackTraceData(RWRetraceDataPackedBuffer[RayIndex]);
        uint RayId = TraceData.RayId;
#else
        uint RayId = RayIndex;
#endif
        (...)

        // 创建追踪光照上下文.
        FRayTracedLightingContext Context = CreateRayTracedLightingContext(TLAS, ...);

        (...)
        
        // 执行小误差追踪.
        FRayTracedLightingResult Result = EpsilonTrace(Ray, Context);
        
        // 如果没有命中物体
        if (!Result.bIsHit)
        {
            Ray.TMin = max(Ray.TMin, AvoidSelfIntersectionTraceDistance);
            Ray.TMax = Ray.TMin;
            // 通过近场的球体包围盒裁剪TMax
            if (length(Ray.Origin - LWCHackToFloat(PrimaryView.WorldCameraOrigin)) < MaxTraceDistance)
            {
                float2 Hit = RayIntersectSphere(Ray.Origin, Ray.Direction, float4(LWCHackToFloat(PrimaryView.WorldCameraOrigin), MaxTraceDistance));
                Ray.TMax = (Hit.x > 0) ? Hit.x : ((Hit.y > 0) ? Hit.y : Ray.TMin);
            }

            // 处理辐射度缓存命中.
            bool bIsRadianceCacheHit = false;
#if DIM_RADIANCE_CACHE
            {
                float ClipmapDitherRandom = InterleavedGradientNoise(ScreenTileCoord, View.StateFrameIndexMod8);
                FRadianceCacheCoverage Coverage = GetRadianceCacheCoverage(Ray.Origin, Ray.Direction, ClipmapDitherRandom);
                if (Coverage.bValid)
                {
                    Ray.TMax = min(Ray.TMax, Coverage.MinTraceDistanceBeforeInterpolation);
                    bIsRadianceCacheHit = true;
                }
            }
#endif

            // 设置远场上下文特例化.
            Context.FarFieldMaxTraceDistance = FarFieldMaxTraceDistance;
            Context.FarFieldReferencePos = FarFieldReferencePos;

#if DIM_LIGHTING_MODE == LIGHTING_MODE_SURFACE_CACHE
            Result = TraceAndCalculateRayTracedLightingFromSurfaceCache(Ray, Context);
#if DIM_PACK_TRACE_DATA
            RWRetraceDataPackedBuffer[RayIndex] = PackTraceData(CreateTraceData(RayId, ...));
#endif
#endif 
        }

        // 写入最终光照结果.
#if DIM_WRITE_FINAL_LIGHTING
        bool bMoving = false;
        if (Result.bIsHit)
        {
            float3 HitWorldPosition = Ray.Origin + Ray.Direction * Result.TraceHitDistance;
            bMoving = IsTraceMoving(...);
        }

        RWTraceRadiance[ScreenProbeTraceCoord] = Result.Radiance * View.PreExposure;
        RWTraceHit[ScreenProbeTraceCoord] = EncodeProbeRayDistance(...);
#endif
    }
}

下面进入光线追踪的调用栈：

// LumenScreenProbeHardwareRayTracing.usf

FRayTracedLightingResult EpsilonTrace(RayDesc Ray, inout FRayTracedLightingContext Context)
{
    FRayTracedLightingResult Result = CreateRayTracedLightingResult();

#if ENABLE_NEAR_FIELD_TRACING
    uint OriginalCullingMode = Context.CullingMode;
    Context.CullingMode = RAY_FLAG_CULL_BACK_FACING_TRIANGLES;
    Ray.TMax = AvoidSelfIntersectionTraceDistance;

    if (Ray.TMax > Ray.TMin)
    {
        // 第一次追踪: 启用背面剔除的短距离，以避免在追踪几何体与GBuffer中的几何体不匹配的情况下自相交（Nanite、光线追踪LOD等）.
#if DIM_LIGHTING_MODE == LIGHTING_FROM_SURFACE_CACHE
        {
            Result = TraceAndCalculateRayTracedLightingFromSurfaceCache(Ray, Context);
        }
#else
        {
            Result = TraceAndCalculateRayTracedLighting(Ray, Context, DIM_LIGHTING_MODE);
        }
#endif
    }
    Context.CullingMode = OriginalCullingMode;
#endif

    return Result;
}

以上的TraceAndCalculateRayTracedLighting和TraceAndCalculateRayTracedLighting会进入复杂的Luman Card追踪和采样逻辑，此文就不继续分析了，可以参看6.5.6 Lumen场景光照和6.5.7 Lumen非直接光照。

此外，UE硬件光追的反射、AO、半透明等特性也杂糅在Lumen当中，形成了相辅相成、耦合性较高且极其复杂的渲染体系，从而呈现出精彩纷呈的电影级别的实时渲染画质。

17.7 本篇总结

本篇主要阐述了UE的硬件光线追踪的渲染流程和主要算法，使得读者对此模块有着大致的理解，至于更多技术细节和原理，需要读者自己去研读UE源码发掘。

正如毛星云（再次惋惜、缅怀以及RIP）在实时光线追踪（real-time ray tracing）技术还有哪些未攻克的难题？中提及的，实时渲染领域还存在诸多悬而未决的问题：

• 渲染问题。如透明、部分覆盖、粒子、全局光照等。
• 性能问题。包含一致性、调度、解耦、采样、降噪等。
• 体系问题。如驱动、硬件、OS、图形API、应用程序等。

但即便如此，基于硬件光线追踪的渲染体系技术肯定是不久将来的主流，值得我们深入探究和挖掘。

希望童鞋们能够踏实地扎根于图形渲染技术，力争做到客观公正、实事求是、以德服人、以技服人（反面教材——），一起提升国内图形渲染技术的综合实力，缩小国际之间的差距。共勉。

特别说明

• 感谢所有参考文献的作者，部分图片来自参考文献和网络，侵删。
• 本系列文章为笔者原创，只发表在博客园上，欢迎分享本文链接，但未经同意，不允许转载！
• 系列文章，未完待续，完整目录请戳内容纲目。
• 系列文章，未完待续，完整目录请戳内容纲目。
• 系列文章，未完待续，完整目录请戳内容纲目。

参考文献

• Unreal Engine Source
• Rendering and Graphics
• Materials
• Graphics Programming
• Numerical Robustness for Geometric Calculations
• 6 Years of Optimizing World of Tanks: Making the Game a Great Experience on All Systems from Laptops to High End PCs
• The Latest Graphics Technology in Remedy's Northlight Engine
• Advanced Graphics Techniques Tutorial: GPU-Based Clay Simulation and Ray-Tracing Tech in 'Claybook'
• Interactive Relighting of Dynamic Refractive Objects
• Math for Game Programmers: Voxel Surfing
• Leveraging Real-Time Ray Tracing to build a Hybrid Game Engine
• Implicit Function Ray Tracing
• High Quality Rendering using Ray Tracing and Photon Mapping
• Stochastic ray tracing
• General-Purpose Computation on Graphics Hardware
• Introduction to PowerVR Ray Tracing
• PowerVR Graphics - Latest Developments and Future Plans
• It Just Works: Ray-Traced Reflections in "Battlefield V"
• Highly Parallel Fast KD-tree Construction for Interactive Ray Tracing of Dynamic Scenes
• Embree
• Intel? oneAPI Rendering Toolkit
• Rendering Technology in 'Agents of Mayhem'
• Practical Techniques for Ray Tracing in Games
• Imagination-PowerVR Photon Architecture
• Photon Architecture White Paper
• Radiance Caching for real-time Global Illumination
• Real-Time Ray Tracing of Correct Soft Shadows
• [Adopting lessons from offline ray tracing to real-time ray tracing for practical pipelines](http://advances.realtimerendering.com/s2018/Pharr - Advances in RTR - Real-time Ray Tracing.pdf)
• [Global Illumination Based on Surfels](http://advances.realtimerendering.com/s2021/SIGGRAPH Advances 2021 - Surfel GI.pptx)
• Hybrid Ray-Traced Shadows
• [From Ray to Path Tracing: Navigating through Dimensions](http://advances.realtimerendering.com/s2020/Turquin - From Ray to Path Tracing - SIGGRAPH 2020 Presentation.pptx)
• T-ReX: Interactive Global Illumination ofMassive Models on HeterogeneousComputing Resources
• Unbiased Photon Gathering for Light Transport Simulation
• Scalable Real time Global Illumination for Large Scenes
• Announcing Microsoft DirectX Raytracing!
• Ray Tracing Denoising
• DirectML's SuperResolution Sample
• Spatiotemporal Variance-Guided Filtering
• TURING RTX RAY TRACING 与 DLSS
• DLSS 2.0 – IMAGE RECONSTRUCTION FOR REAL-TIME RENDERING WITH DEEP LEARNING
• DLSS 2.0 - 重新定义AI渲染
• Spatiotemporal Reservoir Resampling (ReSTIR) - Theory and Basic Implementation
• Ray Tracing in Games with NVIDIA RTX (Presented by NVIDIA)
• Introduction to NVIDIA RTX and DirectX Ray Tracing
• Real-Time_Rendering_4th-Real-Time_Ray_Tracing
• RTX Technology
• NVIDIA Vulkan Ray Tracing Tutorial
• Ray Tracing In Vulkan
• Ray Tracing with Metal
• Metal for Accelerating Ray Tracing
• Accelerating ray tracing using Metal
• AMD Radeon? Rays
• AMD Radeon ProRender
• Radeon ProRender and Radeon Rays in a Gaming Rendering Workflow
• AMD RYZEN? PROCESSOR SOFTWARE OPTIMIZATION
• AMD CDNA? 2 ARCHITECTURE
• Hardware-Accelerated Ray Tracing in AMD Radeon? ProRender 2.0
• Ray Tracing Resources Page
• Ray Tracing Essentials
• Implementing GGX BRDF in Arnold with Multiple Importance Sampling
• NVIDIA RTX: Enabling Ray Tracing in Vulkan
• The RTX Shader Binding Table Three Ways
• SHINING A LIGHT ON RAY TRACING
• Parallel Architectures
• PBRT: Photorealistic Rendering and the Ray-Tracing Algorithm
• Ray Tracing Gems
• Ray Tracing Gems II
• Cinematic Rendering in UE4 with Real-Time Ray Tracing and Denoising
• NVIDIA DLSS Plugin For Unreal Engine
• Practical Solutions for Ray Tracing Content Compatibility in Unreal Engine 4
• 实时光线追踪（real-time ray tracing）技术还有哪些未攻克的难题？
• PIX GPU Captures
• PIX for Windows
• NVIDIA Development Tools Solutions - ERR_NVGPUCTRPERM: Permission issue with Performance Counters
• Tips & Tricks: How the Pros Use PIX to Make Their Games Better on Xbox and Windows
• Hardware Ray Tracing
• Hardware Ray Tracing Tips and Tricks
• Hardware Ray Tracing and Path Tracer Features Properties
• DirectX Raytracing (DXR) Functional Spec
• Lumen Technical Details