企业官网建设流程全解析

1. 项目概述：为什么GPU加速体素化是实时渲染的“新宠”？

在Unity里折腾过地形、破坏系统或者体积云的朋友，大概都听说过“体素”（Voxel）这个词。简单来说，体素就是三维空间里的像素，一个带体积的小方块。传统的体素化处理，比如用Marching Cubes算法生成地形，或者计算物体的体素表示用于碰撞检测，基本都是在CPU上串行计算的。一个复杂的场景，动辄几百万个体素，CPU算起来那叫一个吃力，帧率瞬间就能给你干到个位数，实时渲染？想都别想。

这就是为什么GPU加速体素化（GPU-Accelerated Voxelization）最近成了圈子里的热门话题。它不再是那种“未来可期”的实验室技术，而是实实在在能落地到项目里，解决性能瓶颈的利器。核心思路就一句话：把体素化这个重度计算的任务，从CPU甩给拥有成千上万个核心的GPU去并行处理。想象一下，你要给一个模型“拍个三维CT”，CPU是一个医生拿着切片机一层一层慢慢切，而GPU是同时派出成千上万个医生，每人负责一小块区域瞬间完成。效率根本不是一个量级。

我最近在一个需要实时动态全局光照和软阴影的项目里深度实践了这套流程。目标很明确：将场景中的动态物体实时体素化，生成一个3D体素纹理（3D Texture），也就是我们常说的“体素化表示”（Voxel Representation），然后基于这个3D纹理，实现实时的体素锥追踪（Voxel Cone Tracing, VCT）光照。整个过程，从模型到体素，再到最终屏幕上的光照，全部在GPU管线内完成，CPU只负责调度和传递数据，最终在主流显卡上实现了复杂场景下稳定60帧的实时渲染效果。这不仅仅是“能用”，而是真正达到了生产级可用的性能。

接下来，我就把这套从原理到实现的“GPU加速体素化”高级技巧拆开揉碎了讲给你听，包括核心设计思路、Shader代码实战、性能调优的坑，以及如何集成到你的渲染管线里。无论你是想做动态全局光、真实的体积雾、还是复杂的可破坏地形，这套技术栈都会是你的强大助力。

2. 核心思路与架构设计：构建高效的GPU体素化管线

要实现GPU加速体素化，不能简单地把CPU代码扔进Compute Shader就完事了。它需要一套精心设计的渲染管线架构。核心目标是在一帧内，高效、准确地将三维模型数据“烘焙”成一个离散的3D网格数据，并且要方便后续的着色器采样。

2.1 为什么选择3D纹理作为体素存储？

体素数据的存储有多种选择，比如稀疏体素八叉树（SVO）内存效率高，但构建和遍历复杂。对于追求极致实时性的渲染来说，3D纹理（3D Texture）是目前最直接、最GPU友好的选择。你可以把它想象成一个三维的像素数组，每个“体素”就是纹理中的一个纹素（Texel）。

优势在于：

1. 硬件原生支持：GPU对纹理采样有极度优化的硬件单元，访问速度快。
2. 随机访问便捷：在着色器中，你可以通过一个三维坐标(u, v, w)直接采样到任意位置的体素数据，这对于锥追踪算法至关重要。
3. 与现有管线融合度高：Unity的渲染管线（无论是Built-in RP， URP还是HDRP）都对纹理操作有完善的支持，集成成本相对较低。

当然，缺点也很明显：内存消耗大。一个128x128x128分辨率的RGBAHalf格式（每通道16位浮点数）的3D纹理，内存占用就是128*128*128*8字节 ≈ 16.7MB。分辨率翻倍到256，内存直接飙升到134MB。所以，分辨率的选择是性能与质量权衡的第一个关键点。对于大多数实时全局光照应用，128^3或64^3是一个不错的起步选择。

2.2 体素化管线的核心步骤分解

整个GPU体素化流程可以抽象为以下几个步骤，我将其称为“体素化渲染通道”：

