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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
Face3d.cpp
资源名称：display_list.zip　[点击查看]
上传用户：hcfgz168
上传日期：2011-09-11
资源大小：116k
文件大小：20k
源码类别：

OpenGL

开发平台：

WINDOWS

Face3d.cpp：源码内容
  1. //********************************************
  2. // Face3d.cpp
  3. //********************************************
  4. // class CFace3d
  5. //********************************************
  6. // pierre.alliez@cnet.francetelecom.fr
  7. // Created : 10/12/97
  8. // Modified : 09/02/98
  9. //********************************************
  11. #include "stdafx.h"
  13. #include "Base3d.h"
  14. #include "Face3d.h"
  16. //////////////////////////////////////////////
  17. // CONSTRUCTORS
  18. //////////////////////////////////////////////
  20. //********************************************
  21. // Constructor
  22. //********************************************
  23. CFace3d::CFace3d()
  24. {
  25. for(int i=0;i<3;i++)
  26.   m_pFace[i] = NULL;
  27. for(i=0;i<6;i++)
  28.   m_pVertex[i] = NULL;
  29. m_Flag = 0;
  30. }
  32. //********************************************
  33. // Constructor
  34. //********************************************
  35. CFace3d::CFace3d(CVertex3d *pVertex1,
  36.  CVertex3d *pVertex2,
  37.  CVertex3d *pVertex3)
  38. {
  39. // Face
  40. for(int i=0;i<3;i++)
  41.   m_pFace[i] = NULL;
  42. // Vertices
  43. Set(pVertex1,pVertex2,pVertex3);
  44. for(i=3;i<6;i++)
  45.   m_pVertex[i] = NULL;
  47. // Normal
  48. m_Normal.Set(0.0f,0.0f,0.0f);
  50. m_Flag = 0;
  51. }
  54. //********************************************
  55. // Constructor
  56. //********************************************
  57. CFace3d::CFace3d(CFace3d *pFace)
  58. {
  59. Set(pFace);
  60. m_Flag = 0;
  61. }
  64. //////////////////////////////////////////////
  65. // DATAS
  66. //////////////////////////////////////////////
  68. //********************************************
  69. // Set
  70. //********************************************
  71. inline void CFace3d::Clear()
  72. {
  73. for(int i=0;i<3;i++)
  74.   m_pFace[i] = NULL;
  75. for(i=0;i<6;i++)
  76.   m_pVertex[i] = NULL;
  77. m_Flag = 0;
  78. }
  80. //********************************************
  81. // Equal
  82. //********************************************
  83. int CFace3d::Equal(CFace3d *pFace)
  84. {
  85. return (HasVertex(pFace->v1()) && 
  86.       HasVertex(pFace->v2()) &&
  87. HasVertex(pFace->v3()));
  88. }
  90. //********************************************
  91. // IsValid
  92. //********************************************
  93. int CFace3d::IsValid()
  94. {
  95. int success = 1;
  97. success &= (m_pFace[0] != this);
  98. success &= (m_pFace[1] != this);
  99. success &= (m_pFace[2] != this);
  101. // Different neighbors, if there are
  102. success &= ((m_pFace[0] != m_pFace[1]) || (m_pFace[0] == NULL));
  103. success &= ((m_pFace[0] != m_pFace[2]) || (m_pFace[0] == NULL));
  104. success &= ((m_pFace[1] != m_pFace[2]) || (m_pFace[1] == NULL));
  106. #ifdef _DEBUG
  107. if(!success)
  108. {
  109. TRACE("Face [%x] has the same neighborsn",this);
  110. }
  111. #endif
  113. // Different vertices
  114. success &= (m_pVertex[0] != m_pVertex[1]);
  115. success &= (m_pVertex[1] != m_pVertex[2]);
  116. success &= (m_pVertex[0] != m_pVertex[2]);
  118. /*
  119. #ifdef _DEBUG
  120. if(NbFaceNeighbor() != 3)
  121. {
  122. TRACE("Face [%x] has %d neighborsn",NbFaceNeighbor());
  123. }
  124. #endif
  125. */
  127. #ifdef _DEBUG
  128. if(!success)
  129. {
  130. TRACE("Face [%x] has the same vertices n",this);
  131. }
  132. #endif
  134. // Reciproc. neighboring
  135. for(int i=0;i<3;i++)
  136. {
  137. CFace3d *pFace = f(i);
  138. if(pFace != NULL)
  139. {
  140. if(!pFace->HasNeighbor(this))
  141. {
  142. TRACE("Face [%x] has invalid reciproc. neighboring n",this);
  143. success = 0;
  144. }
  145. }
  146. }
  148. return success;
  149. }
  151. //********************************************
  152. // Set
  153. //********************************************
  154. inline void CFace3d::Set(CVertex3d *pVertex1,
  155.  CVertex3d *pVertex2,
  156.  CVertex3d *pVertex3)
  157. {
  158. m_pVertex[0] = pVertex1;
  159. m_pVertex[1] = pVertex2;
  160. m_pVertex[2] = pVertex3;
  161. }
  163. //********************************************
  164. // Set
  165. //********************************************
  166. inline void CFace3d::Set(CFace3d *pFace1,
  167.  CFace3d *pFace2,
  168.  CFace3d *pFace3)
  169. {
  170. m_pFace[0] = pFace1;
  171. m_pFace[1] = pFace2;
  172. m_pFace[2] = pFace3;
  173. }
  175. //********************************************
  176. // Set
  177. //********************************************
  178. inline void CFace3d::Set(CVertex3d *pVertex1,
  179.  CVertex3d *pVertex2,
  180.  CVertex3d *pVertex3,
  181.  CFace3d *pFace1,
  182.  CFace3d *pFace2,
  183.  CFace3d *pFace3)
  184. {
  185. m_pVertex[0] = pVertex1;
  186. m_pVertex[1] = pVertex2;
  187. m_pVertex[2] = pVertex3;
  188. m_pFace[0] = pFace1;
  189. m_pFace[1] = pFace2;
  190. m_pFace[2] = pFace3;
  191. }
  193. //********************************************
  194. // Set
  195. //********************************************
  196. inline void CFace3d::Set(CFace3d *pFace)
  197. {
  198. Set(pFace->v1(),pFace->v2(),pFace->v3());
  199. Set(pFace->f1(),pFace->f2(),pFace->f3());
  200. }
  202. //********************************************
  203. // SetFlagOnVerticesIfDiff
  204. //********************************************
  205. void CFace3d::SetFlagOnVerticesIfDiff(int FlagDiff,
  206. int flag)
  207. {
  208. for(int i=0;i<3;i++)
  209. {
  210. CVertex3d *pVertex = v(i);
  211. if(pVertex->GetFlag() != FlagDiff)
  212. pVertex->SetFlag(flag);
  213. }
  214. }
  217. //********************************************
  218. // IndexFrom
  219. //********************************************
  220. int CFace3d::IndexFrom(CVertex3d *pVertex)
  221. {
  222. ASSERT(HasVertex(pVertex));
  223. for(int i=0;i<3;i++)
  224. if(m_pVertex[i]==pVertex)
  225. return i;
  226. return 0;
  227. }
  230. //********************************************
  231. // GetCenter
  232. // Allocate on the heap
  233. //********************************************
  234. CVertex3d* CFace3d::GetCenter(void)
  235. {
  236. CVertex3d* pVertex = new CVertex3d;
  237. pVertex->x((m_pVertex[0]->x()+m_pVertex[1]->x()+m_pVertex[2]->x())/3.0f);
  238. pVertex->y((m_pVertex[0]->y()+m_pVertex[1]->y()+m_pVertex[2]->y())/3.0f);
  239. pVertex->z((m_pVertex[0]->z()+m_pVertex[1]->z()+m_pVertex[2]->z())/3.0f);
  240. return pVertex;
  241. }
  243. //********************************************
  244. // FindNearestVertex
  245. //********************************************
  246. CVertex3d *CFace3d::FindNearestVertex(CVertex3d *pVertex)
  247. {
  248. CVertex3d *pV = v(0);
  249. double MinDistance = DistanceSquare(pVertex,v(0));
  250. for(int i=1;i<3;i++)
  251. {
  252. double tmp = DistanceSquare(pVertex,v(i));
  253. if(tmp < MinDistance)
  254. {
  255. MinDistance = tmp;
  256. pV = v(i);
  257. }
  258. }
  259. return pV;
  260. }
  263. //********************************************
  264. // ColorSharpEdge
  265. //********************************************
  266. void CFace3d::ColorSharpEdge(double threshold,
  267.  CColor &color)
  268. {
  269. for(int i=0;i<3;i++)
  270. if(SinAngle(this,f(i)) >= threshold)
  271. {
  272. v(i)->SetColor(color);
  273. v((i+1)%3)->SetColor(color);
  274. }
  275. }
  277. //********************************************
  278. // ColorSharpEdge
  279. //********************************************
  280. int CFace3d::GetSharpEdge(double threshold,
  281. int *SharpEdge)
  282. {
  283. int success = 0;
  284. for(int i=0;i<3;i++)
  285. if(f(i) != NULL)
  286. if(SinAngle(this,f(i)) >= threshold)
  287. {
  288. SharpEdge[i]=1;
  289. success = 1;
  290. }
  291. return success;
  292. }
  294. //********************************************
  295. // HasSharpEdge
  296. //********************************************
  297. int CFace3d::HasSharpEdge(double threshold)
  298. {
  299. for(int i=0;i<3;i++)
  300. {
  301. double sinus = SinAngle(this,f(i));
  302. //TRACE("SinAngle : %gn",sinus);
  303. if(sinus >= threshold)
  304. return 1;
  305. }
  306. return 0;
  307. }
  310. //////////////////////////////////////////////
  311. // DATA ACCESS
  312. //////////////////////////////////////////////
  314. //********************************************
  315. // GetType
  316. //********************************************
  317. int CFace3d::GetType()
  318. {
  319. return TYPE_FACE3D;
  320. }
  322. //********************************************
  323. // NbVertex
  324. //********************************************
  325. int CFace3d::NbVertex()
  326. {
  327. int NbVertex = 0;
  328. for(int i=0;i<6;i++)
  329.   NbVertex += (m_pVertex[i] != NULL);
  330. return NbVertex;
  331. }
  333. //********************************************
  334. // NbFaceNeighbor
  335. //********************************************
  336. int CFace3d::NbFaceNeighbor()
  337. {
  338. int NbFace = 0;
  339. NbFace += (m_pFace[0] != NULL);
  340. NbFace += (m_pFace[1] != NULL);
  341. NbFace += (m_pFace[2] != NULL);
  342. return NbFace;
  343. }
  346. //////////////////////////////////////////////
  347. // PROCESSING
  348. //////////////////////////////////////////////
  351. //********************************************
  352. // CalculateNormal
  353. //********************************************
  354. void CFace3d::CalculateNormal()
  355. {
  356. CVector3d u(m_pVertex[0],m_pVertex[1]);
  357. CVector3d v(m_pVertex[0],m_pVertex[2]);
  358. u.Inner(v);
  359. m_Normal.Set(u);
  360. m_Normal.NormalizeL2();
  361. }
  367. //////////////////////////////////////////////
  368. // MISC
  369. //////////////////////////////////////////////
  371. //********************************************
  372. // HasVertex
  373. //********************************************
  374. int CFace3d::HasVertex(CVertex3d *pVertex)
  375. {
  376. return (m_pVertex[0] == pVertex ||
  377.       m_pVertex[1] == pVertex ||
  378.       m_pVertex[2] == pVertex);
  379. }
  381. //********************************************
  382. // HasVertexWithFlag
  383. //********************************************
  384. int CFace3d::HasVertexWithFlag(int flag)
  385. {
  386. return (m_pVertex[0]->GetFlag() == flag ||
  387.       m_pVertex[1]->GetFlag() == flag ||
  388.       m_pVertex[2]->GetFlag() == flag);
  389. }
  391. //********************************************
  392. // HasVertex
  393. //********************************************
  394. int CFace3d::HasVertex(CVertex3d *pVertex,
  395.  int *index)
  396. {
  397. for(int i=0;i<3;i++)
  398. if(m_pVertex[i] == pVertex)
  399. {
  400. *index = i;
  401. return 1;
  402. }
  403. return 0;
  404. }
  406. //********************************************
  407. // HasVertex
  408. //********************************************
  409. int CFace3d::HasNeighbor(CFace3d *pFace)
  410. {
  411. return (m_pFace[0] == pFace ||
  412.       m_pFace[1] == pFace ||
  413.       m_pFace[2] == pFace);
  414. }
  417. //********************************************
  418. // HasVertex
  419. //********************************************
  420. int CFace3d::HasNeighbor(CFace3d *pFace,
  421.  int *index)
  422. {
  423. for(int i=0;i<3;i++)
  424. if(m_pFace[i] == pFace)
  425. {
  426. *index = i;
  427. return 1;
  428. }
  429. return 0;
  430. }
  433. //********************************************
  434. // GetNeighborExclusive
  435. // Get neighboring face wich has pVertexHas
  436. // and has not pVertexHasNot
  437. //********************************************
  438. CFace3d *CFace3d::GetNeighborExclusive(CVertex3d *pVertexHas,
  439.  CVertex3d *pVertexHasNot)
  440. {
  441. for(int i=0;i<3;i++)
  442. {
  443. CFace3d *pFace = f(i);
  444. if(pFace != NULL)
  445. if(pFace->HasVertex(pVertexHas) && 
  446. !pFace->HasVertex(pVertexHasNot))
  447. return pFace;
  448. }
  449. return NULL;
  450. }
  452. //********************************************
  453. // GetVertexExclusive
  454. //********************************************
  455. CVertex3d *CFace3d::GetVertexExclusive(CVertex3d *pV0,
  456.  CVertex3d *pV1)
  457. {
  458. for(int i=0;i<3;i++)
  459. if(v(i) != pV0 && v(i) != pV1)
  460. return v(i);
  461. return NULL;
  462. }
  465. //********************************************
  466. // GetVertexExclusive
  467. // Return vertex common to this and pFace,
  468. // but pV
  469. //********************************************
  470. CVertex3d *CFace3d::GetVertexExclusive(CVertex3d *pV,
  471.  CFace3d *pFace)
  472. {
  473. for(int i=0;i<3;i++)
  474. if(v(i) != pV && pFace->HasVertex(v(i)))
  475. return v(i);
  476. return NULL;
  477. }
  480. //********************************************
  481. // GetFaceNeighborExclusive
  482. //********************************************
  483. CFace3d *CFace3d::GetFaceNeighborExclusive(CFace3d *pF0,
  484.  CFace3d *pF1)
  485. {
  486. for(int i=0;i<3;i++)
  487. if(f(i) != pF0 && f(i) != pF1)
  488. return f(i);
  489. return NULL;
  490. }
  493. //********************************************
  494. // GetVertexFaceNeighborExclusive
  495. // Get vertex on neighboring face, which is not 
  496. // on "this".
  497. // index : neighboring face
  498. //********************************************
  499. CVertex3d *CFace3d::GetVertexFaceNeighborExclusive(unsigned int index)
  500. {
  501. CFace3d *pFace = m_pFace[index%3];
  502. for(int i=0;i<3;i++)
  503. if(!this->HasVertex(pFace->v(i)))
  504. return pFace->v(i);
  505. return NULL;
  506. }
  509. //********************************************
  510. // JointNeighbor
  511. //********************************************
  512. int CFace3d::JointNeighbor(CFace3d **pFace0,
  513.  CFace3d **pFace1)
  514. {
  515. ASSERT(NbFaceNeighbor()==2);
  517. if(NbFaceNeighbor()!=2)
  518. return 0;
  520. // Find 2 neighbors
  521. CFace3d *pFaceNeighbor[2];
  522. int k=0;
  523. for(int i=0;i<3;i++)
  524. {
  525. if(m_pFace[i] != NULL)
  526. pFaceNeighbor[k++] = m_pFace[i];
  527. }
  528. ASSERT(k==2);
  529. if(k!=2)
  530. return 0;
  532. ASSERT(pFaceNeighbor[0]->HasNeighbor(this));
  533. ASSERT(pFaceNeighbor[1]->HasNeighbor(this));
  534. ASSERT(pFaceNeighbor[0] != this);
  535. ASSERT(pFaceNeighbor[1] != this);
  537. *pFace0 = pFaceNeighbor[0];
  538. *pFace1 = pFaceNeighbor[1];
  540. pFaceNeighbor[0]->UpdateNeighbor(this,pFaceNeighbor[1]);
  541. pFaceNeighbor[1]->UpdateNeighbor(this,pFaceNeighbor[0]);
  543. return 1;
  544. }
  548. //********************************************
  549. // UpdateVertex
  550. //********************************************
  551. int CFace3d::UpdateVertex(CVertex3d *pOld,
  552. CVertex3d *pNew)
  553. {
  554. int index;
  555. if(HasVertex(pOld,&index))
  556. {
  557. v(index,pNew);
  558. CalculateNormal(); // Update normal
  559. return 1;
  560. }
  561. return 0;
  562. }
  564. //********************************************
  565. // UpdateNeighbor
  566. //********************************************
  567. int CFace3d::UpdateNeighbor(CFace3d *pOld,
  568.   CFace3d *pNew)
  569. {
  570. int index;
  571. if(HasNeighbor(pOld,&index))
  572. {
  573. f(index,pNew);
  574. return 1;
  575. }
  576. return 0;
  577. }
  579. //********************************************
  580. // Share2Vertex (exactly)
  581. //********************************************
  582. int CFace3d::Share2Vertex(CFace3d *pFace)
  583. {
  584. if(pFace == NULL)
  585. return 0;
  586. int NbSharedVertex = 0;
  587. for(int i=0;i<3;i++)
  588. for(int j=0;j<3;j++)
  589. NbSharedVertex += (pFace->v(i) == m_pVertex[j]);
  590. return (NbSharedVertex == 2);
  591. }
  593. //********************************************
  594. // Share2Vertex (exactly)
  595. // Get sharing edge index info
  596. //********************************************
  597. int CFace3d::Share2Vertex(CFace3d *pFace,
  598.  int *IndexEdgeThis,
  599.  int *IndexEdgeOther)
  600. {
  601. if(!Share2Vertex(pFace))
  602. return 0;
  604. int IndexThis[3] = {0,0,0};
  605. int IndexOther[3] = {0,0,0};
  607. for(int i=0;i<3;i++)
  608. for(int j=0;j<3;j++)
  609. if(pFace->v(i) == m_pVertex[j]) 
  610. { 
  611. IndexThis[j] = 1;
  612. IndexOther[i] = 1; 
  613. }
  615. // Set IndexEdges
  616. *IndexEdgeThis = (IndexThis[0] && IndexThis[1]) ? 0 : (IndexThis[1] && IndexThis[2]) ? 1 : 2;
  617. *IndexEdgeOther = (IndexOther[0] && IndexOther[1]) ? 0 : (IndexOther[1] && IndexOther[2]) ? 1 : 2;
  619. // ** DEBUG **
  620. if(*IndexEdgeThis == 2)
  621. {
  622. ASSERT(IndexThis[0] && IndexThis[2]);
  623. }
  624. if(*IndexEdgeOther == 2)
  625. {
  626. ASSERT(IndexOther[0] && IndexOther[2]);
  627. }
  629. return 1;
  630. }
  632. //********************************************
  633. // Share2Vertex (exactly)
  634. // Get sharing edge index info
  635. //********************************************
  636. int CFace3d::Share2Vertex(CFace3d *pFace,
  637.  CVertex3d **pSharedV1,
  638.  CVertex3d **pSharedV2)
  639. {
  640. int EdgeThis;
  641. int EdgeOther;
  642. if(!Share2Vertex(pFace))
  643. {
  644. *pSharedV1 = NULL;
  645. *pSharedV2 = NULL;
  646. return 0;
  647. }
  648. Share2Vertex(pFace,&EdgeThis,&EdgeOther);
  649. *pSharedV1 = v(EdgeThis);
  650. *pSharedV2 = v((EdgeThis+1)%3);
  651. return 1;
  652. }
  654. //********************************************
  655. // Share1Vertex (exactly)
  656. //********************************************
  657. int CFace3d::Share1Vertex(CFace3d *pFace)
  658. {
  659. int NbSharedVertex = 0;
  660. for(int i=0;i<3;i++)
  661. for(int j=0;j<3;j++)
  662. NbSharedVertex += (pFace->v(i) == m_pVertex[j]);
  663. return (NbSharedVertex == 1);
  664. }
  667. //********************************************
  668. // UpdateVertexRecursive
  669. //********************************************
  670. int CFace3d::UpdateVertexRecursive(CVertex3d *pVertexOld,
  671.  CVertex3d *pVertexNew)
  672. {
  673. if(pVertexOld == pVertexNew)
  674. return 0;
  675. //TRACE("Update vertex %x in face %xn",pVertexOld,this);
  676. this->UpdateVertex(pVertexOld,pVertexNew);
  677. for(int i=0;i<3;i++)
  678. {
  679. CFace3d *pFace = f(i);
  680. if(pFace != NULL)
  681. if(pFace->HasVertex(pVertexOld))
  682. pFace->UpdateVertexRecursive(pVertexOld,pVertexNew);
  683. }
  684. return 1;
  685. }
  687. //********************************************
  688. // BuildArrayNeighbor
  689. //********************************************
  690. int CFace3d::BuildArrayNeighbor(CArray3d<CFace3d> *pArrayFace,
  691. int depth)
  692. {
  693. // Remove all
  694. pArrayFace->SetSize(0);
  695. pArrayFace->Add(this);
  697. for(int i=0;i<3;i++)
  698. {
  699. CVertex3d *pVertex = v(i);
  700. int NbFaceNeighbor = pVertex->NbFaceNeighbor();
  701. for(int j=0;j<NbFaceNeighbor;j++)
  702. {
  703. CFace3d *pFace = pVertex->GetFaceNeighbor(j);
  704. if(pFace != this) // it's done
  705. if(!pArrayFace->Has(pFace))
  706. pArrayFace->Add(pFace);
  707. }
  708. }
  710. return 1;
  711. }
  717. //////////////////////////////////////////////
  718. // DEBUG
  719. //////////////////////////////////////////////
  721. //********************************************
  722. // Trace
  723. //********************************************
  724. void CFace3d::Trace()
  725. {
  726. TRACE("n");
  727. TRACE("Face %xn",this);
  728. TRACE("Vertex   : %dn",NbVertex());
  729. TRACE("Face (n) : %dn",NbFaceNeighbor());
  730. TRACE("Normal   : %sn",(m_Normal.GetNormL2Square()==0) ? "no" : "yes");
  731. TRACE("Vertices : (%g,%g,%g) (%g,%g,%g) (%g,%g,%g) n",
  732. m_pVertex[0]->x(),m_pVertex[0]->y(),m_pVertex[0]->z(),
  733. m_pVertex[1]->x(),m_pVertex[1]->y(),m_pVertex[1]->z(),
  734. m_pVertex[2]->x(),m_pVertex[2]->y(),m_pVertex[2]->z());
  735. TRACE("Normal   : (%g,%g,%g)n",m_Normal.x(),m_Normal.y(),m_Normal.z());
  737. // ** DEBUG **
  738. /*
  739. for(int i=0;i<3;i++)
  740. m_pVertex[i]->Trace();
  741. */
  742. }
  745. //////////////////////////////////////////////
  746. // OPENGL
  747. //////////////////////////////////////////////
  749. //********************************************
  750. // glDraw
  751. // Highlights face and its neighbors
  752. //********************************************
  753. void CFace3d::glDraw(unsigned char *ColorFace,
  754.  CMesh3d *pMesh /* = NULL */,
  755.  unsigned char *ColorNeightbor /* = NULL */)
  756. {
  757. // Transform
  758. if(pMesh != NULL)
  759. {
  760. CTransform *pTransform = pMesh->GetTransform();
  761. ::glPushMatrix();
  763. // Position / translation / scaling
  764. glTranslatef(pTransform->GetTranslation()->x(),
  765.  pTransform->GetTranslation()->y(),
  766.  pTransform->GetTranslation()->z());
  768. glScalef(pTransform->GetScale()->x(),
  769.  pTransform->GetScale()->y(),
  770.  pTransform->GetScale()->z());
  772. glRotatef(pTransform->GetValueRotation(),
  773. pTransform->GetRotation()->x(),
  774. pTransform->GetRotation()->y(),
  775. pTransform->GetRotation()->z());
  776. }
  778. // Neighbor
  779. if(ColorNeightbor != NULL)
  780. {
  781. glColor3ub(ColorNeightbor[0],ColorNeightbor[1],ColorNeightbor[2]);
  782. for(int k=0;k<3;k++)
  783. {
  784. CFace3d *pFace = f(k);
  785. if(pFace != NULL)
  786. {
  787. ::glBegin(GL_POLYGON);
  788. ::glVertex3f(pFace->v1()->x(),pFace->v1()->y(),pFace->v1()->z());
  789. ::glVertex3f(pFace->v2()->x(),pFace->v2()->y(),pFace->v2()->z());
  790. ::glVertex3f(pFace->v3()->x(),pFace->v3()->y(),pFace->v3()->z());
  791. ::glEnd();
  792. }
  793. }
  794. }
  796. // Main face
  797. glColor3ub(ColorFace[0],ColorFace[1],ColorFace[2]);
  799. ::glBegin(GL_POLYGON);
  800. for(int i=0;i<3;i++)
  801. ::glVertex3f(m_pVertex[i]->x(),m_pVertex[i]->y(),m_pVertex[i]->z());
  802. ::glEnd();
  804. if(pMesh != NULL)
  805. {
  806. ::glPopMatrix();
  807. }
  808. }
  811. //********************************************
  812. // Area
  813. //********************************************
  814. double CFace3d::Area()
  815. {
  816. return ::Area(m_pVertex[0],m_pVertex[1],m_pVertex[2]);
  817. }
  819. //********************************************
  820. // Perimeter
  821. //********************************************
  822. double CFace3d::Perimeter()
  823. {
  824. return (::Distance(m_pVertex[0],m_pVertex[1]) + 
  825.       ::Distance(m_pVertex[1],m_pVertex[2]) +
  826. ::Distance(m_pVertex[2],m_pVertex[0]));
  827. }
  829. //********************************************
  830. // Compacity
  831. //********************************************
  832. double CFace3d::Compacity()
  833. {
  834. double perimeter = Perimeter();
  835. if(perimeter == 0.0f)
  836. {
  837. TRACE("CFace3d::Compacity : null trianglen");
  838. return 0.0;
  839. }
  840. return (4.0*PI*Area()/(perimeter*perimeter));
  841. }
  844. // ** EOF **