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

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

游戏引擎

开发平台：

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. /////////////////////////////
  17. bool CMath::IsLineSegmentCutByPolygon(VERTEX v1 ,VERTEX v2,VERTEX* pv,int num)
  18. {
  19. if(num<3)return false;
  20. PLANE plane;
  21. plane=GetPlaneEquation(pv,num);
  22. ///////////如果两点在同一侧
  23. if((ClassifyPointPlane(v1,plane)*ClassifyPointPlane(v2,plane))>=0)
  24. return false;
  25. //////////////获得线段与平面的交点
  26. VERTEX intersection;
  27. intersection=GetIntersection(v1,v2,plane);
  28. ///////////包围盒粗略判断
  29. float maxx,minx,  maxy,miny,  maxz,minz;
  30. maxx=minx=pv[0].xpos;
  31. maxy=miny=pv[0].ypos;
  32. maxz=minz=pv[0].zpos;
  33. for(int i=1;i<num;i++)
  34. {
  35. if(pv[i].xpos>maxx)maxx=pv[i].xpos;
  36. if(pv[i].xpos<minx)minx=pv[i].xpos;
  37. if(pv[i].ypos>maxy)maxy=pv[i].ypos;
  38. if(pv[i].ypos<miny)miny=pv[i].ypos;
  39. if(pv[i].zpos>maxz)maxz=pv[i].zpos;
  40. if(pv[i].zpos<minz)minz=pv[i].zpos;
  41. }
  42. if(intersection.xpos>maxx || intersection.xpos<minx)
  43. return false;
  44. if(intersection.ypos>maxy || intersection.ypos<miny)
  45. return false;
  46. if(intersection.zpos>maxz || intersection.zpos<minz)
  47. return false;
  48. //////////////找一个过交点intersection且与某一坐标轴垂直的平面
  49.     PLANE  p(0,0,0,0);
  50.     float absA,absB,absC;
  51. if(plane.A<0)absA=-plane.A;
  52. else absA=plane.A;
  53. if(plane.B<0)absB=-plane.B;
  54. else absB=plane.B;
  55. if(plane.C<0)absC=-plane.C;
  56. else absC=plane.C;
  58. if(absA<=absB && absA<=absC)
  59. {
  60. ///////////平面与X轴接近平行
  61. p.A=1;
  62. p.D=-intersection.xpos;
  64. ///////////////////////////////////////////
  65. if(absB>absC)
  66. {   //////比较 Z 轴坐标
  67.             VERTEX sect[6];/////可能有重复的交点，如顶点
  68.             int  index=0;
  69. for( i=0;i<(num-1);i++)
  70. {
  71. if(ClassifyPointPlane(pv[i],p)!=ClassifyPointPlane(pv[i+1],p))
  72. {
  73.                      sect[index]=GetIntersection(pv[i],pv[i+1],p);
  74.  index++;
  75. }
  76. }
  77. if(ClassifyPointPlane(pv[0],p)!=ClassifyPointPlane(pv[num-1],p))
  78. {
  79.                  sect[index]=GetIntersection(pv[0],pv[num-1],p);
  80.  index++;
  81. }
  82. /////////////////////////////
  83. float maxzz,minzz;
  84. maxzz=minzz=sect[0].zpos;
  85. for(i=0;i<index;i++)
  86. {
  87. if(sect[i].zpos>maxzz)maxzz=sect[i].zpos;
  88. if(sect[i].zpos<minzz)minzz=sect[i].zpos;
  89. }
  90. if(intersection.zpos>maxzz || intersection.zpos<minzz)return false;
  91. else 
  92. return true;
  93. }
  94. else
  95. {   //////比较 Y 轴坐标
  96.             VERTEX sect[6];/////可能有重复的交点，如顶点
  97.             int  index=0;
  98. for( i=0;i<(num-1);i++)
  99. {
  100. if(ClassifyPointPlane(pv[i],p)!=ClassifyPointPlane(pv[i+1],p))
  101. {
  102.                      sect[index]=GetIntersection(pv[i],pv[i+1],p);
  103.  index++;
  104. }
  105. }
  106. if(ClassifyPointPlane(pv[0],p)!=ClassifyPointPlane(pv[num-1],p))
  107. {
  108.                  sect[index]=GetIntersection(pv[0],pv[num-1],p);
  109.  index++;
  110. }
  111. /////////////////////////////
  112. float maxyy,minyy;
  113. maxyy=minyy=sect[0].ypos;
  114. for(i=0;i<index;i++)
  115. {
  116. if(sect[i].ypos>maxyy)maxyy=sect[i].ypos;
  117. if(sect[i].ypos<minyy)minyy=sect[i].ypos;
  118. }
  119. if(intersection.ypos>maxyy || intersection.ypos<minyy)return false;
  120. else 
  121. return true;
  122. }
  124. }
  125. else if(absB<=absA && absB<=absC)
  126. {
  127. ///////////平面与Y轴接近平行
  128. p.B=1;
  129. p.D=-intersection.ypos;
  131. ///////////////////////////////////////////
  132. if(absA>absC)
  133. {   //////比较 Z 轴坐标
  134.             VERTEX sect[6];/////可能有重复的交点，如顶点
  135.             int  index=0;
  136. for( i=0;i<(num-1);i++)
  137. {
  138. if(ClassifyPointPlane(pv[i],p)!=ClassifyPointPlane(pv[i+1],p))
  139. {
  140.                      sect[index]=GetIntersection(pv[i],pv[i+1],p);
  141.  index++;
  142. }
  143. }
  144. if(ClassifyPointPlane(pv[0],p)!=ClassifyPointPlane(pv[num-1],p))
  145. {
  146.                  sect[index]=GetIntersection(pv[0],pv[num-1],p);
  147.  index++;
  148. }
  149. /////////////////////////////
  150. float maxzz,minzz;
  151. maxzz=minzz=sect[0].zpos;
  152. for(i=0;i<index;i++)
  153. {
  154. if(sect[i].zpos>maxzz)maxzz=sect[i].zpos;
  155. if(sect[i].zpos<minzz)minzz=sect[i].zpos;
  156. }
  157. if(intersection.zpos>maxzz || intersection.zpos<minzz)return false;
  158. else 
  159. return true;
  160. }
  161. else
  162. {   //////比较 X 轴坐标
  163.             VERTEX sect[6];/////可能有重复的交点，如顶点
  164.             int  index=0;
  165. for( i=0;i<(num-1);i++)
  166. {
  167. if(ClassifyPointPlane(pv[i],p)!=ClassifyPointPlane(pv[i+1],p))
  168. {
  169.                      sect[index]=GetIntersection(pv[i],pv[i+1],p);
  170.  index++;
  171. }
  172. }
  173. if(ClassifyPointPlane(pv[0],p)!=ClassifyPointPlane(pv[num-1],p))
  174. {
  175.                  sect[index]=GetIntersection(pv[0],pv[num-1],p);
  176.  index++;
  177. }
  178. /////////////////////////////
  179. float maxxx,minxx;
  180. maxxx=minxx=sect[0].xpos;
  181. for(i=0;i<index;i++)
  182. {
  183. if(sect[i].xpos>maxxx)maxxx=sect[i].xpos;
  184. if(sect[i].xpos<minxx)minxx=sect[i].xpos;
  185. }
  186. if(intersection.xpos>maxxx || intersection.xpos<minxx)return false;
  187. else 
  188. return true;
  189. }
  190. }
  191. else  //(absC<absA && absC<absB)
  192. {
  193. ///////////平面与Z轴接近平行
  194. p.C=1;
  195. p.D=-intersection.zpos;
  197. ///////////////////////////////////////////
  198. if(absA>absB)
  199. {   //////比较 Y 轴坐标
  200.             VERTEX sect[6];/////可能有重复的交点，如顶点
  201.             int  index=0;
  202. for( i=0;i<(num-1);i++)
  203. {
  204. if(ClassifyPointPlane(pv[i],p)!=ClassifyPointPlane(pv[i+1],p))
  205. {
  206.                      sect[index]=GetIntersection(pv[i],pv[i+1],p);
  207.  index++;
  208. }
  209. }
  210. if(ClassifyPointPlane(pv[0],p)!=ClassifyPointPlane(pv[num-1],p))
  211. {
  212.                  sect[index]=GetIntersection(pv[0],pv[num-1],p);
  213.  index++;
  214. }
  215. /////////////////////////////
  216. float maxyy,minyy;
  217. maxyy=minyy=sect[0].ypos;
  218. for(i=0;i<index;i++)
  219. {
  220. if(sect[i].ypos>maxyy)maxyy=sect[i].ypos;
  221. if(sect[i].ypos<minyy)minyy=sect[i].ypos;
  222. }
  223. if(intersection.ypos>maxyy || intersection.ypos<minyy)return false;
  224. else 
  225. return true;
  226. }
  227. else
  228. {   //////比较 X 轴坐标
  229.             VERTEX sect[6];/////可能有重复的交点，如顶点
  230.             int  index=0;
  231. for( i=0;i<(num-1);i++)
  232. {
  233. if(ClassifyPointPlane(pv[i],p)!=ClassifyPointPlane(pv[i+1],p))
  234. {
  235.                      sect[index]=GetIntersection(pv[i],pv[i+1],p);
  236.  index++;
  237. }
  238. }
  239. if(ClassifyPointPlane(pv[0],p)!=ClassifyPointPlane(pv[num-1],p))
  240. {
  241.                  sect[index]=GetIntersection(pv[0],pv[num-1],p);
  242.  index++;
  243. }
  244. /////////////////////////////
  245. float maxxx,minxx;
  246. maxxx=minxx=sect[0].xpos;
  247. for(i=0;i<index;i++)
  248. {
  249. if(sect[i].xpos>maxxx)maxxx=sect[i].xpos;
  250. if(sect[i].xpos<minxx)minxx=sect[i].xpos;
  251. }
  252. if(intersection.xpos>maxxx || intersection.xpos<minxx)return false;
  253. else 
  254. return true;
  255. }
  257. }
  259. return true;
  260. }
  261. bool CMath::IsLineSegmentCutBy3DBoundary(VERTEX v1 ,VERTEX v2,BOUNDARY_3D bd)
  262. {
  263. if(v1.xpos>bd.maxx && v2.xpos>bd.maxx)return false;
  264. if(v1.xpos<bd.minx && v2.xpos<bd.minx)return false;
  265. if(v1.ypos>bd.maxy && v2.ypos>bd.maxy)return false;
  266. if(v1.ypos<bd.miny && v2.ypos<bd.miny)return false;
  267. if(v1.zpos>bd.maxz && v2.zpos>bd.maxz)return false;
  268. if(v1.zpos<bd.minz && v2.zpos<bd.minz)return false;
  269. /////////////
  270.     VERTEX v[8];
  272. v[0]=VERTEX(bd.minx,bd.miny,bd.minz);
  273. v[1]=VERTEX(bd.maxx,bd.miny,bd.minz);
  274. v[2]=VERTEX(bd.maxx,bd.maxy,bd.minz);
  275. v[3]=VERTEX(bd.minx,bd.maxy,bd.minz);
  277. v[4]=VERTEX(bd.minx,bd.miny,bd.maxz);
  278. v[5]=VERTEX(bd.maxx,bd.miny,bd.maxz);
  279. v[6]=VERTEX(bd.maxx,bd.maxy,bd.maxz);
  280. v[7]=VERTEX(bd.minx,bd.maxy,bd.maxz);
  281.     ///////////////
  282.     if(IsLineSegmentCutByStardQuad(v1,v2, v[0],v[1],v[2],v[3]))return true;
  283.     if(IsLineSegmentCutByStardQuad(v1,v2, v[4],v[5],v[6],v[7]))return true;
  284.     if(IsLineSegmentCutByStardQuad(v1,v2, v[2],v[3],v[7],v[6]))return true;
  285.     if(IsLineSegmentCutByStardQuad(v1,v2, v[1],v[0],v[4],v[5]))return true;
  286.     if(IsLineSegmentCutByStardQuad(v1,v2, v[1],v[2],v[6],v[5]))return true;
  287.     if(IsLineSegmentCutByStardQuad(v1,v2, v[0],v[3],v[7],v[4]))return true;
  288.     ///////////////
  289.     return false;
  290. }
  292. bool CMath::IsLineSegmentCutByStardQuad(VERTEX v1 ,VERTEX v2,VERTEX va,VERTEX vb,VERTEX vc,VERTEX vd)
  293. {
  294. PLANE plane;
  295. plane=GetPlaneEquation(va,vb,vc);
  296. ///////////如果两点在同一侧
  297. if((ClassifyPointPlane(v1,plane)*ClassifyPointPlane(v2,plane))>=0)
  298. return false;
  299. //////////////获得线段与平面的交点
  300. VERTEX intersection;
  301. intersection=GetIntersection(v1,v2,plane);
  302. ///////////包围盒判断
  303. float maxx,minx,  maxy,miny,  maxz,minz;
  304. maxx=minx=va.xpos;
  305. maxy=miny=va.ypos;
  306. maxz=minz=va.zpos;
  308. if(vb.xpos>maxx)maxx=vb.xpos;
  309. if(vb.xpos<minx)minx=vb.xpos;
  310. if(vb.ypos>maxy)maxy=vb.ypos;
  311. if(vb.ypos<miny)miny=vb.ypos;
  312. if(vb.zpos>maxz)maxz=vb.zpos;
  313. if(vb.zpos<minz)minz=vb.zpos;
  315. if(vc.xpos>maxx)maxx=vc.xpos;
  316. if(vc.xpos<minx)minx=vc.xpos;
  317. if(vc.ypos>maxy)maxy=vc.ypos;
  318. if(vc.ypos<miny)miny=vc.ypos;
  319. if(vc.zpos>maxz)maxz=vc.zpos;
  320. if(vc.zpos<minz)minz=vc.zpos;
  322. if(vd.xpos>maxx)maxx=vd.xpos;
  323. if(vd.xpos<minx)minx=vd.xpos;
  324. if(vd.ypos>maxy)maxy=vd.ypos;
  325. if(vd.ypos<miny)miny=vd.ypos;
  326. if(vd.zpos>maxz)maxz=vd.zpos;
  327. if(vd.zpos<minz)minz=vd.zpos;
  329. if(intersection.xpos>maxx || intersection.xpos<minx)
  330. return false;
  331. if(intersection.ypos>maxy || intersection.ypos<miny)
  332. return false;
  333. if(intersection.zpos>maxz || intersection.zpos<minz)
  334. return false;
  336.     return true;
  337. }
  338. bool CMath::IsLineSegmentCutByStardQuad(VERTEX v1 ,VERTEX v2,VERTEX *pv)
  339. {
  340. return IsLineSegmentCutByStardQuad(v1,v2,pv[0],pv[1],pv[2],pv[3]);
  341. }
  342. PLANE CMath::GetPlaneEquation(VERTEX v1,VERTEX v2,PLANE p)
  343. {
  344. PLANE plane;
  345. /////////////  n12不能与plane垂直
  346.     ////???????????????????????????
  347. ///////////////////////////////
  348.     double nnx,nny,nnz ;
  349. nnx=v2.xpos-v1.xpos;
  350. nny=v2.ypos-v1.ypos;
  351. nnz=v2.zpos-v1.zpos;
  352. double pA,pB,pC,pD;
  353.     pA=p.A; pB=p.B; pC=p.C; pD=p.D;
  355.     double a,b,c;
  356. a=(pC*nny-pB*nnz)*(pA*nny-pB*nnx);
  357.     b=(pC*nnx-pA*nnz)*(pB*nnx-pA*nny);
  358. c=(pB*nnx-pA*nny)*(pA*nny-pB*nnx);
  360. NORMAL n=Normalization(a,b,c);
  361. plane.A=n.nx;
  362. plane.B=n.ny;
  363. plane.C=n.nz;    
  364. plane.D=-(plane.A*v1.xpos+plane.B*v1.ypos+plane.C*v1.zpos);
  366. return plane;
  368. }
  369. PLANE CMath::GetPlaneEquation(VERTEX *pVertices,int VerticesNumber)
  370. {
  371. PLANE plane;
  372. if(VerticesNumber<3)
  373. {
  374. plane.A=plane.B=plane.C=plane.D=0;
  375. }
  376. else
  377. {
  378.      NORMAL N12,N13,N;
  379.      ////////////calculate n12 n13
  380.      N12.nx=pVertices[1].xpos-pVertices[0].xpos;
  381.      N12.ny=pVertices[1].ypos-pVertices[0].ypos;
  382.      N12.nz=pVertices[1].zpos-pVertices[0].zpos;
  384.      N13.nx=pVertices[2].xpos-pVertices[0].xpos;
  385.      N13.ny=pVertices[2].ypos-pVertices[0].ypos;
  386.      N13.nz=pVertices[2].zpos-pVertices[0].zpos;
  387.      ////////////////////////////
  388.         N=GetTwoNormalProduct(N12,N13);
  390.      plane.A=N.nx;
  391.      plane.B=N.ny;
  392.      plane.C=N.nz;
  393. plane.D= -(plane.A*pVertices->xpos+plane.B*pVertices->ypos+plane.C*pVertices->zpos);
  394. }
  395. return plane;
  396. }
  398. PLANE CMath::GetPlaneEquation(VERTEX v1,VERTEX v2,VERTEX v3)
  399. {
  400. PLANE plane;
  401.     NORMAL N12,N13,N;
  402.     ////////////calculate n12 n13
  403.     N12.nx=v2.xpos-v1.xpos;
  404.     N12.ny=v2.ypos-v1.ypos;
  405.     N12.nz=v2.zpos-v1.zpos;
  407.     N13.nx=v3.xpos-v1.xpos;
  408.     N13.ny=v3.ypos-v1.ypos;
  409.     N13.nz=v3.zpos-v1.zpos;
  411.     N=GetTwoNormalProduct(N12,N13);
  413.     plane.A=N.nx;
  414.     plane.B=N.ny;
  415.     plane.C=N.nz;
  416. plane.D= -(plane.A*v1.xpos+plane.B*v1.ypos+plane.C*v1.zpos);
  418. return plane;
  419. }
  421. PLANE CMath::GetPlaneEquation(VERTEX v,PLANE p1,PLANE p2)
  422. {
  423. PLANE plane;
  424.     NORMAL n1,n2,normal;
  425.     n1.nx=p1.A;  n1.ny=p1.B;  n1.nz=p1.C;
  426.     n2.nx=p2.A;  n2.ny=p2.B;  n2.nz=p2.C;
  428. normal=GetTwoNormalProduct(n1,n2);
  430. plane.A=normal.nx;
  431. plane.B=normal.ny;
  432. plane.C=normal.nz;
  433. plane.D=-(plane.A*v.xpos+plane.B*v.ypos+plane.C*v.zpos);
  435. return plane;
  436. }
  438. VERTEX CMath::GetIntersection(VERTEX v1,VERTEX v2,PLANE plane)
  439. {
  440. VERTEX point;
  441. double temp1=(plane.A*(v2.xpos-v1.xpos)+plane.B*(v2.ypos-v1.ypos)+plane.C*(v2.zpos-v1.zpos));
  442. double temp2=-plane.D-plane.A*v1.xpos-plane.B*v1.ypos-plane.C*v1.zpos;
  443.     ///// Line param is temp2/temp1
  444. point.xpos=v1.xpos+float((double(v2.xpos-v1.xpos)*temp2)/temp1);
  445. point.ypos=v1.ypos+float((double(v2.ypos-v1.ypos)*temp2)/temp1);
  446. point.zpos=v1.zpos+float((double(v2.zpos-v1.zpos)*temp2)/temp1);
  447.  
  448. return point;
  449. }
  451. TEXCOORD CMath::GetIntersectionTexCoord(VERTEX pointA,TEXCOORD texcoordA,
  452. VERTEX pointB,TEXCOORD texcoordB,  PLANE plane)
  453. {
  454. VERTEX intersect=GetIntersection(pointA,pointB,plane);
  455. float distA=GetDistance(pointA,intersect);
  456. float distAB=GetDistance(pointA,pointB);
  457. if(distAB<0.0001)return texcoordA; ///////safe
  458. TEXCOORD texcoord;
  459. texcoord.u=(texcoordA.u*distAB + distA*(texcoordB.u-texcoordA.u))/distAB;
  460. texcoord.v=(texcoordA.v*distAB + distA*(texcoordB.v-texcoordA.v))/distAB;
  462. return texcoord;
  463. }
  465. VERTEX CMath::GetPositionOnGrid(VERTEX *pQuads,float u,float v)
  466. {
  467. /////////u，v 的范围为0－1
  468. if(u<0)u=0; if(u>1)u=1;
  469. if(v<0)v=0; if(v>1)v=1;
  470. //////////////////////////////////////
  471. VERTEX v1,v2; //与u相关的两条边上的点
  472. v1=VERTEX(pQuads[0].xpos+(pQuads[1].xpos-pQuads[0].xpos)*u,
  473.               pQuads[0].ypos+(pQuads[1].ypos-pQuads[0].ypos)*u,
  474.               pQuads[0].zpos+(pQuads[1].zpos-pQuads[0].zpos)*u);
  476. v2=VERTEX(pQuads[3].xpos+(pQuads[2].xpos-pQuads[3].xpos)*u,
  477.               pQuads[3].ypos+(pQuads[2].ypos-pQuads[3].ypos)*u,
  478.               pQuads[3].zpos+(pQuads[2].zpos-pQuads[3].zpos)*u);
  479. ///////////////////////////////////////
  480. VERTEX vertex;    ///所求的点
  481.     vertex.xpos=v1.xpos+(v2.xpos-v1.xpos)*v;
  482.     vertex.ypos=v1.ypos+(v2.ypos-v1.ypos)*v;
  483.     vertex.zpos=v1.zpos+(v2.zpos-v1.zpos)*v;
  485. return vertex;
  486. }
  488. NORMAL CMath::GetTwoNormalProduct(NORMAL n1,NORMAL n2)
  489. {
  490. double n1x,n1y,n1z,n2x,n2y,n2z;
  491. n1x=n1.nx;  n1y=n1.ny;  n1z=n1.nz;
  492. n2x=n2.nx;  n2y=n2.ny;  n2z=n2.nz;
  494.     double nx,ny,nz;
  496.     nx=  n1y*n2z-n2y*n1z;
  497.     ny=-(n1x*n2z-n2x*n1z);
  498.     nz=  n1x*n2y-n2x*n1y;
  499. // return NORMAL(float(nx),float(ny),float(nz));
  500. return Normalization(nx,ny,nz);
  501. }
  502. NORMAL CMath::GetNormal(VERTEX v1,VERTEX v2,VERTEX v3)
  503. {
  504. NORMAL n1,n2;
  505. n1.nx=v2.xpos-v1.xpos;
  506. n1.ny=v2.ypos-v1.ypos;
  507. n1.nz=v2.zpos-v1.zpos;
  509. n2.nx=v3.xpos-v1.xpos;
  510. n2.ny=v3.ypos-v1.ypos;
  511. n2.nz=v3.zpos-v1.zpos;
  513. return GetTwoNormalProduct(n1,n2);
  515. }
  516. NORMAL  CMath::GetNormal(float *v1,float *v2,float *v3)
  517. {
  518. NORMAL n1,n2;
  519. n1.nx=v2[0]-v1[0];
  520. n1.ny=v2[1]-v1[1];
  521. n1.nz=v2[2]-v1[2];
  523. n2.nx=v3[0]-v1[0];
  524. n2.ny=v3[1]-v1[1];
  525. n2.nz=v3[2]-v1[2];
  527. return GetTwoNormalProduct(n1,n2);
  529. }
  530. float CMath::GetTwoVectorAngleCosine(NORMAL na,NORMAL nb)
  531. {
  532.     NORMAL n1,n2;
  533. n1=Normalization(na);
  534. n2=Normalization(nb);
  535. double temp,length1,length2;
  536. temp=n1.nx*n2.nx+n1.ny*n2.ny+n1.nz*n2.nz;
  537. length1=pow( n1.nx*n1.nx +n1.ny*n1.ny +n1.nz*n1.nz,0.5);
  538. length2=pow( n2.nx*n2.nx +n2.ny*n2.ny +n2.nz*n2.nz,0.5);
  540. return float(temp/(length1*length2));
  541. }
  544. float CMath::GetDistance(VERTEX v1,VERTEX v2)
  545. {
  546. float dist;
  547. dist=(float)pow((v2.xpos-v1.xpos)*(v2.xpos-v1.xpos)+
  548.             (v2.ypos-v1.ypos)*(v2.ypos-v1.ypos)+
  549. (v2.zpos-v1.zpos)*(v2.zpos-v1.zpos),0.5);
  550. return dist;
  552. }
  553. float CMath::GetDistance(VERTEX point,PLANE plane)
  554. {
  555. float abc=(float)sqrt(plane.A*plane.A+plane.B*plane.B+plane.C*plane.C);
  556. float dist=(plane.A*point.xpos+plane.B*point.ypos+plane.C*point.zpos+plane.D)/abc;
  557.     if(dist<0)dist=-dist;
  558.     return dist;
  559. }
  560. float CMath::GetDistance(VERTEX point,PLANE plane,float powABC)
  561. {
  562.     return (plane.A*point.xpos+plane.B*point.ypos+plane.C*point.zpos+plane.D)/powABC;
  563. }
  564. float CMath::GetTwoVectorAngleCosine(VERTEX  v1,VERTEX vCenter,VERTEX v2)
  565. {
  566. double temp,length1,length2;
  567. double n1nx,n1ny,n1nz,n2nx,n2ny,n2nz;
  569. n1nx=v1.xpos-vCenter.xpos;
  570. n1ny=v1.ypos-vCenter.ypos;
  571. n1nz=v1.zpos-vCenter.zpos;
  573. n2nx=v2.xpos-vCenter.xpos;
  574. n2ny=v2.ypos-vCenter.ypos;
  575. n2nz=v2.zpos-vCenter.zpos;
  577. temp=n1nx*n2nx+n1ny*n2ny+n1nz*n2nz;
  578. length1=pow( n1nx*n1nx +n1ny*n1ny +n1nz*n1nz,0.5);
  579. length2=pow( n2nx*n2nx +n2ny*n2ny +n2nz*n2nz,0.5);
  581. return float(temp/(length1*length2));
  582. }
  584. int CMath::ClassifyTwoNormal(NORMAL n1,NORMAL n2)
  585. {
  586. float temp;
  587. temp=n1.nx*n2.nx+n1.ny*n2.ny+n1.nz*n2.nz;
  588. if(temp==0)return PERPENDICULAR;
  589. if(temp>0)return SHARP_ANGLE;
  590.     if(temp<0)return OBTUSE_ANGLE; 
  591. return UNKNOW;
  592. }
  594. int CMath::ClassifyTwoNormal(VERTEX  v1,VERTEX vCenter,VERTEX v2)
  595. {
  596. float temp;
  597. NORMAL n1,n2;
  599. n1.nx=v1.xpos-vCenter.xpos;
  600. n1.ny=v1.ypos-vCenter.ypos;
  601. n1.nz=v1.zpos-vCenter.zpos;
  603. n2.nx=v2.xpos-vCenter.xpos;
  604. n2.ny=v2.ypos-vCenter.ypos;
  605. n2.nz=v2.zpos-vCenter.zpos;
  607. temp=n1.nx*n2.nx+n1.ny*n2.ny+n1.nz*n2.nz;
  609. if(temp==0)return PERPENDICULAR;
  610. if(temp>0)return SHARP_ANGLE;
  611.     if(temp<0)return OBTUSE_ANGLE; 
  612. return UNKNOW;
  613. }
  615. int CMath::ClassifyPointPlane(VERTEX point,PLANE plane)
  616. {
  617. float distance=plane.A*point.xpos+plane.B*point.ypos+plane.C*point.zpos+plane.D;
  618.     if(distance==0)return COINCIDENT;
  619. if(distance>0)return  IN_FRONT_OF;
  620. return  IN_BACK_OF;
  621. }
  623. int CMath::ClassifyPolygonPlane(PLANE plane,VERTEX *vertices,int num)
  624. {
  625. if(num<3)return UNKNOW;
  626. int current=0;
  627.     int dist=ClassifyPointPlane(vertices[0],plane);
  628. if(dist==IN_FRONT_OF)
  629. {
  630.         current=1;
  631. while(current<num && dist!=IN_BACK_OF)
  632. {
  633.              dist=ClassifyPointPlane(vertices[current],plane);
  634.  current++;
  635. }
  637. if(current<num)return SPANNING;
  638. else if(dist==IN_BACK_OF) return SPANNING;
  639. else return IN_FRONT_OF;
  640. }
  641. else if(dist==IN_BACK_OF)
  642. {
  643.         current=1;
  644. while(current<num && dist!=IN_FRONT_OF)
  645. {
  646.              dist=ClassifyPointPlane(vertices[current],plane);
  647.  current++;
  648. }
  650. if(current<num)return SPANNING;
  651. else if(dist==IN_FRONT_OF) return SPANNING;
  652. else return IN_BACK_OF;
  653. }
  654. else   //First point in the plane
  655. {
  656. int front,back;
  657. front=back=0;
  658. int temp;
  659. for(int i=1;i<num;i++)
  660. {
  661. temp=ClassifyPointPlane(vertices[i],plane);
  662. if(temp==IN_FRONT_OF)front++;
  663. if(temp==IN_BACK_OF)back--;
  664. }
  665. if(front==0 && back==0)return COINCIDENT;
  666. if((front+back)==back)return IN_BACK_OF;
  667. if((front+back)==front)return IN_FRONT_OF;
  669. return SPANNING;
  670. }
  671. }
  673. NORMAL CMath::Normalization(NORMAL n)
  674. {
  675. NORMAL normal;
  676. double x,y,z;
  677. x=n.nx; y=n.ny; z=n.nz;
  679. double max=sqrt(x*x+y*y+z*z);
  680.     if(max<0.0001)return NORMAL(0,1,0);
  682. x=x/max;
  683. y=y/max;
  684. z=z/max;
  686. normal.nx=float(x);
  687. normal.ny=float(y);
  688. normal.nz=float(z);
  690. return normal;
  692. }
  694. NORMAL CMath::Normalization(double x,double y,double z)
  695. {
  696. NORMAL normal=NORMAL(x,y,z);
  697.     return Normalization(normal);
  698. }