1. 场景准备与参数设定：

   • 确定体素网格的边界（AABB）。通常包围整个需要体素化的场景区域，或者动态物体的包围盒。
   • 设定体素分辨率（如128）。这决定了体素世界的“精度”。
   • 创建并初始化3D纹理。通常使用RenderTextureFormat.ARGBHalf格式，因为我们需要存储位置、法线、颜色等信息，且可能需要HDR范围。

2. 几何体体素化（核心步骤）： 这是最核心的一步。我们需要将每个三角形的片元（Fragment）“喷涂”到它穿过的所有体素格子中。在CPU上这是三重循环的灾难，在GPU上我们使用几何着色器（Geometry Shader）或更现代的计算着色器（Compute Shader）来并行处理。

   • 方法A：光栅化到3D纹理（传统方法）。这是一种巧妙的“作弊”：我们将3D纹理的每一个2D切片（Slice）视为一个渲染目标（RenderTarget）。通过一个特殊的Shader，将三角形渲染到多个切片上，模拟三维填充。这种方法利用了现有的光栅化硬件，但设置复杂，且对某些形状的体素化可能不精确。
   • 方法B：计算着色器直接写入（推荐方法）。我更倾向于使用Compute Shader。思路是：将模型的顶点和索引缓冲区传入Compute Shader。每个Compute Shader线程处理一个三角形。对于每个三角形，计算其与体素网格的相交范围，然后循环遍历该范围内的所有体素格子，判断该体素中心点是否在三角形“内部”或“附近”，并进行写入。这种方法控制粒度更细，精度更高，是当前的主流方案。

3. 数据编码与存储： 一个体素格子需要存储什么信息？至少需要：

   • 颜色/反照率（Albedo）：RGB通道。
   • 法线（Normal）：编码到RGB通道（通常从[-1,1]映射到[0,1]）。
   • 遮挡/距离场信息：Alpha通道或其他通道，可以存储到最近表面的距离（用于后续的锥追踪或AO计算）。 我们需要在Compute Shader中，将计算得到的信息编码并原子操作（Atomic Operation）写入到3D纹理对应的位置，因为多个三角形可能会影响同一个体素。

4. 后续处理（可选但重要）： 生成了“生”的体素纹理后，通常还需要一些后处理来优化质量。

   • 三线性过滤（Trilinear Filtering）：启用3D纹理的三线性过滤，可以让锥追踪采样时颜色过渡更平滑，减少“方块感”。
   • Mipmap生成：为3D纹理生成Mipmap链。这是实现多尺度锥追踪的关键。粗级别的Mipmap用于追踪较粗、较远的锥体，提升性能。
   • 降噪与模糊：有时需要对体素纹理进行各向异性高斯模糊，以减少噪点和走样。

2.3 与渲染管线的集成策略

在Unity中，你需要决定何时执行体素化。

• 每帧体素化：适用于完全动态的场景。性能开销最大，但灵活性最高。
• 按需体素化：当检测到场景中的物体移动、旋转或变形时才触发。需要维护一套脏标记系统。
• 静态预计算：对于静态场景部分，可以预先体素化并保存，运行时只体素化动态物体，然后与静态体素数据融合。这是性能和效果兼顾的最佳实践。

在我的实现中，我将其作为一个独立的MonoBehaviour组件，挂载在摄像机或一个全局管理器上。它在LateUpdate或通过CommandBuffer在相机渲染前触发体素化计算，并将生成的3D纹理通过Shader.SetGlobalTexture暴露给所有需要它的着色器（如全局光照着色器）。

注意：原子操作虽然保证了写入的正确性，但它是性能热点。在体素化Shader中，要尽量减少对同一个体素格的写入冲突。一种优化策略是，先为每个三角形计算一个保守的体素包围盒，只在这个小范围内进行精细的相交测试和写入，而不是遍历整个大网格。

