Method BuildBVH

Source/Engine/Tools/ModelTool/MeshAccelerationStructure.cpp:23–172

static_assert(sizeof(GPUBVH) == sizeof(Float4) * 2, "Invalid BVH structure size for GPU.");

void MeshAccelerationStructure::BuildBVH(int32 node, BVHBuild& build)
{
    auto* root = &_bvh[node];
    ASSERT_LOW_LAYER(root->Leaf.IsLeaf);
    if (build.MaxLeafSize > 0 && root->Leaf.TriangleCount <= build.MaxLeafSize)
        return;
    if (build.MaxDepth > 0 && build.NodeDepth >= build.MaxDepth)
        return;

    // Spawn two leaves
    const int32 childIndex = _bvh.Count();
    _bvh.AddDefault(2);
    root = &_bvh[node];
    auto& left = _bvh.Get()[childIndex];
    auto& right = _bvh.Get()[childIndex + 1];
    left.Leaf.IsLeaf = 1;
    right.Leaf.IsLeaf = 1;
    left.Leaf.MeshIndex = root->Leaf.MeshIndex;
    right.Leaf.MeshIndex = root->Leaf.MeshIndex;

    // Mid-point splitting based on the largest axis
    const Float3 boundsSize = root->Bounds.GetSize();
    int32 axisCount = 0;
    int32 axis = 0;
RETRY:
    if (axisCount == 0)
    {
        // Pick the highest axis
        axis = 0;
        if (boundsSize.Y > boundsSize.X && boundsSize.Y >= boundsSize.Z)
            axis = 1;
        else if (boundsSize.Z > boundsSize.X)
            axis = 2;
    }
    else if (axisCount == 3)
    {
        // Failed to split
        _bvh.Resize(childIndex);
        return;
    }
    else
    {
        // Go to the next axis
        axis = (axis + 1) % 3;
    }
    const float midPoint = (float)(root->Bounds.Minimum.Raw[axis] + boundsSize.Raw[axis] * 0.5f);
    const Mesh& meshData = _meshes[root->Leaf.MeshIndex];
    const Float3* vb = meshData.VertexBuffer.Get<Float3>();
    int32 indexStart = root->Leaf.TriangleIndex * 3;
    int32 indexEnd = indexStart + root->Leaf.TriangleCount * 3;
    left.Leaf.TriangleCount = 0;
    right.Leaf.TriangleCount = 0;
    if (meshData.Use16BitIndexBuffer)
    {
        struct Tri
        {
            uint16 I0, I1, I2;
        };