开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
CMath.cpp
资源名称：3dexplorerTest.rar　[点击查看]
上传用户：hkb425
上传日期：2007-06-16
资源大小：34191k
文件大小：24k
源码类别：

游戏引擎

开发平台：

Visual C++

CMath.cpp：源码内容
  1. // CMath.cpp: implementation of the CMath class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "CMath.h"
  8. //////////////////////////////////////////////////////////////////////
  9. // Construction/Destruction
  10. //////////////////////////////////////////////////////////////////////
  11. CMath::CMath()
  12. {}
  13. CMath::~CMath()
  14. {}
  15. /////////////////////////////
  16. bool CMath::IsLineSegmentCutByPolygon(VERTEX v1 ,VERTEX v2,VERTEX* pv,int num)
  17. {
  18. if(num<3)return false;
  19. PLANE plane;
  20. plane=GetPlaneEquation(pv,num);
  21. ///////////如果两点在同一侧
  22. if((ClassifyPointPlane(v1,plane)*ClassifyPointPlane(v2,plane))> 0)
  23. return false;
  24. //////////////获得线段与平面的交点
  25. VERTEX intersection;
  26. intersection=GetIntersection(v1,v2,plane);
  27. ///////////包围盒粗略判断
  28. float maxx,minx,  maxy,miny,  maxz,minz;
  29. maxx=minx=pv[0].xpos;
  30. maxy=miny=pv[0].ypos;
  31. maxz=minz=pv[0].zpos;
  32. for(int i=1;i<num;i++)
  33. {
  34. if(pv[i].xpos>maxx)maxx=pv[i].xpos;
  35. if(pv[i].xpos<minx)minx=pv[i].xpos;
  36. if(pv[i].ypos>maxy)maxy=pv[i].ypos;
  37. if(pv[i].ypos<miny)miny=pv[i].ypos;
  38. if(pv[i].zpos>maxz)maxz=pv[i].zpos;
  39. if(pv[i].zpos<minz)minz=pv[i].zpos;
  40. }
  41. if(intersection.xpos>maxx || intersection.xpos<minx)
  42. return false;
  43. if(intersection.ypos>maxy || intersection.ypos<miny)
  44. return false;
  45. if(intersection.zpos>maxz || intersection.zpos<minz)
  46. return false;
  47. //////////////找一个过交点intersection且与某一坐标轴垂直的平面
  48.     PLANE  p(0,0,0,0);
  49.     float absA,absB,absC;
  50. if(plane.A<0)absA=-plane.A;
  51. else absA=plane.A;
  52. if(plane.B<0)absB=-plane.B;
  53. else absB=plane.B;
  54. if(plane.C<0)absC=-plane.C;
  55. else absC=plane.C;
  57. if(absA<=absB && absA<=absC)
  58. {
  59. ///////////平面与X轴接近平行
  60. p.A=1;
  61. p.D=-intersection.xpos;
  63. ///////////////////////////////////////////
  64. if(absB>absC)
  65. {   //////比较 Z 轴坐标
  66.             VERTEX sect[6];/////可能有重复的交点，如顶点
  67.             int  index=0;
  68. for( i=0;i<(num-1);i++)
  69. {
  70. if(ClassifyPointPlane(pv[i],p)!=ClassifyPointPlane(pv[i+1],p))
  71. {
  72.                      sect[index]=GetIntersection(pv[i],pv[i+1],p);
  73.  index++;
  74. }
  75. }
  76. if(ClassifyPointPlane(pv[0],p)!=ClassifyPointPlane(pv[num-1],p))
  77. {
  78.                  sect[index]=GetIntersection(pv[0],pv[num-1],p);
  79.  index++;
  80. }
  81. /////////////////////////////
  82. float maxzz,minzz;
  83. maxzz=minzz=sect[0].zpos;
  84. for(i=0;i<index;i++)
  85. {
  86. if(sect[i].zpos>maxzz)maxzz=sect[i].zpos;
  87. if(sect[i].zpos<minzz)minzz=sect[i].zpos;
  88. }
  89. if(intersection.zpos>maxzz || intersection.zpos<minzz)return false;
  90. else 
  91. return true;
  92. }
  93. else
  94. {   //////比较 Y 轴坐标
  95.             VERTEX sect[6];/////可能有重复的交点，如顶点
  96.             int  index=0;
  97. for( i=0;i<(num-1);i++)
  98. {
  99. if(ClassifyPointPlane(pv[i],p)!=ClassifyPointPlane(pv[i+1],p))
  100. {
  101.                      sect[index]=GetIntersection(pv[i],pv[i+1],p);
  102.  index++;
  103. }
  104. }
  105. if(ClassifyPointPlane(pv[0],p)!=ClassifyPointPlane(pv[num-1],p))
  106. {
  107.                  sect[index]=GetIntersection(pv[0],pv[num-1],p);
  108.  index++;
  109. }
  110. /////////////////////////////
  111. float maxyy,minyy;
  112. maxyy=minyy=sect[0].ypos;
  113. for(i=0;i<index;i++)
  114. {
  115. if(sect[i].ypos>maxyy)maxyy=sect[i].ypos;
  116. if(sect[i].ypos<minyy)minyy=sect[i].ypos;
  117. }
  118. if(intersection.ypos>maxyy || intersection.ypos<minyy)return false;
  119. else 
  120. return true;
  121. }
  123. }
  124. else if(absB<=absA && absB<=absC)
  125. {
  126. ///////////平面与Y轴接近平行
  127. p.B=1;
  128. p.D=-intersection.ypos;
  130. ///////////////////////////////////////////
  131. if(absA>absC)
  132. {   //////比较 Z 轴坐标
  133.             VERTEX sect[6];/////可能有重复的交点，如顶点
  134.             int  index=0;
  135. for( i=0;i<(num-1);i++)
  136. {
  137. if(ClassifyPointPlane(pv[i],p)!=ClassifyPointPlane(pv[i+1],p))
  138. {
  139.                      sect[index]=GetIntersection(pv[i],pv[i+1],p);
  140.  index++;
  141. }
  142. }
  143. if(ClassifyPointPlane(pv[0],p)!=ClassifyPointPlane(pv[num-1],p))
  144. {
  145.                  sect[index]=GetIntersection(pv[0],pv[num-1],p);
  146.  index++;
  147. }
  148. /////////////////////////////
  149. float maxzz,minzz;
  150. maxzz=minzz=sect[0].zpos;
  151. for(i=0;i<index;i++)
  152. {
  153. if(sect[i].zpos>maxzz)maxzz=sect[i].zpos;
  154. if(sect[i].zpos<minzz)minzz=sect[i].zpos;
  155. }
  156. if(intersection.zpos>maxzz || intersection.zpos<minzz)return false;
  157. else 
  158. return true;
  159. }
  160. else
  161. {   //////比较 X 轴坐标
  162.             VERTEX sect[6];/////可能有重复的交点，如顶点
  163.             int  index=0;
  164. for( i=0;i<(num-1);i++)
  165. {
  166. if(ClassifyPointPlane(pv[i],p)!=ClassifyPointPlane(pv[i+1],p))
  167. {
  168.                      sect[index]=GetIntersection(pv[i],pv[i+1],p);
  169.  index++;
  170. }
  171. }
  172. if(ClassifyPointPlane(pv[0],p)!=ClassifyPointPlane(pv[num-1],p))
  173. {
  174.                  sect[index]=GetIntersection(pv[0],pv[num-1],p);
  175.  index++;
  176. }
  177. /////////////////////////////
  178. float maxxx,minxx;
  179. maxxx=minxx=sect[0].xpos;
  180. for(i=0;i<index;i++)
  181. {
  182. if(sect[i].xpos>maxxx)maxxx=sect[i].xpos;
  183. if(sect[i].xpos<minxx)minxx=sect[i].xpos;
  184. }
  185. if(intersection.xpos>maxxx || intersection.xpos<minxx)return false;
  186. else 
  187. return true;
  188. }
  189. }
  190. else  //(absC<absA && absC<absB)
  191. {
  192. ///////////平面与Z轴接近平行
  193. p.C=1;
  194. p.D=-intersection.zpos;
  196. ///////////////////////////////////////////
  197. if(absA>absB)
  198. {   //////比较 Y 轴坐标
  199.             VERTEX sect[6];/////可能有重复的交点，如顶点
  200.             int  index=0;
  201. for( i=0;i<(num-1);i++)
  202. {
  203. if(ClassifyPointPlane(pv[i],p)!=ClassifyPointPlane(pv[i+1],p))
  204. {
  205.                      sect[index]=GetIntersection(pv[i],pv[i+1],p);
  206.  index++;
  207. }
  208. }
  209. if(ClassifyPointPlane(pv[0],p)!=ClassifyPointPlane(pv[num-1],p))
  210. {
  211.                  sect[index]=GetIntersection(pv[0],pv[num-1],p);
  212.  index++;
  213. }
  214. /////////////////////////////
  215. float maxyy,minyy;
  216. maxyy=minyy=sect[0].ypos;
  217. for(i=0;i<index;i++)
  218. {
  219. if(sect[i].ypos>maxyy)maxyy=sect[i].ypos;
  220. if(sect[i].ypos<minyy)minyy=sect[i].ypos;
  221. }
  222. if(intersection.ypos>maxyy || intersection.ypos<minyy)return false;
  223. else 
  224. return true;
  225. }
  226. else
  227. {   //////比较 X 轴坐标
  228.             VERTEX sect[6];/////可能有重复的交点，如顶点
  229.             int  index=0;
  230. for( i=0;i<(num-1);i++)
  231. {
  232. if(ClassifyPointPlane(pv[i],p)!=ClassifyPointPlane(pv[i+1],p))
  233. {
  234.                      sect[index]=GetIntersection(pv[i],pv[i+1],p);
  235.  index++;
  236. }
  237. }
  238. if(ClassifyPointPlane(pv[0],p)!=ClassifyPointPlane(pv[num-1],p))
  239. {
  240.                  sect[index]=GetIntersection(pv[0],pv[num-1],p);
  241.  index++;
  242. }
  243. /////////////////////////////
  244. float maxxx,minxx;
  245. maxxx=minxx=sect[0].xpos;
  246. for(i=0;i<index;i++)
  247. {
  248. if(sect[i].xpos>maxxx)maxxx=sect[i].xpos;
  249. if(sect[i].xpos<minxx)minxx=sect[i].xpos;
  250. }
  251. if(intersection.xpos>maxxx || intersection.xpos<minxx)return false;
  252. else 
  253. return true;
  254. }
  256. }
  258. return true;
  259. }
  260. bool CMath::IsLineSegmentCutBy3DBoundary(VERTEX *v1 ,VERTEX *v2,BOUNDARY_3D *bd)
  261. {
  262. if(v1->xpos>bd->maxx && v2->xpos>bd->maxx)return false;
  263. if(v1->xpos<bd->minx && v2->xpos<bd->minx)return false;
  264. if(v1->ypos>bd->maxy && v2->ypos>bd->maxy)return false;
  265. if(v1->ypos<bd->miny && v2->ypos<bd->miny)return false;
  266. if(v1->zpos>bd->maxz && v2->zpos>bd->maxz)return false;
  267. if(v1->zpos<bd->minz && v2->zpos<bd->minz)return false;
  268. /////////////
  269.     VERTEX v[8];
  271. v[0]=VERTEX(bd->minx,bd->miny,bd->minz);
  272. v[1]=VERTEX(bd->maxx,bd->miny,bd->minz);
  273. v[2]=VERTEX(bd->maxx,bd->maxy,bd->minz);
  274. v[3]=VERTEX(bd->minx,bd->maxy,bd->minz);
  276. v[4]=VERTEX(bd->minx,bd->miny,bd->maxz);
  277. v[5]=VERTEX(bd->maxx,bd->miny,bd->maxz);
  278. v[6]=VERTEX(bd->maxx,bd->maxy,bd->maxz);
  279. v[7]=VERTEX(bd->minx,bd->maxy,bd->maxz);
  280.     ///////////////
  281.     if(IsLineSegmentCutByStardQuad(*v1,*v2, v[0],v[1],v[2],v[3]))return true;
  282.     if(IsLineSegmentCutByStardQuad(*v1,*v2, v[4],v[5],v[6],v[7]))return true;
  283.     if(IsLineSegmentCutByStardQuad(*v1,*v2, v[2],v[3],v[7],v[6]))return true;
  284.     if(IsLineSegmentCutByStardQuad(*v1,*v2, v[1],v[0],v[4],v[5]))return true;
  285.     if(IsLineSegmentCutByStardQuad(*v1,*v2, v[1],v[2],v[6],v[5]))return true;
  286.     if(IsLineSegmentCutByStardQuad(*v1,*v2, v[0],v[3],v[7],v[4]))return true;
  287.     ///////////////
  288.     return false;
  289. }
  290. bool CMath::IsLineSegmentCutBy3DBoundary(VERTEX v1 ,VERTEX v2,BOUNDARY_3D bd)
  291. {
  292. if(v1.xpos>bd.maxx && v2.xpos>bd.maxx)return false;
  293. if(v1.xpos<bd.minx && v2.xpos<bd.minx)return false;
  294. if(v1.ypos>bd.maxy && v2.ypos>bd.maxy)return false;
  295. if(v1.ypos<bd.miny && v2.ypos<bd.miny)return false;
  296. if(v1.zpos>bd.maxz && v2.zpos>bd.maxz)return false;
  297. if(v1.zpos<bd.minz && v2.zpos<bd.minz)return false;
  298. /////////////
  299.     VERTEX v[8];
  301. v[0]=VERTEX(bd.minx,bd.miny,bd.minz);
  302. v[1]=VERTEX(bd.maxx,bd.miny,bd.minz);
  303. v[2]=VERTEX(bd.maxx,bd.maxy,bd.minz);
  304. v[3]=VERTEX(bd.minx,bd.maxy,bd.minz);
  306. v[4]=VERTEX(bd.minx,bd.miny,bd.maxz);
  307. v[5]=VERTEX(bd.maxx,bd.miny,bd.maxz);
  308. v[6]=VERTEX(bd.maxx,bd.maxy,bd.maxz);
  309. v[7]=VERTEX(bd.minx,bd.maxy,bd.maxz);
  310.     ///////////////
  311.     if(IsLineSegmentCutByStardQuad(v1,v2, v[0],v[1],v[2],v[3]))return true;
  312.     if(IsLineSegmentCutByStardQuad(v1,v2, v[4],v[5],v[6],v[7]))return true;
  313.     if(IsLineSegmentCutByStardQuad(v1,v2, v[2],v[3],v[7],v[6]))return true;
  314.     if(IsLineSegmentCutByStardQuad(v1,v2, v[1],v[0],v[4],v[5]))return true;
  315.     if(IsLineSegmentCutByStardQuad(v1,v2, v[1],v[2],v[6],v[5]))return true;
  316.     if(IsLineSegmentCutByStardQuad(v1,v2, v[0],v[3],v[7],v[4]))return true;
  317.     ///////////////
  318.     return false;
  319. }
  321. bool CMath::IsLineSegmentCutByStardQuad(VERTEX v1 ,VERTEX v2,VERTEX va,VERTEX vb,VERTEX vc,VERTEX vd)
  322. {
  323. PLANE plane;
  324. plane=GetPlaneEquation(va,vb,vc);
  325. ///////////如果两点在同一侧
  326. if((ClassifyPointPlane(v1,plane)*ClassifyPointPlane(v2,plane))>=0)
  327. return false;
  328. //////////////获得线段与平面的交点
  329. VERTEX intersection;
  330. intersection=GetIntersection(v1,v2,plane);
  331. ///////////包围盒判断
  332. float maxx,minx,  maxy,miny,  maxz,minz;
  333. maxx=minx=va.xpos;
  334. maxy=miny=va.ypos;
  335. maxz=minz=va.zpos;
  337. if(vb.xpos>maxx)maxx=vb.xpos;
  338. if(vb.xpos<minx)minx=vb.xpos;
  339. if(vb.ypos>maxy)maxy=vb.ypos;
  340. if(vb.ypos<miny)miny=vb.ypos;
  341. if(vb.zpos>maxz)maxz=vb.zpos;
  342. if(vb.zpos<minz)minz=vb.zpos;
  344. if(vc.xpos>maxx)maxx=vc.xpos;
  345. if(vc.xpos<minx)minx=vc.xpos;
  346. if(vc.ypos>maxy)maxy=vc.ypos;
  347. if(vc.ypos<miny)miny=vc.ypos;
  348. if(vc.zpos>maxz)maxz=vc.zpos;
  349. if(vc.zpos<minz)minz=vc.zpos;
  351. if(vd.xpos>maxx)maxx=vd.xpos;
  352. if(vd.xpos<minx)minx=vd.xpos;
  353. if(vd.ypos>maxy)maxy=vd.ypos;
  354. if(vd.ypos<miny)miny=vd.ypos;
  355. if(vd.zpos>maxz)maxz=vd.zpos;
  356. if(vd.zpos<minz)minz=vd.zpos;
  358. if(intersection.xpos>maxx || intersection.xpos<minx)
  359. return false;
  360. if(intersection.ypos>maxy || intersection.ypos<miny)
  361. return false;
  362. if(intersection.zpos>maxz || intersection.zpos<minz)
  363. return false;
  365.     return true;
  366. }
  367. bool CMath::IsLineSegmentCutByStardQuad(VERTEX v1 ,VERTEX v2,VERTEX *pv)
  368. {
  369. return IsLineSegmentCutByStardQuad(v1,v2,pv[0],pv[1],pv[2],pv[3]);
  370. }
  371. bool CMath::IsVertexInsideCube(VERTEX vertex , CUBE cube )
  372. {
  373.     if(vertex.xpos < cube.V0.xpos)return false;
  374.     if(vertex.xpos > cube.V1.xpos)return false;
  375.     if(vertex.ypos < cube.V0.ypos)return false;
  376.     if(vertex.ypos > cube.V4.ypos)return false;
  377.     if(vertex.zpos < cube.V3.zpos)return false;
  378.     if(vertex.zpos > cube.V0.zpos)return false;
  379. return true;
  380. }
  381. bool CMath::IsVertexInsideCube(VERTEX *vertex , BOUNDARY_3D *boundary)
  382. {
  383.     if(vertex->xpos > boundary->maxx || vertex->xpos < boundary->minx)return false;
  384.     if(vertex->ypos > boundary->maxy || vertex->ypos < boundary->miny)return false;
  385.     if(vertex->zpos > boundary->maxz || vertex->zpos < boundary->minz)return false;
  387. return true;
  389. }
  390. bool CMath::IsCubeCutByQuad(CUBE cube , QUAD quad)
  391. {
  392. ////////////// 1.如果Quad上有一个点在cube内，则相交
  393.     if(IsVertexInsideCube(quad.V0,cube))return true;
  394.     if(IsVertexInsideCube(quad.V1,cube))return true;
  395.     if(IsVertexInsideCube(quad.V2,cube))return true;
  396.     if(IsVertexInsideCube(quad.V3,cube))return true;
  397. ////////////// 2. 现在quad的四个点都在cube外，
  398. if(quad.V0.xpos < cube.V0.xpos && 
  399.        quad.V1.xpos < cube.V0.xpos && 
  400.    quad.V2.xpos < cube.V0.xpos && 
  401.    quad.V3.xpos < cube.V0.xpos    )return false;
  402. if(quad.V0.xpos > cube.V1.xpos && 
  403.        quad.V1.xpos > cube.V1.xpos && 
  404.    quad.V2.xpos > cube.V1.xpos && 
  405.    quad.V3.xpos > cube.V1.xpos    )return false;
  406. if(quad.V0.ypos < cube.V0.ypos && 
  407.        quad.V1.ypos < cube.V0.ypos && 
  408.    quad.V2.ypos < cube.V0.ypos && 
  409.    quad.V3.ypos < cube.V0.ypos    )return false;
  410. if(quad.V0.ypos > cube.V4.ypos && 
  411.        quad.V1.ypos > cube.V4.ypos && 
  412.    quad.V2.ypos > cube.V4.ypos && 
  413.    quad.V3.ypos > cube.V4.ypos    )return false;
  414. if(quad.V0.zpos < cube.V2.zpos && 
  415.        quad.V1.zpos < cube.V2.zpos && 
  416.    quad.V2.zpos < cube.V2.zpos && 
  417.    quad.V3.zpos < cube.V2.zpos    )return false;
  418. if(quad.V0.zpos > cube.V1.zpos && 
  419.        quad.V1.zpos > cube.V1.zpos && 
  420.    quad.V2.zpos > cube.V1.zpos && 
  421.    quad.V3.zpos > cube.V1.zpos    )return false;
  422. /////////////// 3.现在判断cube上的8个点是否在Quad的同一侧
  423. int side[8];
  424. side[0] = ClassifyPointPlane(cube.V0,quad.plane);
  425. side[1] = ClassifyPointPlane(cube.V1,quad.plane);
  426. side[2] = ClassifyPointPlane(cube.V2,quad.plane);
  427. side[3] = ClassifyPointPlane(cube.V3,quad.plane);
  428. side[4] = ClassifyPointPlane(cube.V4,quad.plane);
  429. side[5] = ClassifyPointPlane(cube.V5,quad.plane);
  430. side[6] = ClassifyPointPlane(cube.V6,quad.plane);
  431. side[7] = ClassifyPointPlane(cube.V7,quad.plane);
  433. int count = 0;
  434. int index = 0;
  435. for(int i=0;i<8;i++)
  436. {
  437. // if(side[i] !=0 )
  438. {
  439. count+=side[i];
  440. index++;
  441. }
  442. }
  443. if(count==index || count==-index)return false;
  444. ////////////// 4.判断cube的12条边中有没有与Quad相交的
  445. // VERTEX vList[4];
  446. if(IsLineSegmentCutByPolygon(cube.V0,cube.V1,&quad.V0,4))return true;
  447. if(IsLineSegmentCutByPolygon(cube.V0,cube.V4,&quad.V0,4))return true;
  448. if(IsLineSegmentCutByPolygon(cube.V0,cube.V3,&quad.V0,4))return true;
  449.  
  450. if(IsLineSegmentCutByPolygon(cube.V6,cube.V7,&quad.V0,4))return true;
  451. if(IsLineSegmentCutByPolygon(cube.V6,cube.V2,&quad.V0,4))return true;
  452. if(IsLineSegmentCutByPolygon(cube.V6,cube.V5,&quad.V0,4))return true;
  453.  
  454. if(IsLineSegmentCutByPolygon(cube.V7,cube.V3,&quad.V0,4))return true;
  455. if(IsLineSegmentCutByPolygon(cube.V7,cube.V4,&quad.V0,4))return true;
  457. if(IsLineSegmentCutByPolygon(cube.V5,cube.V4,&quad.V0,4))return true;
  458.   if(IsLineSegmentCutByPolygon(cube.V5,cube.V1,&quad.V0,4))return true;
  460. if(IsLineSegmentCutByPolygon(cube.V2,cube.V1,&quad.V0,4))return true;
  461. if(IsLineSegmentCutByPolygon(cube.V2,cube.V3,&quad.V0,4))return true;
  462.  
  463. return false;
  464. }
  465. PLANE CMath::GetPlaneEquation(VERTEX v1,VERTEX v2,PLANE p)
  466. {
  467. PLANE plane;
  468. /////////////  n12不能与plane垂直
  469.     ////???????????????????????????
  470. ///////////////////////////////
  471.     double nnx,nny,nnz ;
  472. nnx=v2.xpos-v1.xpos;
  473. nny=v2.ypos-v1.ypos;
  474. nnz=v2.zpos-v1.zpos;
  475. double pA,pB,pC,pD;
  476.     pA=p.A; pB=p.B; pC=p.C; pD=p.D;
  478.     double a,b,c;
  479. a=(pC*nny-pB*nnz)*(pA*nny-pB*nnx);
  480.     b=(pC*nnx-pA*nnz)*(pB*nnx-pA*nny);
  481. c=(pB*nnx-pA*nny)*(pA*nny-pB*nnx);
  483. NORMAL n=Normalization(a,b,c);
  484. plane.A=n.nx;
  485. plane.B=n.ny;
  486. plane.C=n.nz;    
  487. plane.D=-(plane.A*v1.xpos+plane.B*v1.ypos+plane.C*v1.zpos);
  489. return plane;
  491. }
  492. PLANE CMath::GetPlaneEquation(VERTEX *pVertices,int VerticesNumber)
  493. {
  494. PLANE plane;
  495. if(VerticesNumber<3)
  496. {
  497. plane.A=plane.B=plane.C=plane.D=0;
  498. }
  499. else
  500. {
  501.      NORMAL N12,N13,N;
  502.      ////////////calculate n12 n13
  503.      N12.nx=pVertices[1].xpos-pVertices[0].xpos;
  504.      N12.ny=pVertices[1].ypos-pVertices[0].ypos;
  505.      N12.nz=pVertices[1].zpos-pVertices[0].zpos;
  507.      N13.nx=pVertices[2].xpos-pVertices[0].xpos;
  508.      N13.ny=pVertices[2].ypos-pVertices[0].ypos;
  509.      N13.nz=pVertices[2].zpos-pVertices[0].zpos;
  510.      ////////////////////////////
  511.         N=GetTwoNormalProduct(N12,N13);
  513.      plane.A=N.nx;
  514.      plane.B=N.ny;
  515.      plane.C=N.nz;
  516. plane.D= -(plane.A*pVertices->xpos+plane.B*pVertices->ypos+plane.C*pVertices->zpos);
  517. }
  518. return plane;
  519. }
  521. PLANE CMath::GetPlaneEquation(VERTEX v1,VERTEX v2,VERTEX v3)
  522. {
  523. PLANE plane;
  524.     NORMAL N12,N13,N;
  525.     ////////////calculate n12 n13
  526.     N12.nx=v2.xpos-v1.xpos;
  527.     N12.ny=v2.ypos-v1.ypos;
  528.     N12.nz=v2.zpos-v1.zpos;
  530.     N13.nx=v3.xpos-v1.xpos;
  531.     N13.ny=v3.ypos-v1.ypos;
  532.     N13.nz=v3.zpos-v1.zpos;
  534.     N=GetTwoNormalProduct(N12,N13);
  536.     plane.A=N.nx;
  537.     plane.B=N.ny;
  538.     plane.C=N.nz;
  539. plane.D= -(plane.A*v1.xpos+plane.B*v1.ypos+plane.C*v1.zpos);
  541. return plane;
  542. }
  544. PLANE CMath::GetPlaneEquation(VERTEX v,PLANE p1,PLANE p2)
  545. {
  546. PLANE plane;
  547.     NORMAL n1,n2,normal;
  548.     n1.nx=p1.A;  n1.ny=p1.B;  n1.nz=p1.C;
  549.     n2.nx=p2.A;  n2.ny=p2.B;  n2.nz=p2.C;
  551. normal=GetTwoNormalProduct(n1,n2);
  553. plane.A=normal.nx;
  554. plane.B=normal.ny;
  555. plane.C=normal.nz;
  556. plane.D=-(plane.A*v.xpos+plane.B*v.ypos+plane.C*v.zpos);
  558. return plane;
  559. }
  561. VERTEX CMath::GetIntersection(VERTEX v1,VERTEX v2,PLANE plane)
  562. {
  563. VERTEX point;
  564. double temp1=(plane.A*(v2.xpos-v1.xpos)+plane.B*(v2.ypos-v1.ypos)+plane.C*(v2.zpos-v1.zpos));
  565. double temp2=-plane.D-plane.A*v1.xpos-plane.B*v1.ypos-plane.C*v1.zpos;
  566.     ///// Line param is temp2/temp1
  567. point.xpos=v1.xpos+float((double(v2.xpos-v1.xpos)*temp2)/temp1);
  568. point.ypos=v1.ypos+float((double(v2.ypos-v1.ypos)*temp2)/temp1);
  569. point.zpos=v1.zpos+float((double(v2.zpos-v1.zpos)*temp2)/temp1);
  570.  
  571. return point;
  572. }
  573. VERTEX CMath::GetProjection(VERTEX vertex,PLANE plane)
  574. {
  575.     VERTEX v=VERTEX(vertex.xpos-plane.A,vertex.ypos-plane.B,vertex.zpos-plane.C);
  576. return GetIntersection(v,vertex,plane);
  578. }
  579. TEXCOORD CMath::GetIntersectionTexCoord(VERTEX pointA,TEXCOORD texcoordA,
  580. VERTEX pointB,TEXCOORD texcoordB,  PLANE plane)
  581. {
  582. VERTEX intersect=GetIntersection(pointA,pointB,plane);
  583. float distA=GetDistance(pointA,intersect);
  584. float distAB=GetDistance(pointA,pointB);
  585. if(distAB<0.0001)return texcoordA; ///////safe
  586. TEXCOORD texcoord;
  587. texcoord.u=(texcoordA.u*distAB + distA*(texcoordB.u-texcoordA.u))/distAB;
  588. texcoord.v=(texcoordA.v*distAB + distA*(texcoordB.v-texcoordA.v))/distAB;
  590. return texcoord;
  591. }
  593. VERTEX CMath::GetPositionOnGrid(VERTEX *pQuads,float u,float v)
  594. {
  595. /////////u，v 的范围为0－1
  596. if(u<0)u=0; if(u>1)u=1;
  597. if(v<0)v=0; if(v>1)v=1;
  598. //////////////////////////////////////
  599. VERTEX v1,v2; //与u相关的两条边上的点
  600. v1=VERTEX(pQuads[0].xpos+(pQuads[1].xpos-pQuads[0].xpos)*u,
  601.               pQuads[0].ypos+(pQuads[1].ypos-pQuads[0].ypos)*u,
  602.               pQuads[0].zpos+(pQuads[1].zpos-pQuads[0].zpos)*u);
  604. v2=VERTEX(pQuads[3].xpos+(pQuads[2].xpos-pQuads[3].xpos)*u,
  605.               pQuads[3].ypos+(pQuads[2].ypos-pQuads[3].ypos)*u,
  606.               pQuads[3].zpos+(pQuads[2].zpos-pQuads[3].zpos)*u);
  607. ///////////////////////////////////////
  608. VERTEX vertex;    ///所求的点
  609.     vertex.xpos=v1.xpos+(v2.xpos-v1.xpos)*v;
  610.     vertex.ypos=v1.ypos+(v2.ypos-v1.ypos)*v;
  611.     vertex.zpos=v1.zpos+(v2.zpos-v1.zpos)*v;
  613. return vertex;
  614. }
  616. NORMAL CMath::GetTwoNormalProduct(NORMAL n1,NORMAL n2)
  617. {
  618. double n1x,n1y,n1z,n2x,n2y,n2z;
  619. n1x=n1.nx;  n1y=n1.ny;  n1z=n1.nz;
  620. n2x=n2.nx;  n2y=n2.ny;  n2z=n2.nz;
  622.     double nx,ny,nz;
  624.     nx=  n1y*n2z-n2y*n1z;
  625.     ny=-(n1x*n2z-n2x*n1z);
  626.     nz=  n1x*n2y-n2x*n1y;
  627. // return NORMAL(float(nx),float(ny),float(nz));
  628. return Normalization(nx,ny,nz);
  629. }
  630. NORMAL CMath::GetNormal(VERTEX v1,VERTEX v2,VERTEX v3)
  631. {
  632. NORMAL n1,n2;
  633. n1.nx=v2.xpos-v1.xpos;
  634. n1.ny=v2.ypos-v1.ypos;
  635. n1.nz=v2.zpos-v1.zpos;
  637. n2.nx=v3.xpos-v1.xpos;
  638. n2.ny=v3.ypos-v1.ypos;
  639. n2.nz=v3.zpos-v1.zpos;
  641. return GetTwoNormalProduct(n1,n2);
  643. }
  644. NORMAL  CMath::GetNormal(float *v1,float *v2,float *v3)
  645. {
  646. NORMAL n1,n2;
  647. n1.nx=v2[0]-v1[0];
  648. n1.ny=v2[1]-v1[1];
  649. n1.nz=v2[2]-v1[2];
  651. n2.nx=v3[0]-v1[0];
  652. n2.ny=v3[1]-v1[1];
  653. n2.nz=v3[2]-v1[2];
  655. return GetTwoNormalProduct(n1,n2);
  657. }
  658. float CMath::GetTwoVectorAngleCosine(NORMAL na,NORMAL nb)
  659. {
  660.     NORMAL n1,n2;
  661. n1=Normalization(na);
  662. n2=Normalization(nb);
  663. double temp,length1,length2;
  664. temp=n1.nx*n2.nx+n1.ny*n2.ny+n1.nz*n2.nz;
  665. length1=pow( n1.nx*n1.nx +n1.ny*n1.ny +n1.nz*n1.nz,0.5);
  666. length2=pow( n2.nx*n2.nx +n2.ny*n2.ny +n2.nz*n2.nz,0.5);
  668. return float(temp/(length1*length2));
  669. }
  672. float CMath::GetDistance(VERTEX v1,VERTEX v2)
  673. {
  674. float dist;
  675. dist=(float)pow((v2.xpos-v1.xpos)*(v2.xpos-v1.xpos)+
  676.             (v2.ypos-v1.ypos)*(v2.ypos-v1.ypos)+
  677. (v2.zpos-v1.zpos)*(v2.zpos-v1.zpos),0.5);
  678. return dist;
  680. }
  681. float CMath::GetPointToLineDist2D(VERTEX lineV1,VERTEX lineV2,VERTEX point)
  682. {
  683. PLANE plane=GetPlaneEquation(lineV1,lineV2,VERTEX(lineV1.xpos,lineV1.ypos-200,lineV1.zpos));
  684.     float dist=GetDistance(point,plane);
  685. if(dist<0)dist=-dist;
  686. return dist;
  687. }
  688. float CMath::GetDistance(VERTEX point,PLANE plane)
  689. {
  690. float abc=(float)sqrt(plane.A*plane.A+plane.B*plane.B+plane.C*plane.C);
  691. float dist=(plane.A*point.xpos+plane.B*point.ypos+plane.C*point.zpos+plane.D)/abc;
  692. //    if(dist<0)dist=-dist;
  693.     return dist;
  694. }
  695. float CMath::GetDistance(VERTEX point,PLANE plane,float powABC)
  696. {
  697.     return (plane.A*point.xpos+plane.B*point.ypos+plane.C*point.zpos+plane.D)/powABC;
  698. }
  699. float CMath::GetTwoVectorAngleCosine(VERTEX  v1,VERTEX vCenter,VERTEX v2)
  700. {
  701. double temp,length1,length2;
  702. double n1nx,n1ny,n1nz,n2nx,n2ny,n2nz;
  704. n1nx=v1.xpos-vCenter.xpos;
  705. n1ny=v1.ypos-vCenter.ypos;
  706. n1nz=v1.zpos-vCenter.zpos;
  708. n2nx=v2.xpos-vCenter.xpos;
  709. n2ny=v2.ypos-vCenter.ypos;
  710. n2nz=v2.zpos-vCenter.zpos;
  712. temp=n1nx*n2nx+n1ny*n2ny+n1nz*n2nz;
  713. length1=pow( n1nx*n1nx +n1ny*n1ny +n1nz*n1nz,0.5);
  714. length2=pow( n2nx*n2nx +n2ny*n2ny +n2nz*n2nz,0.5);
  716. return float(temp/(length1*length2));
  717. }
  719. int CMath::ClassifyTwoNormal(NORMAL n1,NORMAL n2)
  720. {
  721. float temp;
  722. temp=n1.nx*n2.nx+n1.ny*n2.ny+n1.nz*n2.nz;
  723. if(temp==0)return PERPENDICULAR;
  724. if(temp>0)return SHARP_ANGLE;
  725.     if(temp<0)return OBTUSE_ANGLE; 
  726. return UNKNOW;
  727. }
  729. int CMath::ClassifyTwoNormal(VERTEX  v1,VERTEX vCenter,VERTEX v2)
  730. {
  731. float temp;
  732. NORMAL n1,n2;
  734. n1.nx=v1.xpos-vCenter.xpos;
  735. n1.ny=v1.ypos-vCenter.ypos;
  736. n1.nz=v1.zpos-vCenter.zpos;
  738. n2.nx=v2.xpos-vCenter.xpos;
  739. n2.ny=v2.ypos-vCenter.ypos;
  740. n2.nz=v2.zpos-vCenter.zpos;
  742. temp=n1.nx*n2.nx+n1.ny*n2.ny+n1.nz*n2.nz;
  744. if(temp==0)return PERPENDICULAR;
  745. if(temp>0)return SHARP_ANGLE;
  746.     if(temp<0)return OBTUSE_ANGLE; 
  747. return UNKNOW;
  748. }
  750. int CMath::ClassifyPointPlane(VERTEX point,PLANE plane)
  751. {
  752. float distance=plane.A*point.xpos+plane.B*point.ypos+plane.C*point.zpos+plane.D;
  753.     if(distance==0)return COINCIDENT;
  754. if(distance>0)return  IN_FRONT_OF;
  755. return  IN_BACK_OF;
  756. }
  758. int CMath::ClassifyPolygonPlane(PLANE plane,VERTEX *vertices,int num)
  759. {
  760. if(num<3)return UNKNOW;
  761. int current=0;
  762.     int dist=ClassifyPointPlane(vertices[0],plane);
  763. if(dist==IN_FRONT_OF)
  764. {
  765.         current=1;
  766. while(current<num && dist!=IN_BACK_OF)
  767. {
  768.              dist=ClassifyPointPlane(vertices[current],plane);
  769.  current++;
  770. }
  772. if(current<num)return SPANNING;
  773. else if(dist==IN_BACK_OF) return SPANNING;
  774. else return IN_FRONT_OF;
  775. }
  776. else if(dist==IN_BACK_OF)
  777. {
  778.         current=1;
  779. while(current<num && dist!=IN_FRONT_OF)
  780. {
  781.              dist=ClassifyPointPlane(vertices[current],plane);
  782.  current++;
  783. }
  785. if(current<num)return SPANNING;
  786. else if(dist==IN_FRONT_OF) return SPANNING;
  787. else return IN_BACK_OF;
  788. }
  789. else   //First point in the plane
  790. {
  791. int front,back;
  792. front=back=0;
  793. int temp;
  794. for(int i=1;i<num;i++)
  795. {
  796. temp=ClassifyPointPlane(vertices[i],plane);
  797. if(temp==IN_FRONT_OF)front++;
  798. if(temp==IN_BACK_OF)back--;
  799. }
  800. if(front==0 && back==0)return COINCIDENT;
  801. if((front+back)==back)return IN_BACK_OF;
  802. if((front+back)==front)return IN_FRONT_OF;
  804. return SPANNING;
  805. }
  806. }
  808. NORMAL CMath::Normalization(NORMAL n)
  809. {
  810. NORMAL normal;
  811. double x,y,z;
  812. x=n.nx; y=n.ny; z=n.nz;
  814. double max=sqrt(x*x+y*y+z*z);
  815.     if(max<0.0001)return NORMAL(0,1,0);
  817. x=x/max;
  818. y=y/max;
  819. z=z/max;
  821. normal.nx=float(x);
  822. normal.ny=float(y);
  823. normal.nz=float(z);
  825. return normal;
  827. }
  829. NORMAL CMath::Normalization(double x,double y,double z)
  830. {
  831. NORMAL normal=NORMAL(float(x),float(y),float(z));
  832.     return Normalization(normal);
  833. /*
  834. double absX,absY,absZ;
  835. if(x<0)absX=-x;
  836. else absX=x;
  837. if(y<0)absY=-y;
  838. else absY=y;
  839. if(z<0)absZ=-z;
  840. else absZ=z;
  842. double max=absX>absY?absX:absY;
  843. max=max>absZ?max:absZ ;
  844.   
  845. x=x/max;
  846. y=y/max;
  847. z=z/max;
  849. normal.nx=float(x);
  850. normal.ny=float(y);
  851. normal.nz=float(z);
  853. return normal;*/
  854. }