加速结构 #

// binding = 2: BLASNode
struct AABB {
    vec3 min;
    vec3 max;
};
struct BLASNode {
    AABB bounds;
    ivec3 indices;
    int left;
    int right;
};
layout(std430, binding = 2) readonly buffer BLASBuffer {
    BLASNode blasNodes[];
};

// binding = 3: TLASInstance
struct TLASInstance {
    mat4 transform;
    AABB worldBounds;
    int rootNodeIndex; // 对应BLAS根节点位置
    int baseIndexOffset;
    int materialID;
};
layout(std430, binding = 3) readonly buffer TLASInstanceBuffer {
    TLASInstance instances[];
};

// binding = 4: TLASNode
struct TLASNode {
    AABB bounds;
    int left;
    int right;
    int instanceIndex;
};
layout(std430, binding = 4) readonly buffer TLASNodeBuffer {
    TLASNode tlasNodes[];
};

// 从 TLAS 开始进行包围盒遍历，并在叶子节点中调用 BLAS 进一步追踪
void traceTLAS_stack(int rootIndex, vec3 rayOrig, vec3 rayDir, inout float minT, inout vec3 hitColor) {
    int stack[MAX_STACK_SIZE];  // 遍历用的栈
    int sp = 0;                 // 栈指针
    stack[sp++] = rootIndex;   // 初始推入根节点

    while (sp > 0) {
        int nodeIndex = stack[--sp];              // 弹出当前节点索引
        TLASNode node = tlasNodes[nodeIndex];     // 获取当前 TLAS 节点

        // 如果射线未与该节点的 AABB 相交，跳过
        if (!intersectAABB(rayOrig, rayDir, node.bounds)) continue;

        // 叶子节点，表示是一个具体的实例
        if (node.left == -1 && node.right == -1) {
            int instanceIndex = node.instanceIndex;
            TLASInstance inst = instances[instanceIndex];  // 取出对应的实例信息
            mat4 model = inst.transform;                   // 实例的变换矩阵（局部 -> 世界）
            mat4 invModel = inverse(model);                // 世界 -> 局部（仅 BLAS 中使用）

            // 追踪该实例下的 BLAS
            traceBLAS_stack(inst.rootNodeIndex, rayOrig, rayDir, model, inst.materialID, inst.baseIndexOffset, minT, hitColor);
        } else {
            // 非叶子节点，将左右子节点入栈
            if (node.right >= 0) stack[sp++] = node.right;
            if (node.left >= 0)  stack[sp++] = node.left;
        }

        // 防止栈溢出
        if (sp >= MAX_STACK_SIZE) break;
    }
}

// 对一个具体的 BLAS 实例执行射线遍历和相交测试
void traceBLAS_stack(int rootIndex, vec3 rayOrig, vec3 rayDir, mat4 model, int materialID, int baseIndexOffset, inout float minT, inout vec3 hitColor) {
    int stack[MAX_STACK_SIZE];
    int sp = 0;
    stack[sp++] = rootIndex;

    // 把射线从世界空间变换到局部空间（与网格对齐）
    mat4 invModel = inverse(model);
    vec3 localOrigin = vec3(invModel * vec4(rayOrig, 1.0));
    vec3 localDir = normalize(mat3(invModel) * rayDir);

    while (sp > 0) {
        int nodeIndex = stack[--sp];
        BLASNode node = blasNodes[nodeIndex];

        // 局部空间下与 AABB 不相交，跳过
        if (!intersectAABB(localOrigin, localDir, node.bounds)) continue;

        // 叶子节点：执行三角形相交测试
        if (node.right < 0 && node.left < 0) {
            for (int i = 0; i < 3; ++i) {
                int localIndex = node.indices[i];
                if (localIndex == -1) break; // 无效索引跳过

                int idx = baseIndexOffset + localIndex;

                // 取出三角形顶点（局部空间）
                vec3 v0 = vertices[indices[idx + 0]].Position;
                vec3 v1 = vertices[indices[idx + 1]].Position;
                vec3 v2 = vertices[indices[idx + 2]].Position;

                float t;
                // 射线与三角形求交，t 为局部空间下的距离
                if (intersectTriangle(localOrigin, localDir, v0, v1, v2, t)) {
                    // 命中点从局部转到世界空间
                    vec3 hitLocal = localOrigin + t * localDir;
                    vec3 hitWorld = vec3(model * vec4(hitLocal, 1.0));
                    float tWorld = length(hitWorld - rayOrig); // 世界空间距离

                    // 如果距离更小，更新最小距离和命中颜色
                    if (tWorld < minT) {
                        minT = tWorld;
                        hitColor = materials[materialID].baseColor;
                    }
                }
            }
        } else {
            // 非叶子节点，压入左右子节点
            if (node.right >= 0) stack[sp++] = node.right;
            if (node.left >= 0)  stack[sp++] = node.left;
        }

        if (sp >= MAX_STACK_SIZE) break;
    }
}

// 2. 初始化 hit 信息
float minT = 1e20;
vec3 hitColor = vec3(0.0);

// 3. 遍历 TLAS 根节点（最后一个）
int tlasRoot = int(tlasNodes.length()) - 1;
traceTLAS_stack(tlasRoot, rayOrig, rayDir, minT, hitColor);