Bounding volume tree的应用

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