Bsp 空间分割模拟实现

Bsp：二叉分割树，在游戏中用来分割局部空间，方便碰撞检测等的实现。

1. 下面介绍一种简单易用的分割方法：分割步骤：一、将空间中的所有的面，加入的根部节点。二、遍历根部节点的所有面，分别找到x、y、z的最大最小值，给根节点指定一个合适的包围空间。三、在这个节点的包围空间里找到最长轴、并按这个最长轴的中间点做为新的分割点，遍历该节点的所有面将其分在其左右子节点中。四、返回第2步，直到达到一定限制条件，结束，此时空间已经被分开了。当然闲话不说，贴上实现模拟代码：

#include"stdafx.h"

2. #include<map>
3. #include<vector>
4. #include<iostream>
6. usingnamespacestd;
7. structpoint
8. {
9. floatx,y,z;
10. point():x(0.0f),y(0.0f),z(0.0f){};
11. point(floata,floatb,floatc):x(a),y(b),z(c){}
12. voidoperator+=(intn)
13. {
14. x+=n;
15. y+=n;
16. z+=n;
17. }
18. voidoperator=(point&p)
19. {
20. memcpy(this,(void*)&p,sizeof(*this));
21. }
22. };
23. structface
24. {
25. pointP[3];
26. voidoperator+=(intn)
27. {
28. P[0]+=n;
29. P[1]+=n;
30. P[2]+=n;
31. }
32. };
33. structBBox
34. {
35. pointMin;
36. pointMax;
37. BBox():Min(),Max(){}
38. };
39. enumEAxis
40. {
41. Axis_X,
42. Axis_Y,
43. Axis_Z,
44. };
45. structTreeNode
46. {
47. TreeNode():box(),nDepth(0),pLChild(NULL),pRChild(NULL),Axis(Axis_X),Split(0.0f){vFaceId.reserve(16);}
48. intnDepth;
49. TreeNode*pLChild;
50. TreeNode*pRChild;
51. std::vector<int>vFaceId;
52. intAxis;
53. BBoxbox;
54. floatSplit;
55. };
56. std::map<int,face>m_mFace;
57. face*GetFaceByID(intnID)
58. {
59. std::map<int,face>::iteratoritr=m_mFace.find(nID);
60. if(itr!=m_mFace.end())
61. {
62. return&(m_mFace[nID]);
63. }
64. returnNULL;
65. }
66. classBspTree
67. {
68. public:
69. BspTree():m_pRoot(NULL){};
70. ~BspTree()
71. {
72. if(m_pRoot)
73. {
74. DeleteNode(m_pRoot);
75. }
76. }
77. //初始化树根
78. voidInitTreeRoot(TreeNode*pNode);
79. //释放整个树的资源
80. voidDeleteNode(TreeNode*pNode);
81. //生成AABB包围盒
82. voidBuildAABB(TreeNode*pNode);
83. //切分整个空间
84. voidSplitSpace(TreeNode*pRoot,intnAxis,intndepth);
85. //切分面
86. voidSplitFace(intnFaceId,floatfSplit,intnAxis,int*pLeftNum,int*pRightNum,int*pBothNum);
87. //遍历整个树
88. voidErgodicTree(TreeNode*pNode);
89. protected:
90. private:
91. TreeNode*m_pRoot;
92. };
93. voidBspTree::InitTreeRoot(TreeNode*pNode)
94. {
95. if(pNode==NULL)
96. return;
97. m_pRoot=pNode;
98. }
99. voidBspTree::DeleteNode(TreeNode*pNode)
100. {
101. if(pNode==NULL)
102. return;
103. DeleteNode(pNode->pLChild);
104. DeleteNode(pNode->pRChild);
105. deletepNode;
106. }
107. //遍历整个树
108. voidBspTree::ErgodicTree(TreeNode*pNode)
109. {
110. if(pNode==NULL)
111. return;
113. ErgodicTree(pNode->pLChild);
114. cout<<"节点深度:"<<pNode->nDepth<<"含有多少个面:"<<pNode->vFaceId.size();
115. switch(pNode->Axis)
116. {
117. caseAxis_X:
118. {
119. cout<<"沿X轴分割"<<"分割点是:x="<<pNode->Split<<endl;
120. break;
121. }
122. caseAxis_Y:
123. {
124. cout<<"沿Y轴分割"<<"分割点是:y="<<pNode->Split<<endl;
125. break;
126. }
127. caseAxis_Z:
128. {
129. cout<<"沿Z轴分割"<<"分割点是:z="<<pNode->Split<<endl;
130. break;
131. }
132. }
133. ErgodicTree(pNode->pRChild);
135. }
136. voidBspTree::BuildAABB(TreeNode*pNode)
137. {
138. if(!pNode)
139. return;
140. pointMin(1000000,1000000,1000000);
141. pointMax(-1000000,-1000000,-1000000);
142. for(intn=0;n<pNode->vFaceId.size();++n)
143. {
144. face*pFa=GetFaceByID(n);
145. if(pFa==NULL)
146. continue;
147. for(intm=0;m<3;++m)
148. {
149. if(pFa->P[m].x>Max.x)
150. Max.x=pFa->P[m].x;
151. if(pFa->P[m].y>Max.y)
152. Max.y=pFa->P[m].y;
153. if(pFa->P[m].z>Max.z)
154. Max.z=pFa->P[m].z;
156. if(pFa->P[m].x<Min.x)
157. Min.x=pFa->P[m].x;
158. if(pFa->P[m].y<Min.y)
159. Min.y=pFa->P[m].y;
160. if(pFa->P[m].z<Min.z)
161. Min.z=pFa->P[m].z;
162. }
163. }
164. pNode->box.Max=Max;
165. pNode->box.Min=Min;
166. }
168. intCompareFloat(floata,floatb,floatfOff)
169. {
170. if(abs(a-b)<fOff)
171. return0;
172. if(a>b)
173. return1;
174. else
175. return-1;
177. }
178. voidBspTree::SplitFace(intnFaceId,floatfSplit,intnAxis,int*pLeftNum,int*pRightNum,int*pBothNum)
179. {
180. face*pFace=GetFaceByID(nFaceId);
182. intnLeftCount=0;
183. intnRightCount=0;
184. intnBothCount=0;
185. floatt[3];
186. switch(nAxis)
187. {
188. caseAxis_X:
189. t[0]=pFace->P[0].x;
190. t[1]=pFace->P[1].x;
191. t[2]=pFace->P[2].x;
192. break;
193. caseAxis_Y:
194. t[0]=pFace->P[0].y;
195. t[1]=pFace->P[1].y;
196. t[2]=pFace->P[2].y;
197. break;
198. caseAxis_Z:
199. t[0]=pFace->P[0].z;
200. t[1]=pFace->P[1].z;
201. t[2]=pFace->P[2].z;
202. break;
203. }
204. for(inti=0;i<3;i++)
205. {
206. intc=CompareFloat(t[i],fSplit,0.001f);
208. if(c<0)//左边
209. nLeftCount++;
210. elseif(c>0)//右边
211. nRightCount++;
212. else//正中间
213. nBothCount++;
214. }
215. *pLeftNum=nLeftCount;
216. *pRightNum=nRightCount;
217. *pBothNum=nBothCount;
219. }
221. voidBspTree::SplitSpace(TreeNode*pRoot,intnAxis,intndepth)
222. {
223. if(!pRoot)
224. return;
225. pRoot->nDepth=ndepth;
226. pRoot->Axis=nAxis;
227. if(pRoot->vFaceId.size()<3||ndepth>2)
228. {
229. pRoot->pLChild=NULL;
230. pRoot->pRChild=NULL;
231. return;
232. }
233. pRoot->pLChild=newTreeNode;
234. pRoot->pRChild=newTreeNode;
236. pRoot->pLChild->box.Max=pRoot->box.Max;
237. pRoot->pLChild->box.Min=pRoot->box.Min;
239. pRoot->pRChild->box.Max=pRoot->box.Max;
240. pRoot->pRChild->box.Min=pRoot->box.Min;
243. nAxis=(int)Axis_X;
244. floatXLength=pRoot->box.Max.x-pRoot->box.Min.x;
245. floatYLength=pRoot->box.Max.y-pRoot->box.Min.y;
246. floatZLength=pRoot->box.Max.z-pRoot->box.Min.z;
247. if(YLength>XLength)
248. {
249. nAxis=Axis_Y;
250. XLength=YLength;
251. }
252. if(ZLength>XLength)
253. {
254. nAxis=Axis_Z;
255. }
256. floatfslit=0.0f;
257. switch(nAxis)
258. {
259. caseAxis_X:
260. {
261. fslit=(pRoot->box.Max.x+pRoot->box.Min.x)/2.0;
262. pRoot->pLChild->box.Max.x=fslit;
263. pRoot->pRChild->box.Min.x=fslit;
265. }break;
266. caseAxis_Y:
267. {
268. fslit=(pRoot->box.Max.y+pRoot->box.Min.y)/2.0;
269. pRoot->pLChild->box.Max.y=fslit;
270. pRoot->pRChild->box.Min.y=fslit;
271. }break;
272. caseAxis_Z:
273. {
274. fslit=(pRoot->box.Max.z+pRoot->box.Min.z)/2.0;
275. pRoot->pLChild->box.Max.z=fslit;
276. pRoot->pRChild->box.Min.z=fslit;
277. }break;
278. }
279. pRoot->Split=fslit;
281. intnSize=pRoot->vFaceId.size();
283. intnLeftCount,nRightCount,nBothCount;
284. for(intn=0;n<nSize;++n)
285. {
286. SplitFace(pRoot->vFaceId.at(n),fslit,nAxis,&nLeftCount,&nRightCount,&nBothCount);
288. //如果左边有
289. if(nLeftCount>0||nBothCount>0)
290. pRoot->pLChild->vFaceId.push_back(pRoot->vFaceId.at(n));
291. if(nRightCount>0||nBothCount>0)
292. pRoot->pRChild->vFaceId.push_back(pRoot->vFaceId.at(n));
293. }
295. pRoot->vFaceId.clear();
297. //递归
298. SplitSpace(pRoot->pLChild,nAxis,ndepth+1);
299. SplitSpace(pRoot->pRChild,nAxis,ndepth+1);
300. }
301. int_tmain(intargc,_TCHAR*argv[])
302. {
303. BspTreebspTree;
304. TreeNode*pRoot=newTreeNode;
305. facefa;
306. fa.P[0].x=-10;fa.P[0].y=-10;fa.P[0].z=-10;
307. fa.P[1].x=2;fa.P[1].y=2;fa.P[1].z=2;
308. fa.P[2].x=5;fa.P[2].y=5;fa.P[2].z=5;
309. for(intn=0;n<16;++n)
310. {
311. if(n%5==0)
312. fa+=2*(-n);
313. else
314. fa+=2*n;
315. m_mFace[n]=fa;
316. pRoot->vFaceId.push_back(n);
317. }
318. bspTree.InitTreeRoot(pRoot);
319. bspTree.BuildAABB(pRoot);
320. bspTree.SplitSpace(pRoot,0,0);
321. bspTree.ErgodicTree(pRoot);
323. getchar();
324. return0;
325. }