3. 实战：使用Compute Shader实现精确体素化

理论讲完了，我们上硬货。下面我将展示一个基于Compute Shader的体素化核心实现。这里假设你已经创建了一个RenderTexture作为3D体素纹理（_VoxelTexture），并准备好了模型的顶点/索引数据。

3.1 Compute Shader 核心代码解析

首先，我们定义体素化的数据结构。在Compute Shader中：

// Voxelization.compute #pragma kernel CSMain RWTexture3D<float4> _VoxelTexture; // 可读写的3D纹理，存储体素数据 float3 _VolumeMin; // 体素网格世界空间最小点 float3 _VolumeMax; // 体素网格世界空间最大点 float3 _VolumeSize; // 体素网格世界空间尺寸 int _Resolution; // 体素网格分辨率（如128） float _VoxelSize; // 单个体素的世界空间尺寸 StructuredBuffer<float3> _VertexBuffer; // 顶点位置缓冲区 StructuredBuffer<int> _IndexBuffer; // 索引缓冲区 // 一个辅助函数：将世界坐标转换为体素纹理坐标（0到1范围） float3 WorldToVoxelPos(float3 worldPos) { float3 localPos = (worldPos - _VolumeMin) / _VolumeSize; return localPos; // 现在在[0,1]范围内 } // 判断点P是否在三角形ABC内（重心坐标法） bool PointInTriangle(float3 p, float3 a, float3 b, float3 c) { float3 v0 = c - a; float3 v1 = b - a; float3 v2 = p - a; float dot00 = dot(v0, v0); float dot01 = dot(v0, v1); float dot02 = dot(v0, v2); float dot11 = dot(v1, v1); float dot12 = dot(v1, v2); float invDenom = 1.0 / (dot00 * dot11 - dot01 * dot01); float u = (dot11 * dot02 - dot01 * dot12) * invDenom; float v = (dot00 * dot12 - dot01 * dot02) * invDenom; return (u >= 0) && (v >= 0) && (u + v < 1); } [numthreads(64, 1, 1)] void CSMain (uint3 id : SV_DispatchThreadID) { uint triangleIndex = id.x; if(triangleIndex >= _IndexBuffer.Length / 3) return; // 获取三角形的三个顶点 int i0 = _IndexBuffer[triangleIndex * 3]; int i1 = _IndexBuffer[triangleIndex * 3 + 1]; int i2 = _IndexBuffer[triangleIndex * 3 + 2]; float3 v0 = _VertexBuffer[i0]; float3 v1 = _VertexBuffer[i1]; float3 v2 = _VertexBuffer[i2]; // 计算三角形在体素空间中的包围盒（保守估计） float3 triMin = min(v0, min(v1, v2)); float3 triMax = max(v0, max(v1, v2)); float3 voxelTriMin = WorldToVoxelPos(triMin); float3 voxelTriMax = WorldToVoxelPos(triMax); // 将[0,1]坐标转换为体素索引坐标[0, Resolution-1] int3 minIdx = clamp(int3(voxelTriMin * _Resolution), int3(0,0,0), int3(_Resolution-1, _Resolution-1, _Resolution-1)); int3 maxIdx = clamp(int3(voxelTriMax * _Resolution), int3(0,0,0), int3(_Resolution-1, _Resolution-1, _Resolution-1)); // 遍历三角形包围盒内的每一个体素 for (int z = minIdx.z; z <= maxIdx.z; ++z) { for (int y = minIdx.y; y <= maxIdx.y; ++y) { for (int x = minIdx.x; x <= maxIdx.x; ++x) { // 计算当前体素中心的世界坐标 float3 voxelCenterWorld = _VolumeMin + (float3(x, y, z) + 0.5) * _VoxelSize; // 简化测试：检查体素中心是否在三角形投影的平面附近，并粗略判断内外 // 这里使用一个更高效的近似方法：计算体素中心到三角形平面的距离 // 为了简化示例，我们使用一个简单的投影到2D的包含测试（忽略深度） float3 voxelPos2D = voxelCenterWorld; // 实际可能需要投影到三角形的主要平面 // ... 此处应包含更精确的相交测试代码 ... // 假设我们通过测试，需要写入体素数据 float4 voxelData = float4(1.0, 0.5, 0.2, 1.0); // 示例：颜色和法线（编码后） // 使用原子操作或确保写入安全（此处简化，实际需处理并发写入） // InterlockedMax 常用于合并颜色或距离场 float4 existingData; // 注意：RWTexture3D的原子操作在某些平台上可能受限，另一种常见做法是使用RWStructuredBuffer // 这里为了概念清晰，直接写入（实际项目需处理竞争） _VoxelTexture[int3(x, y, z)] = voxelData; } } } }

