Slang光线追踪加速结构：BVH构建与遍历优化

2026-02-05 04:25:05作者：伍霜盼Ellen

在计算机图形学领域，光线追踪（Ray Tracing）技术能够生成高度逼真的图像，但复杂场景下的计算开销一直是其广泛应用的障碍。Slang作为专注于简化着色器开发的编程语言，通过高效的光线追踪加速结构实现，显著提升了实时渲染性能。本文将深入解析Slang中的Bounding Volume Hierarchy（BVH，包围体层次结构）实现，重点探讨构建策略与遍历优化技术，帮助开发者充分利用Slang的光线追踪能力。

BVH加速结构基础

光线追踪的核心挑战在于如何快速确定光线与场景中几何体的交点。在复杂场景中，未经优化的暴力搜索（Brute-force Search）需要将每条光线与场景中所有几何体进行相交测试，时间复杂度高达O(n)，完全无法满足实时渲染需求。BVH通过将场景中的几何体按照空间位置进行层次化分组，能够将光线相交测试的时间复杂度降低至O(log n)，是当前工业界应用最广泛的光线追踪加速技术之一。

Slang的BVH实现遵循经典的层次化包围体设计思想，主要包含以下核心组件：

包围体（Bounding Volume）：采用轴对齐包围盒（AABB，Axis-Aligned Bounding Box）作为基础包围体，每个节点包含一个能够完全容纳其所有子节点或几何体的AABB。
层次化结构：整个场景被组织为树形结构，根节点包含整个场景，叶子节点对应具体的几何体，内部节点则包含子节点的合并包围体。
构建算法：通过递归划分场景几何体，构建平衡的层次结构，确保光线遍历效率。
遍历算法：基于栈的深度优先搜索（DFS）或广度优先搜索（BFS），结合包围体相交测试，快速定位光线可能相交的几何体。

Slang的BVH实现源码位于tests/fcpw/bvh.slang，该文件定义了完整的BVH数据结构、构建逻辑和遍历算法。同时，Slang还提供了多个光线追踪示例程序，如examples/ray-tracing/shaders.slang和examples/ray-tracing-pipeline/shaders.slang，展示了如何在实际渲染场景中应用BVH加速结构。

Slang BVH数据结构设计

Slang的BVH实现采用了泛型编程思想，通过模板参数和接口抽象，提供了高度灵活和可扩展的BVH数据结构。核心数据结构定义如下：

节点结构

BVH的节点结构在tests/fcpw/bvh.slang中定义，主要包含以下类型：

public struct TraversalStack
{
    public uint node;      // 节点索引
    public float distance; // 到该节点的最小距离（参数化距离、平方距离等）

    // 构造函数
    public __init()
    {
        node = 0;
        distance = 0.0;
    }
};

public struct Bvh<N : IBvhNode, P : IPrimitive, S : ISilhouette> : IAggregate
{
    public RWStructuredBuffer<N> nodes;          // 节点缓冲区
    public StructuredBuffer<P> primitives;       // 几何体缓冲区
    public StructuredBuffer<S> silhouettes;      // 轮廓缓冲区
    // ... 方法定义 ...
}

上述代码展示了Slang BVH的核心数据结构。Bvh类是一个泛型类，通过模板参数N（节点类型）、P（几何体类型）和S（轮廓类型）实现了高度的通用性。nodes是一个结构化缓冲区，存储了BVH的所有节点数据；primitives存储了场景中的所有几何体数据；silhouettes则用于存储几何体的轮廓信息，主要用于特定的渲染优化。

包围体定义

Slang的BVH实现中，包围体主要包含包围盒（Bounding Box）和包围锥（Bounding Cone）两种类型，分别用于不同的相交测试场景：

// 包围盒定义（隐式）
struct BoundingBox 
{
    float3 pMin;  // 最小顶点
    float3 pMax;  // 最大顶点

    // 计算包围盒的中心
    float3 getCentroid() { return 0.5 * (pMin + pMax); }

