二进制空间分区 - 空间分区逻辑错误

Question

所以我一直在实现我的第一个 BSP 树，我认为我发现我的逻辑存在缺陷。我对如何真正正确地重构它以使其按应有的方式工作感到非常迷茫。

这里是构造函数（解释如下）：

BSPTree::BSPTree( const polygonList_t& list )
    : mRoot( nullptr )
{
    polygonList_t front, back;

    auto eol = list.end();
    Polygon* rootSplitter = list[ 0 ];

    vec3 rootSplitPos;
    rootSplitter->GetPosition( rootSplitPos );

    for( auto iPoly = list.begin() + 1; iPoly != eol; ++iPoly )
    {
        vec3 resolvePos;
        ( *iPoly )->GetPosition( resolvePos );

        switch( ResolvePosition( rootSplitPos, resolvePos ) )
        {
            case POSITION_FRONT:
                front.push_back( *iPoly );
                break;

            case POSITION_BACK:
                back.push_back( *iPoly );
                break;

            case POSITION_SPLIT:
            {
                Polygon* toSplit = *iPoly;
                list.erase( iPoly );

                Polygon* outFront = new Polygon;
                Polygon* outBack  = new Polygon;

                SplitPolygon( resolvePos, toSplit, outFront, outBack );

                front.push_back( outFront );
                back.push_back( outBack );

                // finally we kill this one off
                delete toSplit;
                toSplit = nullptr;
            }
                break;
        }
    }

    mRoot = BSP_MakeNode();

    mRoot->splitter = rootSplitter;

    SplitSpace( mRoot, front );
    SplitSpace( mRoot, back );
}

简而言之，我们收到一个类型化的std::vector< Polygon* >，其中包含任意数量的堆分配的多边形对象。然后我们想把它们分成两类：在某个中心元素前面的和后面的。自然地，我们声明了两个具有相同 typedef 的列表，并将它们分别称为 front 和 back。

首先，我们选择一个多边形（最终我想找到一个看起来最适合根分区平面的多边形），然后我们遍历我们的原始列表，检查以下 3 种情况之一：

（注意 - 为简洁起见，我只是将我们的根分区多边形命名为 root）

• POSITION_FRONT：我们知道当前列表中的多边形在root的前面，所以我们很自然地把这个多边形添加到我们的前面列表中。

• POSITION_BACK: 和位置一样，唯一的不同是这个多边形在根的后面。

• POSITION_SPLIT：我们无法确定这个多边形是在root前面还是后面，所以我们把它分成两部分，插入前后部分将其添加到各自的列表中。

最后，一旦我们将多边形划分为它们的前列表和后列表，我们将进一步细分我们的空间，使用根作为初始细分的基础。

void BSPTree::SplitSpace( bspNode_t* node, polygonList_t& polygons )
{
    if ( polygons.size() == 0 ) return;

    // grab the first polygon within the list,
    // and then subtract it from the list itself.
    Polygon* next = polygons[ 0 ];
    polygons.pop_back();

    vec3 splitPos;
    node->splitter->GetPosition( splitPos );

    vec3 toResolve;
    next->GetPosition( toResolve );

    switch( ResolvePosition( splitPos, toResolve ) )
    {
        case POSITION_FRONT:
            node->front = BSP_MakeNode();
            node->front->splitter = next;
            SplitSpace( node->front, polygons );
            break;

        case POSITION_BACK:
            node->back = BSP_MakeNode();
            node->back->splitter = next;
            SplitSpace( node->back, polygons );
            break;

        case POSITION_SPLIT:
        {
            Polygon* outFront = new Polygon;
            Polygon* outBack  = new Polygon;

            SplitPolygon( toResolve, next, outFront, outBack );

            node->front = BSP_MakeNode();
            node->back  = BSP_MakeNode();

            node->front->splitter = outFront;
            node->back->splitter = outBack;

            SplitSpace( node->front, polygons );
            SplitSpace( node->back, polygons );
        }
            break;
    }
}

现在，我们执行非常相似的操作序列，主要区别在于我们进一步细分已经分区的空间，直到每个多边形在节点树中具有给定位置，即在前面或后面其父节点。当然，我们递归地执行此操作。

我目前看到的问题在于上述 switch 语句中的 POSITION_SPLIT 案例评估：

        case POSITION_SPLIT:
        {
            Polygon* outFront = new Polygon;
            Polygon* outBack  = new Polygon;

            SplitPolygon( toResolve, next, outFront, outBack );

            node->front = BSP_MakeNode();
            node->back  = BSP_MakeNode();

            node->front->splitter = outFront;
            node->back->splitter = outBack;

            SplitSpace( node->front, polygons ); // here
            SplitSpace( node->back, polygons );  // and here
        }

结合其他两个因素：

1234563

• 结合前面提到的，每次调用SplitSpace(...) 都会检查它接收到的列表是否为空。如果是这样，则什么都不做，并且该列表的递归细分已经完成。

由于这两个因素，我不禁认为，在POSITION_SPLIT案例评估中，第二次调用SplitSpace(...)是没有用的：在第二次调用之前列表将被耗尽（以容纳back 部分）。

问题

那么，有什么办法可以解决这个问题，至少能让我重回正轨？

Answer 1

您应该将 BSPTree 构造函数重构为递归逻辑并应用分治法。
1. 输入是多边形列表。
2. 选择一个分裂平面，这是 BSP 中的当前节点。
3. 将多边形细分为正面和背面。
4. 将前面的列表传递给同一个函数（递归），取回一个子节点。
5. 将返回列表传递给同一函数（递归），取回一个子节点。
6. 返回当前节点。

bspNode_t* BuildBSP( const polygonList_t& list )
{
 polygonList_t front, back;
 Polygon* rootSplitter = list[ 0 ];
 bspNode_t* currentNode = new bspNode_t(rootSplitter);

 vec3 rootSplitPos;
 rootSplitter->GetPosition( rootSplitPos );

 for( auto iPoly = list.begin() + 1; iPoly != eol; ++iPoly )
 {
   vec3 resolvePos;
   ( *iPoly )->GetPosition( resolvePos );

   switch( ResolvePosition( rootSplitPos, resolvePos ) )
   {
     case POSITION_FRONT:
       front.push_back( *iPoly );
       break;

     case POSITION_BACK:
       back.push_back( *iPoly );
       break;

     case POSITION_SPLIT:
     {
       Polygon* toSplit = *iPoly;
       list.erase( iPoly );

       Polygon* outFront = new Polygon;
       Polygon* outBack  = new Polygon;

       SplitPolygon( resolvePos, toSplit, outFront, outBack );

       front.push_back( outFront );
       back.push_back( outBack );

       // finally we kill this one off
       delete toSplit;
       toSplit = nullptr;

       break;
    }
  }
}

currentNode->frontChild = BuildBSP(front);
currentNode->backChild = BuildBSP(back);

return currentNode;

}