Unity SRP框架下VXGI体素全局光照实现与优化实战

1. 项目概述：从标题拆解核心价值

“Unity SRP VXGI 开源项目教程”这个标题，乍一看有点技术黑话堆砌的味道，但对我们这些常年泡在图形渲染和引擎开发里的老鸟来说，它指向的是一个非常具体、且极具实践价值的领域。我来帮你把这个标题掰开揉碎了讲清楚。

首先，Unity是引擎，这个不用多说。SRP是 Scriptable Render Pipeline 的缩写，中文叫“可编程渲染管线”。这是Unity近年来在渲染架构上的一次重大革新，它把过去黑盒的渲染流程开放了出来，允许开发者像搭积木一样自定义整个渲染过程。这意味着什么？意味着你可以摆脱Unity内置渲染管线的限制，去实现那些“官方不给”的高级效果，或者为你的特定项目（比如风格化卡通、写实大世界、或者移动端超优化）量身打造一套渲染方案。SRP是通往高端图形和深度定制的钥匙。

接着是VXGI，全称 Voxel Global Illumination，即“体素全局光照”。全局光照（GI）是渲染里追求真实感的核心技术，它模拟光线在场景中多次反弹、相互影响的效果。传统的实时光照要么是直接光加简单的环境光，要么像Unity的Enlighten或烘焙光照那样，要么是预计算（慢、不动态），要么是性能开销巨大。VXGI提供了一种折中且强大的思路：它将场景体素化（想象成把世界变成一个三维的乐高积木网格），然后在这些体素中预计算和存储光照信息。这样，动态物体也能享受到来自复杂环境的、柔和的间接光照，而且性能相对可控。它曾是NVidia力推的技术，在不少3A游戏的宣传片里露过脸。

那么，“Unity SRP VXGI 开源项目教程”连起来看，它的核心价值就非常明确了：这是一个教你如何在Unity的自定义可编程渲染管线（SRP）框架下，从零开始或深度集成一套VXGI体素全局光照系统的实战指南。而且它是“开源项目”，意味着你不是在学纯理论，而是在剖析一个可以运行、可以修改的真实代码工程。

这解决了什么问题？对于中级以上的Unity开发者或图形程序员来说，官方文档和基础教程已经无法满足需求。你想深入理解现代渲染管线，想掌握实时光照的前沿实现，想拥有定制高级渲染效果的能力，但面对SRP的抽象和VXGI的数学物理，往往无从下手。这个项目教程，正是填补了这个空白——它提供了一个从理论到代码、从框架到细节的完整路径。

适合谁来学？如果你满足以下任何一条，这篇内容就值得你深究：

1. 对Unity的渲染机制有基本了解，不满足于使用现成插件，想知其所以然的开发者。
2. 有志于向图形程序（Technical Artist或Graphics Programmer）方向发展的同学。
3. 在项目中遇到复杂光照需求（如动态昼夜交替下的室内外光照、大量动态物体的色彩渗透），需要寻找高性能GI解决方案的技术负责人。
4. 对计算机图形学，特别是实时光照技术有浓厚兴趣的学习者。

接下来，我会带你深入这个项目，不仅告诉你它是什么，更会拆解它怎么做，以及为什么这么做。我们会涉及SRP的框架搭建、VXGI的核心算法、在Unity中的工程化实现，以及无数只有踩过坑才知道的优化技巧和调试心得。

2. SRP框架基础与项目环境搭建

在直接跳进VXGI的体素海洋之前，我们必须先把船造好——也就是搭建一个稳固、可扩展的SRP框架。很多教程一上来就讲效果，但框架设计上的坑，往往后期会让你推倒重来。

2.1 理解SRP的核心：RenderGraph与Pass架构