    // 合并两个包围盒
    BoundingBox mergeBoundingBoxes(BoundingBox a, BoundingBox b) 
    {
        return BoundingBox(min(a.pMin, b.pMin), max(a.pMax, b.pMax));
    }

    // 光线与包围盒相交测试
    bool intersect(Ray r, out float tMin, out float tMax) 
    {
        // 经典的Slab测试算法实现
        // ...
    }
};

// 包围锥定义（隐式）
struct BoundingCone 
{
    float3 axis;      // 锥轴方向
    float halfAngle;  // 半锥角
    float radius;     // 锥半径

    // 检查包围锥是否有效
    bool isValid() { return halfAngle >= 0; }

    // 光线与包围锥相交测试
    bool overlap(float3 rayOrigin, float3 rayDir, out float t) 
    {
        // 包围锥相交测试算法实现
        // ...
    }
};

包围盒主要用于快速排除明显不相交的节点，而包围锥则在特定场景下（如毛发渲染、光束追踪等）提供更紧凑的包围体表示，进一步提升遍历效率。Slang的BVH实现中，每个节点可以同时包含包围盒和包围锥，根据场景特性动态选择最适合的相交测试方法。

BVH构建算法

BVH的构建质量直接影响后续光线遍历的效率，一个平衡良好、包围体紧致的BVH结构能够显著减少光线相交测试的次数。Slang采用了自底向上的BVH构建算法，结合表面积启发式（SAH，Surface Area Heuristic）划分策略，构建高效的层次化结构。

构建流程概述

Slang的BVH构建过程主要包含以下步骤：

初始化：为每个几何体创建一个叶子节点，并计算其包围体。
层次化构建：采用自底向上的方式，通过合并相邻节点构建更高层次的内部节点，直到形成包含整个场景的根节点。
优化：通过调整节点顺序和结构，优化BVH的平衡性和包围体紧致性。

核心构建代码位于tests/fcpw/bvh.slang的refit方法中，该方法实现了BVH的自底向上更新逻辑：

// 更新节点的包围体（叶子节点）
[mutating]
internal void refitLeafNode(uint nodeIndex)
{
    // 初始化包围盒为无穷大
    float3 pMin = float3(FLT_MAX, FLT_MAX, FLT_MAX);
    float3 pMax = float3(-FLT_MAX, -FLT_MAX, -FLT_MAX);
    N node = nodes[nodeIndex];
    uint nPrimitives = node.getNumPrimitives();

    // 合并所有几何体的包围盒
    for (uint p = 0; p < nPrimitives; p++)
    {
        uint primitiveIndex = node.getPrimitiveOffset() + p;
        BoundingBox primitiveBox = primitives[primitiveIndex].getBoundingBox();
        pMin = min(pMin, primitiveBox.pMin);
        pMax = max(pMax, primitiveBox.pMax);
    }

    // 更新节点的包围盒
    node.setBoundingBox(BoundingBox(pMin, pMax));

    // 如果需要，更新节点的包围锥
    if (node.hasBoundingCone())
    {
        // 计算所有轮廓的法向量，构建包围锥
        // ...
        node.setBoundingCone(BoundingCone(axis, halfAngle, radius));
    }
}

// 更新节点的包围体（内部节点）
[mutating]
internal void refitInternalNode(uint nodeIndex)
{
    N node = nodes[nodeIndex];
    uint leftNodeIndex = nodeIndex + 1;
    uint rightNodeIndex = nodeIndex + node.getRightChildOffset();
    N leftNode = nodes[leftNodeIndex];
    N rightNode = nodes[rightNodeIndex];

    // 合并左右子节点的包围盒
    BoundingBox leftBox = leftNode.getBoundingBox();
    BoundingBox rightBox = rightNode.getBoundingBox();
    BoundingBox mergedBox = mergeBoundingBoxes(leftBox, rightBox);
    node.setBoundingBox(mergedBox);

    // 如果需要，合并左右子节点的包围锥
    if (node.hasBoundingCone())
    {
        BoundingCone leftCone = leftNode.getBoundingCone();
        BoundingCone rightCone = rightNode.getBoundingCone();
        BoundingCone mergedCone = mergeBoundingCones(leftCone, rightCone,
                                                    leftBox.getCentroid(),
                                                    rightBox.getCentroid(),
                                                    mergedBox.getCentroid());
        node.setBoundingCone(mergedCone);
    }
}

