BVH树碰撞检测：递归与栈实现的比较-CSDN博客

本文链接：https://blog.csdn.net/OK_why_not/article/details/136567676

一. 背景

模型中两个组件都构建成为BVH树（二叉树），需要在两颗树同级节点之间进行碰撞检测。

具体流程如下：首先对两棵树的根节点包围盒进行碰撞检测(A1-B1)，若发生碰撞则继续对每个子节点之间进行碰撞检测(A2-B2、A2-B3、A3-B2、A3-B3)，若不发生碰撞则跳过。以此类推，直到检测完某一层级节点都未发生碰撞，或者检测到有叶子节点发生碰撞，则对应返回结果。

二. 使用递归调用实现

假设节点A4与B6发生碰撞，使用函数的递归调用实现对树节点的遍历，流程图与代码如下：

AabbTreeNode* GetPosForDetection(AabbTreeNode*, AabbTree*);    //获取节点的左子节点
AabbTreeNode* GetNegForDetection(AabbTreeNode*, AabbTree*);    //获取节点的右子节点

Bit32 Collide(AabbTreeNode* a, AabbTreeNode* b, AabbTree* pAabbTree1, AabbTree* pAabbTree2) { 
    Bit32 retFlag = -1, i = 0;
    //做包围盒相交判断，节点包围盒是否发生碰撞，如果判断出没有碰撞则不进行其子节点的检测
    retFlag = BoxBoxOverlap(&a->bv, &b->bv);
    if (retFlag == 0) {
        return retFlag;
    }
    //判断a是否为子节点
    if(IsLeaf(a, pAabbTree1) == 0) { 
        //判断b是否为子节点
        if (IsLeaf(b, pAabbTree2) == 0) {
            retFlag = Collide(GetPosForDetection(a,pAabbTree1), GetPosForDetection(b,pAabbTree2), pAabbTree1, pAabbTree2); 
            if(retFlag == 1) {
                return retFlag;
            }
            retFlag = Collide(GetPosForDetection(a,pAabbTree1), GetNegForDetection(b,pAabbTree2), pAabbTree1, pAabbTree2); 
            if (retFlag == 1) {
                return retFlag;
            }
            retFlag = Collide(GetNegForDetection(a,pAabbTree1), GetPosForDetection(b,pAabbTree2), pAabbTree1, pAabbTree2); 
            if (retFlag == 1){
                return retFlag;
            }
            retFlag = Collide(GetNegForDetection(a,pAabbTree1), GetNegForDetection(b,pAabbTree2), pAabbTree1, pAabbTree2); 
            if(retFlag == 1){
                return retFlag; 
            }
        }
        else {
            retFlag = Collide(GetPosForDetection(a,pAabbTree1), b, pAabbTree1, pAabbTree2); 
            if (retFlag == 1){
                return retFlag;
            }
            retFlag = Collide(GetNegForDetection(a,pAabbTree1), b, pAabbTree1, pAabbTree2); 
            if (retFlag == 1){
            return retFlag; 
            }
    else {
        if (IsLeaf(b, pAabbTree2) == 0) {
            retFlag = Collide(a, GetPosForDetection(b,pAabbTree2), pAabbTree1, pAabbTree2); 
            if (retFlag == 1) {
                return retFlag;
            }
            retFlag = Collide(a, GetNegForDetection(b,pAabbTree2), pAabbTree1, pAabbTree2); 
            if (retFlag == 1) {
                return retFlag; 
            }
        else {
            //a、b都是叶子节点，进入图元碰撞检测，碰撞则返回1
            ......
        }
    }
    return 0;    // 未发生碰撞则返回0
}

三. 用栈实现

假设节点A7与B5发生碰撞，使用函数的递归调用实现对树节点的遍历，流程图与代码如下：

首先定义了栈的数据结构：

#define MAX_STNODE_NUM (100)    //栈最大容纳的节点对数量

//定义栈结构
typedef struct _CollisionStack {
    AabbTreeNode* nodeA;    //栈存储的第一个节点包围盒
    AabbTreeNode* nodeB;    //栈存储的第二个节点包围盒
}CollisionStack;

typedef struct _CollisionContext { 
    Bit32 top;    //栈顶索引 
    CollisionStack stack[MAX_STNODE_NUM];    //存放在栈内的节点数据
}CollisionContext;

//栈的操作方法
//元素入栈
void stackPush(CollisionStack* stack, Bit32* top, AabbTreeNode* nodeA, AabbTreeNode* nodeB) { 
    stack[*top].nodeA = nodeA;
    stack[*top].nodeB = nodeB;
    (*top)++;
}
//元素出栈
void stackPop(Bit32* top) { 
    if (*top <= 0) {
        *top = 0; 
        return;
    }
    (*top)--;
}
//判断栈是否为空
Bit32 stackIsEmpty(Bit32 top) { 
    return (top <= 0);
}

用栈实现对树节点的遍历：

Bit32 CollisionCheckWithStack(AabbTree* pAabbTree1, AabbTree* pAabbTree2, CollisionContext* context) { 
    Bit32 ret = -1;
    Bit32 i = 0;
    if (context->top == 0) {
        //将根节点推入栈
        stackPush(context->stack, &(context->top), &pAabbTree1->treeNode, &pAabbTree2->treeNode); 
    }
    while (!stackIsEmpty(context->top)) {
        CollisionStack currentNodePair = context->stack[context->top - 1]; 
        stackPop(&(context->top));
        //进行节点包围盒检测，不碰撞则不检测其子节点
        ret=BoxBoxOverlap(&currentNodePair.nodeA->bv, &currentNodePair.nodeB->bv); 
        if (ret == 0) {
            continue;
        }
        //判断节点是否为叶子节点
        if (IsLeaf(currentNodePair.nodeA, pAabbTree1) == 0) { 
            if (IsLeaf(currentNodePair.nodeB, pAabbTree2) == 0) { 
                //A和B都不是叶子节点，将所有组合推入栈
                stackPush(context->stack, &(context->top), GetPosForDetection(currentNodePair.nodeA, pAabbTree1), GetPosForDetection(currentNodePair.nodeB, pAabbTree2)); 
                stackPush(context->stack, &(context->top), GetPosForDetection(currentNodePair.nodeA, pAabbTree1), GetNegForDetection(currentNodePair.nodeB, pAabbTree2)); 
                stackPush(context->stack, &(context->top), GetNegForDetection(currentNodePair.nodeA,pAabbTree1), GetPosForDetection(currentNodePair.nodeB,pAabbTree2)); 
                stackPush(context->stack, &(context->top), GetNegForDetection(currentNodePair.nodeA, pAabbTree1), GetNegForDetection(currentNodePair.nodeB, pAabbTree2)); 
            }
            else
            {
                //B是叶子节点，将A的两个子节点推入栈
                stackPush(context->stack, &(context->top), GetPosForDetection(currentNodePair.nodeA,pAabbTree1), currentNodePair.nodeB);
                stackPush(context->stack,&(context->top), GetNegForDetection(currentNodePair.nodeA,pAabbTree1), currentNodePair.nodeB); 
            }
        else {
            //A是叶子节点
            if (IsLeaf(currentNodePair.nodeB, pAabbTree2) == 0) {
                // B是内部节点，将B的两个子节点推入栈
                stackPush(context->stack, &(context->top), currentNodePair.nodeA, GetPosForDetection(currentNodePair.nodeB,pAabbTree2)); 
                stackPush(context->stack, &(context->top), currentNodePair.nodeA, GetNegForDetection(currentNodePair.nodeB,pAabbTree2)); 
            }
            else {
                //a、b都是叶子节点，进入图元碰撞检测，碰撞则返回1
                ......
            }
        }
    }
    return 0;    // 未发生碰撞则返回0
}