Unity的SRP，无论是URP（Universal RP）还是HDRP（High Definition RP），其底层都遵循一个核心设计模式：基于RenderGraph的Pass执行。你可以把它理解为一个渲染指令的有向无环图（DAG）。我们不是直接向GPU发命令，而是先声明一系列“渲染Pass”（如深度预渲染、不透明物体渲染、天空盒、后处理等），并定义它们之间的资源依赖关系（比如Pass B需要Pass A生成的纹理）。SRP Core（Unity提供的一个底层包）会负责最优化的排序和执行。

在我们的自定义SRP中，核心就是继承自RenderPipeline的类，并重写Render方法。在这个方法里，我们构建自己的RenderGraph。

using UnityEngine; using UnityEngine.Rendering; using UnityEngine.Rendering.RenderGraphModule; public class MyCustomSRP : RenderPipeline { private RenderGraph m_RenderGraph = new RenderGraph(“MyCustomSRPGraph”); protected override void Render(ScriptableRenderContext context, Camera[] cameras) { // 1. 开始一帧的RenderGraph构建 m_RenderGraph.BeginFrame(); // 2. 为每个相机执行渲染 foreach (var camera in cameras) { if (!CullResults.GetCullingParameters(camera, out var cullParams)) continue; CullResults cullResults = new CullResults(); if (!CullResults.Cull(ref cullParams, context, ref cullResults)) continue; // 构建该相机对应的渲染流程 RenderCamera(m_RenderGraph, context, camera, cullResults); } // 3. 执行构建好的RenderGraph m_RenderGraph.EndFrameAndExecute(context); // 4. 提交上下文命令 context.Submit(); } private void RenderCamera(RenderGraph renderGraph, ScriptableRenderContext context, Camera camera, CullResults cullResults) { // 使用RenderGraph API，声明和连接各个Pass // 例如：DepthPrePass, GBufferPass, VXGIPass, LightingPass, TransparencyPass, PostProcessingPass等 // 这部分是框架的核心，我们稍后详细展开。 } protected override void Dispose(bool disposing) { m_RenderGraph.Cleanup(); base.Dispose(disposing); } }

为什么一定要用RenderGraph？早期的SRP示例可能直接使用CommandBuffer。RenderGraph的优势在于自动的资源生命周期管理和隐式同步。它确保纹理等资源只在需要的Pass中存在，用完后及时释放，避免了内存泄露和“谁先谁后”的同步噩梦。这对于VXGI这种需要多Pass、中间纹理繁多的复杂流程至关重要。

2.2 项目初始化与关键包管理

创建一个新的Unity项目（建议使用2022.3 LTS或更新版本），我们需要通过Package Manager引入几个核心包：

1. Core RP Library：SRP的基础工具库。
2. RenderGraph：如上所述，现代SRP的基石。
3. Burst和Mathematics：VXGI涉及大量的体素遍历和辐照度计算，这些计算密集型任务必须用Burst编译成高性能的Native代码，并用Mathematics进行SIMD优化。这是性能成败的关键。
4. Unity UI：如果项目包含调试面板的话。

注意：包版本兼容性是个暗坑。务必在Packages/manifest.json中锁定主要版本，例如"com.unity.render-pipelines.core": "14.0.8"。不同大版本间的API可能有断裂式更新，盲目使用latest可能导致项目无法编译。

在Project Settings -> Graphics中，将你的MyCustomSRP资产拖入Scriptable Render Pipeline Settings。这样，你的自定义管线就生效了。

2.3 第一个渲染Pass：清屏与天空盒

让我们从最简单的开始，实现第一个能运行的Pass。在RenderCamera函数中：

using (var builder = renderGraph.AddRenderPass<CameraData>(“ClearAndSkyboxPass”, out var passData)) { // 1. 声明本Pass需要写入的颜色和深度纹理（即相机最终渲染目标） TextureHandle colorHandle = builder.UseColorBuffer(renderGraph.CreateTexture(new TextureDesc(width, height) { colorFormat = GraphicsFormat.R8G8B8A8_UNorm }), 0); TextureHandle depthHandle = builder.UseDepthBuffer(renderGraph.CreateTexture(new TextureDesc(width, height) { depthBufferBits = DepthBits.Depth32 }), DepthAccess.Write); // 2. 设置渲染函数 builder.SetRenderFunc((CameraData data, RasterGraphContext context) => { // 清屏 context.cmd.ClearRenderTarget(true, true, Color.gray); // 绘制天空盒 context.cmd.DrawSkybox(data.camera); }); // 3. 传递数据 passData.camera = camera; }

这个Pass虽然简单，但已经包含了RenderGraph的基本要素：创建纹理资源、声明访问方式（UseColorBuffer/UseDepthBuffer）、设置执行函数。运行后，你应该能看到一个灰色背景和天空盒（如果相机设置了）。

实操心得一：纹理格式选择。GraphicsFormat.R8G8B8A8_UNorm是常见的8位每通道格式。但对于HDR渲染，你可能需要R16G16B16A16_SFloat。深度格式DepthBits.Depth32精度足够，但在移动端考虑Depth24以节省带宽。这些选择在项目初期就要定好，后期更改可能牵一发而动全身。

3. VXGI核心原理与算法拆解

现在，我们的SRP小船已经下水，可以驶向VXGI这片充满挑战的海域了。理解其原理，是写出高效、正确代码的前提。

3.1 体素化：将连续世界离散化

VXGI的第一步是体素化（Voxelization）。我们不是直接对三角形网格进行光照计算，而是将整个场景（或一个影响范围）转换成一个三维的网格，每个网格单元就是一个体素（Voxel）。这相当于用一堆小立方体去近似表示复杂的几何形状。

如何体素化？最主流的方法是使用几何着色器（Geometry Shader）或计算着色器（Compute Shader）进行“光栅化到3D纹理”。我们创建一个3D纹理（Texture3D），其宽度、高度、深度分别代表世界空间X, Y, Z轴划分的体素数量。然后，将场景中的所有网格，以其世界坐标，投影到这个3D纹理的“像素”上。

// 在Compute Shader中体素化的简化概念 [numthreads(8, 8, 1)] void VoxelizeTriangle (uint3 id : SV_DispatchThreadID) { // 获取一个三角形 Triangle tri = _Triangles[id.x]; // 计算三角形包围盒所覆盖的体素范围 int3 minVoxel = WorldPosToVoxelCoord(tri.minAABB); int3 maxVoxel = WorldPosToVoxelCoord(tri.maxAABB); // 遍历这些体素，判断体素中心是否在三角形内（使用保守光栅化确保不漏） for (int z = minVoxel.z; z <= maxVoxel.z; ++z) { for (int y = minVoxel.y; y <= maxVoxel.y; ++y) { for (int x = minVoxel.x; x <= maxVoxel.x; ++x) { if (IsVoxelInsideTriangle(x, y, z, tri)) { // 将该体素标记为“占据”，并存储法线、反照率等信息 _VoxelGrid[uint3(x, y, z)] = EncodeVoxelData(tri.normal, tri.albedo); } } } } }

关键参数：体素尺寸（Voxel Size）和网格分辨率。体素尺寸决定了精度，比如0.5米一个体素。网格分辨率（如128x128x128）决定了覆盖范围和内存开销。精度越高，细节越好（能捕捉更薄的墙体），但计算量和内存（128^3 * 每个体素字节数）呈立方级增长。通常需要在场景边界和性能间做权衡。

3.2 锥体追踪：模拟间接光照

体素化后，我们得到了一个带有法线、颜色信息的3D体素网格。接下来就是光照的核心——锥体追踪（Cone Tracing）。

对于场景中的任意一个着色点（比如一个像素），我们想知道它接收到的来自四面八方的间接光。直接计算所有方向的积分是不可能的。VXGI的聪明之处在于，它用有限个锥体（Cone）来近似这个半球积分。通常使用5个锥体：一个沿表面法线方向（最重要的方向），另外四个倾斜分布在周围。

对于每个锥体，我们从着色点出发，沿着锥体轴线方向“步进”穿越体素网格。在每一步，我们采样当前体素中存储的辐照度信息。由于锥体有张角，我们采样的其实是一个小区域，这需要对周围体素进行三线性滤波，模拟光线在体素间的“散射”。将沿路径采样到的所有光照能量累积起来，就得到了这个锥体方向贡献的间接光照。最后，将几个锥体的结果加权混合，就得到了该着色点最终的间接光照值。

float3 TraceCone(float3 startPos, float3 direction, float coneHalfAngle, float maxDistance) { float3 accumulatedLight = float3(0, 0, 0); float stepSize = _VoxelSize; // 步长与体素尺寸相关 float currentDistance = stepSize; float coneRadiusAtT = currentDistance * tan(coneHalfAngle); // 当前距离处的锥体半径 while (currentDistance < maxDistance) { // 1. 计算当前采样点在体素网格中的坐标 float3 samplePos = startPos + direction * currentDistance; int3 voxelCoord = WorldPosToVoxelCoord(samplePos); // 2. 三线性采样体素纹理，获取该位置的辐照度（或辐射度） float3 voxelIrradiance = _VoxelGridTexture.SampleLevel(_TrilinearClampSampler, VoxelCoordToUVW(voxelCoord), 0).rgb; // 3. 根据距离和锥体覆盖的立体角，计算权重并累加 float weight = CalculateWeight(currentDistance, coneRadiusAtT); accumulatedLight += voxelIrradiance * weight; // 4. 自适应步进：距离越远，步长可以适当增加以提升性能 currentDistance += max(stepSize, coneRadiusAtT * 0.5); coneRadiusAtT = currentDistance * tan(coneHalfAngle); } return accumulatedLight; }

为什么是锥体追踪，而不是光线追踪？纯光线追踪（Ray Tracing）每个像素需要发射成千上万条光线才能得到无噪点的间接光，性能无法承受。锥体追踪用一条“粗”的锥形射线，通过采样和滤波，近似了多条精细光线的效果，是一种在质量和性能间极佳的权衡，特别适合在体素这种离散数据结构上进行。

3.3 辐照度注入与传播：构建光照体素网格

上面提到的_VoxelGridTexture里存储的“辐照度”信息从哪来？这需要另一个关键步骤：辐照度注入与传播（Irradiance Injection & Propagation）。

首先，注入（Injection）。我们遍历所有直接光源（平行光、点光源等）。对于每个体素，我们判断它是否被光源照亮（即不在阴影中），如果被照亮，就计算该光源在该体素位置产生的直接光照（考虑衰减、法线），并将这个光照值（通常是辐射度Radiance）写入到一个临时的3D纹理中。这个纹理我们称为“辐射度体素网格”（Radiance Voxel Grid）。

然后，传播（Propagation）。直接光照只存在于被直接照亮的体素。间接光照需要光线反弹。传播过程模拟了光线在体素间的“扩散”。通常使用迭代的滤波方法：对辐射度体素网格的每一层（Z轴切片），进行多次3D滤波（比如使用一个3x3x3的核），让每个体素的光照信息“渗入”到其相邻的6个或26个体素中。每次迭代模拟一次光线反弹。经过数次（如3-5次）传播迭代后，辐射度网格就包含了多次反弹的间接光照信息，此时我们可以将其转换为更适合最终采样的辐照度（Irradiance）格式存储起来。

注意：注入和传播是VXGI计算开销的大头，尤其是传播，需要对整个3D纹理进行多轮全分辨率计算。因此，开源项目中常见两种优化：1.降低光照体素网格的分辨率，通常比几何体素网格分辨率低（如1/2或1/4）。2.使用Mipmap链，在传播时从低分辨率向高分辨率传递信息，减少计算量。

4. 在SRP中集成VXGI：架构设计与Pass实现

理解了原理，我们来看如何在SRP的框架下，将这些步骤组织成一个个清晰的RenderGraph Pass。一个典型的VXGI集成流程会包含以下核心Pass：

4.1 Pass 1：场景几何体素化

这个Pass通常在相机无关的、每帧或每N帧执行一次。它渲染整个场景到一个离屏的3D纹理。

1. 创建资源：声明一个RWTexture3D<float4>类型的RenderGraph纹理资源，用于存储体素数据（法线、反照率等）。
2. 设置渲染状态：使用一个特殊的Shader，这个Shader的顶点着色器输出世界坐标，几何/片元着色器负责将三角形“拍”到3D纹理的对应位置。视口（Viewport）和投影矩阵需要设置为正交投影，覆盖整个体素化区域的世界空间范围。
3. 执行绘制：使用context.cmd.DrawRenderers绘制所有不透明物体。这里通常需要自定义一个ShaderTagId，比如new ShaderTagId(“Voxelization”)，并在你的着色器中添加对应的LightMode。
4. 数据编码：在片元着色器中，将世界位置转换为体素坐标，并以该坐标为地址，将法线（编码为两个球面系数）和反照率写入到RWTexture3D中。

实操心得二：保守光栅化（Conservative Rasterization）。标准的GPU光栅化会丢弃与像素中心不严格相交的三角形。在体素化中，这会导致薄墙或细杆子“漏体素”，出现空洞。必须在Shader中实现或开启硬件的保守光栅化扩展（如果支持），确保任何与像素（体素）有交集的三角形都会被渲染进去。

4.2 Pass 2：直接光注入与多反弹传播

这是一个完全在Compute Shader中完成的Pass。

1. 注入Pass：

   • 输入：光源数据（位置、颜色、方向）、上一步得到的几何体素网格（只读）。
   • 输出：一个初始的辐射度体素网格（RWTexture3D<float3>）。
   • 逻辑：每个线程组处理一个体素块。线程计算对应体素的世界坐标，判断其可见性（简单的阴影判断，如使用深度图或光线步进），计算直接光照，并写入辐射度网格。

2. 传播Pass（迭代执行）：

   • 输入：上一轮的辐射度体素网格。
   • 输出：新一轮的辐射度体素网格（通常使用双缓冲，两个纹理交替作为输入和输出）。
   • 逻辑：一个标准的3D图像滤波。每个线程处理一个体素，采样其周围（如3x3x3）邻居的值，加权平均后写入新纹理。这个权重可以模拟不同方向的光照传播衰减。

// 在C#端调度Compute Shader using (var builder = renderGraph.AddComputePass(“VXGIPropagationPass”, out var passData)) { // 声明输入输出纹理 TextureHandle inputRadiance = builder.ReadTexture(previousRadianceHandle); TextureHandle outputRadiance = builder.WriteTexture(createNewRadianceHandle); builder.SetRenderFunc((PassData data, ComputeGraphContext context) => { context.cmd.SetComputeTextureParam(data.propagationCS, data.propagationKernel, “_InputRadiance”, inputRadiance); context.cmd.SetComputeTextureParam(data.propagationCS, data.propagationKernel, “_OutputRadiance”, outputRadiance); // 分派线程组，覆盖整个3D纹理 context.cmd.DispatchCompute(data.propagationCS, data.propagationKernel, groupCountX, groupCountY, groupCountZ); }); }

4.3 Pass 3：光照计算与主着色集成

这是将VXGI结果应用到最终画面的Pass。它通常发生在不透明物体渲染之后，透明物体渲染之前。

1. 创建光照积分Pass：这是一个全屏的后处理Pass，或者集成到不透明物体的着色器中（通过全局纹理采样）。
2. 锥体追踪采样：在着色器里，对于每个像素，获取其世界坐标和法线。调用前面提到的TraceCone函数若干次（如5次），对VXGI辐照度体素网格进行采样，得到间接漫反射光照。
3. 与直接光结合：将计算出的间接光照颜色，与传统的直接光照（平行光、点光源等）结果相加。
4. 可选的镜面反射：高级的VXGI实现还会支持间接镜面反射（Glossy Reflection）。原理类似，但锥体的张角更小，方向是反射向量，并且采样时需要考虑粗糙度对锥体角度的影响。

关键点：降噪与滤波。由于体素分辨率和锥体追踪的离散性，原始的VXGI结果可能会有噪点或块状瑕疵。因此，这个Pass之后通常会跟一个时空滤波（Temporal Filter）Pass。利用上一帧的渲染结果和当前帧的运动向量，在时间上累积多帧信息，能极大平滑噪点，提升视觉质量。这是高质量实时GI不可或缺的一步。

5. 性能优化与调试实战

VXGI是一个“性能敏感型”特效，不加优化直接实现，帧率很可能惨不忍睹。以下是我从多个项目实践中总结的优化清单和调试方法。

5.1 多层次细节与自适应体素化

• 动态分辨率：根据物体与相机的距离，使用不同精度的体素化。近处物体用高分辨率体素，远处用低分辨率。这可以通过在体素化前，根据物体的包围盒距离设置不同的渲染层（Layer）来实现，然后分别体素化到不同分辨率的网格中，最后在锥体追踪时根据距离采样不同的网格。
• 级联体素网格（Cascaded Voxel Grid）：类似阴影的级联（CSM）。创建多个不同大小、覆盖不同距离范围的体素网格。近处网格小但精度高，覆盖玩家周围；远处网格大但精度低，覆盖远景。追踪时根据距离选择合适的级联进行采样。

5.2 计算着色器优化

• 线程组大小：Burst/Compute Shader的线程组大小（如[numthreads(8,8,1)]）需要适配GPU的Wavefront/Warp大小（通常是32或64）。8x8=64是个通用选择。不匹配会导致GPU计算单元利用率低下。
• 内存访问模式：确保Compute Shader中对3D纹理的访问是连续的、对齐的。随机访问会导致严重的缓存命中失败。在传播滤波时，让相邻的线程访问相邻的纹理像素。
• 使用LDS（Local Data Share）：在滤波操作中，可以将一个线程组需要的数据块先加载到快速的片上共享内存中，线程组内的所有线程从LDS读取，能大幅减少访问全局显存的次数。

5.3 渲染调试与可视化

调试图形算法，眼睛看不到就等于抓瞎。必须建立强大的可视化工具。

1. 体素网格可视化：写一个简单的Shader，将3D体素纹理以点云或小立方体的形式在场景中绘制出来。可以切换显示法线、反照率或辐照度。这是检查体素化是否正确、是否有空洞的第一步。
2. 锥体追踪可视化：在屏幕空间Debug Pass中，对于鼠标点击的像素，在场景中用线框绘制出它发射的几条锥体射线，并标记每一步采样的体素位置。这能直观看到追踪路径和采样点。
3. 性能分析：使用Unity的Profiler或RenderDoc，精确测量每个VXGI相关Pass（体素化、注入、传播、锥体追踪）的GPU耗时。重点关注：
   • GPU Instancing：体素化绘制是否合批？
   • Compute Shader Occupancy：计算着色器的占用率是否理想？
   • Texture Bandwidth：3D纹理的读写带宽是否成为瓶颈？
4. 参数实时调节面板：在编辑器中创建一个Debug UI，可以实时滑动调节体素尺寸、网格分辨率、锥体数量、传播次数、最大追踪距离等参数。边调边看效果和帧率，是找到最佳平衡点的最快方式。

注意：调试的哲学。不要试图一次性调试整个复杂的VXGI管线。应该采用“分而治之”策略：先确保体素化可视化正确，再关闭传播只看直接光注入是否正确，然后开启一次传播看效果，最后再集成锥体追踪。每步都验证，能极大降低排查难度。

6. 开源项目工程导览与学习路径

一个优秀的开源项目，其价值不仅在于代码本身，更在于其工程结构和设计思想。假设我们研究的是一个典型的Unity SRP VXGI开源项目（例如GitHub上的一些知名Repo），我们可以这样去学习：

6.1 项目结构解析

Assets/ ├── Runtime/ │ ├── Shaders/ │ │ ├── Voxelization.shader // 几何体素化着色器 │ │ ├── VXGIInjection.compute // 光照注入计算着色器 │ │ ├── VXGIPropagation.compute // 传播计算着色器 │ │ ├── VXGIConeTracing.shader // 锥体追踪着色器（全屏或集成） │ │ └── ... // 工具类、调试着色器 │ ├── Scripts/ │ │ ├── Rendering/ │ │ │ ├── MyCustomRenderPipeline.cs // 主管线入口 │ │ │ ├── VXGIPass.cs // VXGI相关Pass的封装类 │ │ │ └── ... // 其他通用Pass │ │ ├── VXGI/ │ │ │ ├── VXGI管理器.cs // 单例，管理资源与参数 │ │ │ ├── VXGI数据资产.cs // ScriptableObject，存储配置 │ │ │ └── 调试绘制器.cs // 在Scene视图绘制体素网格 │ │ └── Utilities/ // 数学、扩展方法等工具 │ └── Resources/ // 内置着色器资源等 └── Editor/ // 自定义Inspector、编辑器工具

学习要点：

• 关注数据流：跟踪Voxel Grid Texture是如何在各个Pass间创建、传递和销毁的。理解RenderGraph如何管理这些临时资源的生命周期。
• 学习参数封装：看作者如何将体素尺寸、分辨率、传播次数等大量参数封装成ScriptableObject，便于管理和预设。
• 模仿调试架构：好的项目会有一个清晰的调试开关系统，可以方便地开启/关闭可视化。学习这种设计，应用到自己的项目中。

6.2 循序渐进的学习与实践计划

如果你是从零开始，我建议按这个路径来：

1. Week 1-2： 吃透SRP基础。不要直接碰VXGI代码。先跟着Unity官方手册或基础教程，实现一个最简单的自定义SRP，包含Forward Rendering的Opaque、Transparent、Skybox等基础Pass。彻底理解ScriptableRenderContext、CommandBuffer和RenderGraph的用法。
2. Week 3： 实现3D纹理与Compute Shader。写一个Demo，用Compute Shader生成一个简单的3D噪声纹理，并在屏幕上用一个Raymarching Shader将其可视化。这一步是熟悉3D纹理读写和计算着色器编程的关键。
3. Week 4： 实现基础体素化。找一个简单的立方体模型，写一个Shader将其体素化到一个低分辨率（如32^3）的3D纹理中，并实现上面提到的可视化Debug，确保每个立方体都被正确“拍”进体素网格。
4. Week 5： 实现直接光注入。在场景中放一个点光源，写一个Compute Shader，遍历体素网格，计算每个体素受到的点光源直接光照，并写入另一个3D纹理。可视化这个“光照体素网格”，你应该能看到光源周围体素被点亮。
5. Week 6： 实现单次传播与锥体追踪。实现一个3x3x3的均值滤波作为一次光传播。然后写一个全屏Shader，对每个像素，从摄像机位置发射一条固定方向的锥体射线，对你上一步生成的光照体素网格进行步进采样和累积，输出到屏幕。这时你应该能看到模糊的、块状的间接光效果。
6. Week 7+： 集成与优化。将以上模块整合到你的SRP框架中，形成完整的Pass链。然后开始迭代优化：增加锥体数量、实现多次传播、加入时空滤波、尝试级联体素、优化线程组调度。

这个过程会充满挑战，但每完成一步，你对实时图形学的理解就会深入一层。这个开源项目教程就是你的地图和工具箱，而真正的宝藏，是你自己动手实现过程中获得的经验和洞察力。记住，图形编程，看十遍不如写一遍，写一遍不如调一遍。