上述代码展示了Slang BVH构建中的核心步骤——包围体更新。refitLeafNode方法负责计算叶子节点的包围体，它遍历该节点包含的所有几何体，合并它们的包围盒和包围锥；refitInternalNode方法则负责合并子节点的包围体，构建父节点的包围体。整个BVH的构建过程就是从叶子节点开始，自底向上递归调用这两个方法，最终构建出完整的层次化结构。

SAH划分策略

Slang的BVH构建算法采用了表面积启发式（SAH）作为划分策略，这是一种基于统计的优化方法，能够显著提升BVH的遍历效率。SAH的核心思想是：在划分节点时，选择能够最小化预期光线遍历成本的划分平面。

SAH的成本函数定义如下：

Cost = C_traversal * (N_left * A_left + N_right * A_right) / A_parent + C_intersect * (N_left + N_right)

其中：

C_traversal 是遍历节点的时间成本
C_intersect 是几何体相交测试的时间成本
N_left 和 N_right 是左右子节点包含的几何体数量
A_left、A_right 和 A_parent 是左右子节点和父节点的包围体表面积

Slang的SAH实现虽然未在公开代码中完全展示，但可以通过tests/fcpw/bvh.slang中的节点划分逻辑推断其大致实现。在实际应用中，Slang会根据场景特性动态调整SAH参数，在构建速度和遍历效率之间取得平衡。

BVH遍历优化技术

BVH的遍历算法是决定光线追踪性能的关键因素之一。Slang实现了多种遍历优化技术，能够在不同硬件平台和场景下提供最佳性能。

基于栈的深度优先遍历

Slang采用基于栈的深度优先遍历算法作为基础遍历方法，实现代码位于tests/fcpw/bvh.slang的intersect方法中：