这个Compute Shader的核心理念是：每个线程处理一个三角形。对于每个三角形，计算它在体素空间中的保守包围盒，然后只遍历这个包围盒内的体素，并进行精确的相交测试（示例中简化了）。这比遍历整个体素网格要高效得多。

3.2 C# 端驱动与调度

在C#端，我们需要设置参数、分配缓冲区并调度这个Compute Shader。

using UnityEngine; using System.Collections.Generic; public class GPUVoxelizer : MonoBehaviour { public ComputeShader voxelizationCS; public int resolution = 128; private RenderTexture _voxelTexture; private Bounds _volumeBounds; private ComputeBuffer _vertexBuffer; private ComputeBuffer _indexBuffer; void Start() { InitializeVoxelTexture(); // 假设有一个目标网格需要体素化 Mesh targetMesh = GetComponent<MeshFilter>().sharedMesh; SetupMeshData(targetMesh); _volumeBounds = targetMesh.bounds; // 使用网格包围盒作为体素化范围 } void InitializeVoxelTexture() { if (_voxelTexture != null) _voxelTexture.Release(); _voxelTexture = new RenderTexture(resolution, resolution, 0, RenderTextureFormat.ARGBHalf); _voxelTexture.dimension = UnityEngine.Rendering.TextureDimension.Tex3D; _voxelTexture.volumeDepth = resolution; _voxelTexture.enableRandomWrite = true; // 关键！允许Compute Shader写入 _voxelTexture.Create(); // 初始化为黑色 RenderTexture.active = _voxelTexture; GL.Clear(true, true, Color.black); RenderTexture.active = null; } void SetupMeshData(Mesh mesh) { Vector3[] vertices = mesh.vertices; // 将顶点从模型空间转换到世界空间（根据物体Transform） for(int i = 0; i < vertices.Length; i++) { vertices[i] = transform.TransformPoint(vertices[i]); } int[] indices = mesh.triangles; // 创建Compute Buffer if(_vertexBuffer != null) _vertexBuffer.Release(); if(_indexBuffer != null) _indexBuffer.Release(); _vertexBuffer = new ComputeBuffer(vertices.Length, sizeof(float) * 3); _vertexBuffer.SetData(vertices); _indexBuffer = new ComputeBuffer(indices.Length, sizeof(int)); _indexBuffer.SetData(indices); } void Update() { if (voxelizationCS == null || _voxelTexture == null) return; // 设置Compute Shader参数 voxelizationCS.SetTexture(0, "_VoxelTexture", _voxelTexture); voxelizationCS.SetVector("_VolumeMin", _volumeBounds.min); voxelizationCS.SetVector("_VolumeMax", _volumeBounds.max); voxelizationCS.SetVector("_VolumeSize", _volumeBounds.size); voxelizationCS.SetInt("_Resolution", resolution); voxelizationCS.SetFloat("_VoxelSize", _volumeBounds.size.x / resolution); // 假设是立方体 voxelizationCS.SetBuffer(0, "_VertexBuffer", _vertexBuffer); voxelizationCS.SetBuffer(0, "_IndexBuffer", _indexBuffer); // 调度计算：每个线程组64个线程，需要足够的线程组覆盖所有三角形 int numTriangles = _indexBuffer.count / 3; int threadGroups = Mathf.CeilToInt(numTriangles / 64.0f); voxelizationCS.Dispatch(0, threadGroups, 1, 1); // 将生成的体素纹理传递给全局着色器变量，供其他Shader使用 Shader.SetGlobalTexture("_GlobalVoxelTexture", _voxelTexture); Shader.SetGlobalVector("_VoxelVolumeMin", _volumeBounds.min); Shader.SetGlobalVector("_VoxelVolumeSize", _volumeBounds.size); } void OnDestroy() { if (_voxelTexture != null) _voxelTexture.Release(); if (_vertexBuffer != null) _vertexBuffer.Release(); if (_indexBuffer != null) _indexBuffer.Release(); } }

这段C#代码完成了管线的搭建：创建3D纹理、准备网格数据、每帧调度Compute Shader进行计算，并将结果传递给渲染管线。这里为了清晰，只体素化了一个网格。实际项目中，你需要遍历所有需要体素化的物体，合并它们的顶点和索引缓冲区，或者进行多次Dispatch。

实操心得：直接使用RenderTexture作为RWTexture3D进行复杂的原子写入，在某些图形API（如OpenGL ES）上可能支持不佳或效率低下。一个更稳健、更通用的工业级做法是：使用ComputeBuffer来存储体素数据。具体来说，创建一个一维的ComputeBuffer，大小为resolution * resolution * resolution，每个元素存储体素信息。在Compute Shader中，通过(z * resolution * resolution + y * resolution + x)计算索引，进行读写。计算完成后，再通过ComputeBuffer.CopyCount或AsyncGPUReadback将数据读回（如果需要），或者通过另一个Compute Shader或Shader将ComputeBuffer的数据“烘焙”到一张3D纹理中供渲染采样。这种方法对原子操作的支持更好，灵活性也更高。

4. 从体素到像素：实现实时体素锥追踪光照

生成了体素纹理，我们只完成了一半的工作。另一半，也是最终出效果的一步，是如何利用这个3D体素世界来照亮我们的场景。这就是体素锥追踪（Voxel Cone Tracing, VCT）的舞台。它本质上是一种简化的、离散化的光线追踪，在片段着色器（Fragment Shader）中执行。

4.1 锥追踪的基本原理

传统的光线追踪是发射一条细长的光线，与场景求交。锥追踪则发射一个圆锥体。为什么是圆锥？因为它模拟了光线的“粗细”和扩散，天然适合用来计算软阴影、漫反射全局光照和光泽反射。

在着色器中，对于屏幕上的每一个像素（即一个表面点）：

1. 确定表面信息：获取该点的世界坐标（worldPos）、法线（normal）和材质颜色（albedo）。
2. 发射锥体：沿着我们需要积分的照明方向发射锥体。例如，对于漫反射光照，我们可能会沿着法线半球随机发射多个锥体（近似半球积分）。对于阴影，则向光源方向发射一个锥体。
3. 步进采样：沿着锥体的中心轴，从表面点开始，以逐步增大的步长向前步进。在每一步的采样点，将世界坐标转换到体素纹理空间，对3D纹理进行三线性采样（tex3Dlod），获取该位置体素存储的颜色和遮挡信息。
4. 累积光照：根据采样到的体素颜色（作为间接光）、距离、以及锥体的衰减因子，累积贡献到最终像素颜色。如果采样到的体素“不透明”值（或距离场值）表明锥体已经击中了表面，则停止步进（对于阴影计算，这意味着该点处于阴影中）。

4.2 漫反射全局光照的锥追踪实现

下面是一个高度简化的、在Surface Shader或片元着色器中实现的单次锥追踪漫反射光照示例：

// 在片段着色器中 float3 CalculateVoxelConeTracingGI(float3 worldPos, float3 normal) { float3 indirectLight = float3(0, 0, 0); float3 voxelCoord = WorldToVoxelPos(worldPos); // 转换到体素纹理空间[0,1] // 定义锥体参数 float coneStep = 0.05; // 初始步长（体素空间） float coneMaxDistance = 1.0; // 最大追踪距离 float coneAperture = 0.577; // 锥体张角tan(半角)，对应约30度 float3 coneDirection = normalize(normal + randomOffset); // 可以加入一些随机偏移来采样半球 float currentDistance = coneStep; float3 accumulatedColor = float3(0,0,0); float accumulatedOpacity = 0.0; while(currentDistance < coneMaxDistance && accumulatedOpacity < 0.95) { // 计算当前步进位置（世界空间 -> 体素空间） float3 samplePos = worldPos + coneDirection * currentDistance; float3 sampleVoxelCoord = WorldToVoxelPos(samplePos); // 计算当前距离对应的Mipmap级别：距离越远，采样的Mip级别越高（锥体越粗） float mipLevel = log2(currentDistance * _Resolution / coneAperture); mipLevel = clamp(mipLevel, 0, 6.0); // 限制最大Mip级别 // 三线性采样体素纹理 float4 voxelSample = tex3Dlod(_GlobalVoxelTexture, float4(sampleVoxelCoord, mipLevel)); float3 sampleColor = voxelSample.rgb; float sampleDensity = voxelSample.a; // 假设Alpha通道存储密度/遮挡 // 累积贡献（简化模型：颜色乘以其透明度贡献） float weight = (1.0 - accumulatedOpacity) * sampleDensity; accumulatedColor += sampleColor * weight; accumulatedOpacity += weight; // 增加步长（可以是指数增长，以快速穿越空区域） currentDistance += coneStep * (1.0 + currentDistance * 0.5); coneStep *= 1.1; // 逐步增加步长 } // 假设累积的颜色就是间接光照 indirectLight = accumulatedColor; return indirectLight; }

这个函数返回了通过锥追踪从体素化场景中采集到的间接光颜色。你需要将其与直接光照（如主方向光）相加，得到最终像素颜色。对于高质量的GI，你需要在法线半球内发射多个锥体（例如6个或更多），并平均它们的结果，这类似于蒙特卡洛积分。

4.3 性能优化关键：Mipmap与三线性过滤

你可能注意到了代码中的tex3Dlod和mipLevel。这是VCT性能优化的灵魂所在。我们为体素纹理生成了Mipmap链。低层级的Mipmap是高层级体素的下采样（平均）。当我们追踪一个锥体时，在近处使用高分辨率的Mipmap（level 0）进行精细采样；随着步进距离变远，锥体覆盖的物理范围变大，我们就切换到低分辨率的Mipmap（更高的level）进行采样。这相当于用一次采样，就获取了一大片区域的平均光照信息，极大地减少了需要步进的次数和采样次数。

如何生成3D纹理的Mipmap？Unity的RenderTexture不会自动为3D纹理生成Mipmap。你需要自己编写一个Compute Shader，来逐级下采样（Downsample）你的体素纹理。这个过程通常是：创建一个分辨率减半的新3D纹理，然后对上一级纹理的8个相邻体素（2x2x2）进行加权平均，写入新纹理。重复此过程直到1x1x1。

注意事项：锥追踪的质量和性能受多个参数控制：coneStep（步长）、coneAperture（锥角）、coneMaxDistance（最大距离）以及发射的锥体数量。步长太小会导致采样次数爆炸，帧率骤降；步长太大会错过细节，产生漏光。一个实用的技巧是使用可变步长：在空区域（采样密度为0）大步前进，在接近物体表面时小步精细采样。这需要你的体素数据中存储一个“距离场”信息，而不仅仅是颜色。

5. 进阶技巧与性能调优实战

把基础管线跑通只是第一步。要让它在实际游戏中流畅运行且效果出色，还需要大量的调优和技巧。下面分享几个我踩过坑后总结的进阶经验。

5.1 双通道存储与距离场编码

我们之前用ARGBHalf（4个半精度浮点通道）存储颜色和法线。但很多时候，我们可能不需要每体素都存法线。一个高效的存储策略是：

• 通道1（RGB）：存储反照率颜色（Albedo）。
• 通道2（A）：存储有符号距离场（Signed Distance Field, SDF）或遮挡值。

SDF存储的是从该体素中心到最近物体表面的带符号距离。正值表示在物体外部，负值表示在物体内部。SDF对于锥追踪来说是“神器”：

• 加速追踪：知道了到表面的距离，我们可以安全地向前跳跃这个距离，而无需逐一体素步进，这就是“球体追踪”（Sphere Tracing）的思想，能极大提升性能。
• 提高精度：即使体素分辨率不高，SDF也能提供平滑的表面边界信息，减少方块感。

在体素化时，计算每个被占据体素的SDF值并存储。这通常需要在体素化后，运行一个额外的“距离变换”（Distance Transform）Compute Shader来处理整个体素场。

5.2 动态物体的高效更新：剪辑映射（Clipmap）

对于开放大世界，体素化整个场景是不现实的。一个经典解决方案是使用剪辑映射（Clipmap）技术。想象一下，围绕摄像机有一个多层嵌套的立方体网格，像洋葱一样。最内层（L0）分辨率最高，覆盖摄像机周围最小的区域；外层（L1，L2...）分辨率逐级减半，但覆盖范围逐级倍增。

工作流程：

1. 每帧，根据摄像机位置，更新这些Clipmap层级的位置（始终以摄像机为中心）。
2. 只体素化落在每一层Clipmap范围内的动态物体。静态场景的体素数据可以预先计算好，作为背景与动态体素数据融合。
3. 在锥追踪着色时，根据采样点距离摄像机的远近，决定从哪个层级的Clipmap中采样。近处用高精度层，远处用低精度层。

这样，我们只用有限的资源（例如4层64^3的纹理），就模拟了一个近乎无限的、具有层次细节的体素世界。这是将体素GI应用于大型动态场景的必备技术。

5.3 常见性能瓶颈与排查清单

当你发现帧率不理想时，可以按照以下清单排查：

5.4 与URP/HDRP的集成要点

如果你在使用URP或HDRP，集成方式略有不同：

• URP：你需要编写一个ScriptableRenderPass。在Execute方法中，使用CommandBuffer来调度你的Compute Shader，并管理RenderTexture。然后将体素纹理通过Shader.SetGlobalTexture设置。在URP的Lit Shader中，你可以通过编写自定义的SubShader或使用Shader Graph的Custom Function节点来插入你的锥追踪光照计算。
• HDRP：HDRP有更复杂的光照架构。推荐的方式是创建一个自定义的RenderPipelineMaterial或利用Custom Pass。HDRP的Shader框架（Shader Graph代码生成）更复杂，直接修改源码的Lit.shader可能更直接，但维护成本高。另一种思路是将体素GI作为屏幕空间后处理效果来计算，然后叠加到HDRP的照明结果上。

一个重要的实践建议是：先从Built-in RP开始原型开发。因为其Shader和管线相对简单，可以让你快速验证核心算法。待效果和性能稳定后，再迁移到URP/HDRP，这时你面对的主要是管线集成问题，而非算法问题。

最后，GPU加速体素化是一个深度、广度和细节都极其丰富的领域。本文为你搭建了一个从原理到基础实现的完整框架，并指出了性能调优和进阶应用的方向。真正的掌握，还需要你在自己的项目中不断实践、调试和优化。记住，参数没有银弹，最适合你项目的配置，一定来自于针对性的性能剖析（Profiling）和视觉对比。拿起Unity Profiler和Frame Debugger，开始你的体素化之旅吧，实时全局光照的大门已经为你打开。