recast&detour源码中有关的数据结构,特此记录,以便以后查看。
原理,先看算法介绍:
http://www.cnblogs.com/lookof/p/3546320.html
实现,对着源码解释:
树的节点结构:rcChunkyTriMeshNode
struct rcChunkyTriMeshNode
{
float bmin[2];// 包围盒大小,不能说是盒子,应该说是矩形(xz平面的)
float bmax[2];
int i; // 正数的为叶子节点,三角形索引id。负值为非叶子节点,表明下一个节点为 +=(-i)
int n; // 表明有几个物体。这里一个节点,存的是一块chunk,即多个物体。
};
对所有的三角形进行分类,根据包围盒大小,每个节点可以存最多 trisPerChunk 个三角形。
使用数组结构 rcChunkyTriMeshNode* nodes,存储bvtree。
bool rcCreateChunkyTriMesh(const float* verts, const int* tris, int ntris,
int trisPerChunk, rcChunkyTriMesh* cm)
{
// 初始化 rcChunkyTriMesh
// 成员nodes: bvtree 数组。
// 成员tris: 排序过的三角形数组。node中的i 即为tris中的索引。
int nchunks = (ntris + trisPerChunk-1) / trisPerChunk;
cm->nodes = new rcChunkyTriMeshNode[nchunks*4];
if (!cm->nodes)
return false;
cm->tris = new int[ntris*3];
if (!cm->tris)
return false;
cm->ntris = ntris;
// 准备工作:对每一个三角形创建AABB包围盒,每一个三角形对应一个BoundsItem,方便后续进行排序划分。
BoundsItem* items = new BoundsItem[ntris];
if (!items)
return false;
for (int i = 0; i < ntris; i++)
{
const int* t = &tris[i*3];
BoundsItem& it = items[i];
it.i = i;
// Calc triangle XZ bounds.
it.bmin[0] = it.bmax[0] = verts[t[0]*3+0];
it.bmin[1] = it.bmax[1] = verts[t[0]*3+2];
for (int j = 1; j < 3; ++j)
{
const float* v = &verts[t[j]*3];
if (v[0] < it.bmin[0]) it.bmin[0] = v[0];
if (v[2] < it.bmin[1]) it.bmin[1] = v[2];
if (v[0] > it.bmax[0]) it.bmax[0] = v[0];
if (v[2] > it.bmax[1]) it.bmax[1] = v[2];
}
}
// 正式构建:划分原则,划分策略,创建节点,构建左右子树。 重点看对 cm->nodes cm->tris 的操作。
int curTri = 0;
int curNode = 0;
subdivide(items, ntris, 0, ntris, trisPerChunk, curNode, cm->nodes, nchunks*4, curTri, cm->tris, tris);
delete [] items;
cm->nnodes = curNode;
......
return true;
}
创建BVTree主函数
static void subdivide(BoundsItem* items, int nitems, int imin, int imax, int trisPerChunk,
int& curNode, rcChunkyTriMeshNode* nodes, const int maxNodes,
int& curTri, int* outTris, const int* inTris)
{
int inum = imax - imin;
int icur = curNode;
if (curNode > maxNodes)
return;
rcChunkyTriMeshNode& node = nodes[curNode++];
// createbvtree 中 是 inum == 1。这里是 chunk ,一个node存一堆
if (inum <= trisPerChunk)
{
// Leaf节点。 赋值 node.bmin, node.bmax
calcExtends(items, nitems, imin, imax, node.bmin, node.bmax);
// Copy triangles.
node.i = curTri;
node.n = inum;
for (int i = imin; i < imax; ++i)
{
const int* src = &inTris[items[i].i*3];
int* dst = &outTris[curTri*3];
curTri++;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
}
}
else
{
// 1.calcExtends 函数计算出 imin 到 imax 的物体的总的包围盒大小,赋值给 node.bmin, node.bmax
calcExtends(items, nitems, imin, imax, node.bmin, node.bmax);
// 2.划分原则,根据node.bmin, node.bmax计算出x轴和y轴的散度,哪个散度大就沿着哪个轴进行划分。
int axis = longestAxis(node.bmax[0] - node.bmin[0],
node.bmax[1] - node.bmin[1]);
if (axis == 0)
{
// Sort along x-axis 对需要划分的items根据x轴坐标进行排序
qsort(items+imin, static_cast<size_t>(inum), sizeof(BoundsItem), compareItemX);
}
else if (axis == 1)
{
// Sort along y-axis
qsort(items+imin, static_cast<size_t>(inum), sizeof(BoundsItem), compareItemY);
}
// 3.划分策略,按数量进行划分,参考中的第二种策略split equal count
int isplit = imin+inum/2;
// 4.递归构建左右子树
// Left
subdivide(items, nitems, imin, isplit, trisPerChunk, curNode, nodes, maxNodes, curTri, outTris, inTris);
// Right
subdivide(items, nitems, isplit, imax, trisPerChunk, curNode, nodes, maxNodes, curTri, outTris, inTris);
// 5.赋值node的i。存为负值,表明这个是非叶子节点,同时表明,如果要找的点不在node.bmin, node.bmax内,可以跳过此节点后的iescape个节点。
int iescape = curNode - icur;
// Negative index means escape.
node.i = -iescape;
}
}
遍历函数Traverse tree
int rcGetChunksOverlappingSegment(const rcChunkyTriMesh* cm,
float p[2], float q[2],
int* ids, const int maxIds)
{
// Traverse tree
int i = 0;
int n = 0;
while (i < cm->nnodes)
{
const rcChunkyTriMeshNode* node = &cm->nodes[i];
const bool overlap = checkOverlapSegment(p, q, node->bmin, node->bmax);
const bool isLeafNode = node->i >= 0;
if (isLeafNode && overlap)
{
if (n < maxIds)
{
ids[n] = i;
n++;
}
}
if (overlap || isLeafNode)
i++;
else
{
const int escapeIndex = -node->i;
i += escapeIndex;
}
}
return n;
}
参考:
https://en.wikipedia.org/wiki/Bounding_volume_hierarchy
http://gad.qq.com/program/translateview/7190243