public bool intersect(inout Ray r, bool checkForOcclusion, inout Interaction i)
{
    TraversalStack traversalStack[FCPW_BVH_MAX_DEPTH];  // 遍历栈
    float4 distToChildNodes = float4(0.0, 0.0, 0.0, 0.0);  // 子节点相交距离
    BoundingBox rootBox = nodes[0].getBoundingBox();
    bool didIntersect = false;

    // 检查光线是否与根节点相交
    if (rootBox.intersect(r, distToChildNodes[0], distToChildNodes[1]))
    {
        traversalStack[0].node = 0;  // 根节点入栈
        traversalStack[0].distance = distToChildNodes[0];
        int stackPtr = 0;  // 栈指针

        while (stackPtr >= 0)
        {
            // 弹出栈顶节点
            uint currentNodeIndex = traversalStack[stackPtr].node;
            float currentDist = traversalStack[stackPtr].distance;
            stackPtr--;

            // 如果当前节点距离大于光线的最大t值，跳过
            if (currentDist > r.tMax)
                continue;

            N node = nodes[currentNodeIndex];
            if (node.isLeaf())
            {
                // 叶子节点：测试光线与所有几何体的相交
                uint nPrimitives = node.getNumPrimitives();
                for (uint p = 0; p < nPrimitives; p++)
                {
                    uint primitiveIndex = node.getPrimitiveOffset() + p;
                    Interaction c;
                    bool didIntersectPrimitive = primitives[primitiveIndex].intersect(r, checkForOcclusion, c);

                    if (didIntersectPrimitive)
                    {
                        if (checkForOcclusion)
                        {
                            // 遮挡测试：找到第一个交点即可返回
                            i = c;
                            return true;
                        }

                        // 更新最近交点
                        didIntersect = true;
                        r.tMax = min(r.tMax, c.d);
                        i = c;
                    }
                }
            }
            else
            {
                // 内部节点：测试光线与子节点的相交
                uint leftNodeIndex = currentNodeIndex + 1;
                BoundingBox leftBox = nodes[leftNodeIndex].getBoundingBox();
                bool didIntersectLeft = leftBox.intersect(r, distToChildNodes[0], distToChildNodes[1]);

                uint rightNodeIndex = currentNodeIndex + node.getRightChildOffset();
                BoundingBox rightBox = nodes[rightNodeIndex].getBoundingBox();
                bool didIntersectRight = rightBox.intersect(r, distToChildNodes[2], distToChildNodes[3]);

                // 按照距离排序子节点，近处节点先入栈
                if (didIntersectLeft && didIntersectRight)
                {
                    uint closer = leftNodeIndex;
                    uint other = rightNodeIndex;

                    // 如果右节点更近，则交换
                    if (distToChildNodes[2] < distToChildNodes[0])
                    {
                        swap(distToChildNodes[0], distToChildNodes[2]);
                        swap(closer, other);
                    }

                    // 远处节点先入栈，近处节点后入栈，保证近处节点先出栈
                    stackPtr++;
                    traversalStack[stackPtr].node = other;
                    traversalStack[stackPtr].distance = distToChildNodes[2];

                    stackPtr++;
                    traversalStack[stackPtr].node = closer;
                    traversalStack[stackPtr].distance = distToChildNodes[0];
                }
                else if (didIntersectLeft)
                {
                    stackPtr++;
                    traversalStack[stackPtr].node = leftNodeIndex;
                    traversalStack[stackPtr].distance = distToChildNodes[0];
                }
                else if (didIntersectRight)
                {
                    stackPtr++;
                    traversalStack[stackPtr].node = rightNodeIndex;
                    traversalStack[stackPtr].distance = distToChildNodes[2];
                }
            }
        }
    }

    return didIntersect;
}

上述代码展示了Slang的BVH遍历算法实现。核心优化点包括：

最近节点优先：光线与左右子节点相交时，优先遍历更近的节点，能够更快找到交点，尤其在遮挡测试场景下效果显著。
栈内存优化：使用固定大小的数组作为遍历栈，避免动态内存分配，提升缓存效率。
早期终止：在遮挡测试模式下，一旦找到交点立即返回，避免不必要的遍历。

光线追踪API集成

Slang不仅提供了底层的BVH实现，还与现代图形API（如Vulkan、DirectX 12）的光线追踪扩展深度集成，能够充分利用硬件加速能力。在Slang的光线追踪示例中，如examples/ray-tracing-pipeline/shaders.slang，展示了如何使用硬件加速的光线追踪API：

// 定义光线负载结构
struct [raypayload] RayPayload
{
    float4 color : read(caller) : write(caller, closesthit, miss);
};

// 光线生成着色器
[shader("raygeneration")]
void rayGenShader()
{
    uint2 threadIdx = DispatchRaysIndex().xy;
    // ... 计算光线方向 ...

    // 追踪光线
    RayDesc ray;
    ray.Origin = uniforms.cameraPosition.xyz;
    ray.Direction = rayDir;
    ray.TMin = 0.001;
    ray.TMax = 10000.0;
    RayPayload payload = { float4(0, 0, 0, 0) };
    TraceRay(sceneBVH, RAY_FLAG_NONE, ~0, 0, 0, 0, ray, payload);

    resultTexture[threadIdx.xy] = payload.color;
}

// 最近命中着色器
[shader("closesthit")]
void closestHitShader(inout RayPayload payload, in BuiltInTriangleIntersectionAttributes attr)
{
    float3 hitLocation = WorldRayOrigin() + WorldRayDirection() * RayTCurrent();
    // ... 计算光照 ...
    payload.color = float4(color * intensity, 1.0f);
}

// 未命中着色器
[shader("miss")]
void missShader(inout RayPayload payload)
{
    payload.color = float4(0, 0, 0, 1);  // 黑色背景
}

在上述代码中，TraceRay函数是Slang对硬件光线追踪API的封装，能够直接利用GPU的光线追踪核心（如NVIDIA的RT Core）加速BVH遍历和相交测试。Slang的BVH实现与硬件加速API无缝衔接，开发者可以根据需求选择软件BVH或硬件加速实现，在兼容性和性能之间取得平衡。

进阶优化技术

Slang还实现了多种进阶优化技术，进一步提升BVH性能：

空间划分优化：Support for multiple spatial partitioning strategies, including grid-based partitioning and k-d trees, allowing developers to choose the best strategy for their specific scene.
缓存优化：BVH节点布局优化，确保遍历过程中的内存访问符合缓存友好模式，减少缓存未命中。
动态BVH更新：支持动态场景的BVH增量更新，避免静态BVH需要完全重建的性能开销，源码位于tests/fcpw/bvh-refit.cs.slang。
SIMD优化：利用单指令多数据（SIMD）指令集，并行处理多条光线的BVH遍历，提升数据级并行性。

实际应用案例

Slang的BVH实现已经在多个光线追踪示例中得到验证，下面以examples/ray-tracing/shaders.slang为例，展示Slang BVH的实际应用效果。

示例场景描述

该示例实现了一个简单的光线追踪场景，包含多个三角形几何体和一个点光源。场景的BVH结构在CPU端构建，然后上传到GPU内存。在GPU端，使用Slang的光线追踪API对场景进行渲染，核心代码如下：

// 定义光线追踪加速结构
uniform RaytracingAccelerationStructure sceneBVH;

// 追踪最近命中的光线
bool traceRayNearestHit(
    RaytracingAccelerationStructure sceneBVH,
    float3 rayOrigin,
    float3 rayDir,
    out float t,
    out int primitiveIndex)
{
    RayDesc ray;
    ray.Origin = rayOrigin;
    ray.TMin = 0.01f;
    ray.Direction = rayDir;
    ray.TMax = 1e4f;
    RayQuery<RAY_FLAG_NONE> q;
    let rayFlags = RAY_FLAG_NONE;

    q.TraceRayInline(
        sceneBVH,
        rayFlags,
        0xff,
        ray);

    q.Proceed();
    if(q.CommittedStatus() == COMMITTED_TRIANGLE_HIT)
    {
        t = q.CommittedRayT();
        primitiveIndex = q.CommittedPrimitiveIndex();
        return true;
    }
    primitiveIndex = q.CandidatePrimitiveIndex();
    unused(t);
    return false;
}

// 主计算着色器
[shader("compute")]
[numthreads(16,16,1)]
void computeMain(
    uint3 threadIdx : SV_DispatchThreadID,
    uniform RWTexture2D resultTexture,
    uniform RaytracingAccelerationStructure sceneBVH,
    uniform StructuredBuffer<Primitive> primitiveBuffer,
    uniform Uniforms uniforms)
{
    // ... 计算光线方向 ...

    int primitiveIndex = 0;
    float intersectionT;
    if (traceRayNearestHit(sceneBVH, uniforms.cameraPosition.xyz, rayDir, intersectionT, primitiveIndex))
    {
        // ... 计算光照和阴影 ...
        resultColor = float4(color * intensity, 1.0f);
    }
    resultTexture[threadIdx.xy] = resultColor;
}

在这个示例中，sceneBVH是预构建的BVH加速结构，traceRayNearestHit函数使用Slang的光线查询API对BVH进行遍历，找出光线与场景的最近交点。通过使用Slang的BVH实现，该示例能够在普通GPU上实现每秒数十帧的光线追踪渲染性能。