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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
3dObjectLathe.cpp
资源名称：gloop.zip　[点击查看]
上传用户：shxiangxiu
上传日期：2007-01-03
资源大小：1101k
文件大小：22k
源码类别：

OpenGL

开发平台：

Visual C++

3dObjectLathe.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////////
  2. // 3dObjectLathe.cpp : implementation file
  3. //
  4. // glOOP (OpenGL Object Oriented Programming library)
  5. // Copyright (c) Craig Fahrnbach 1997, 1998
  6. //
  7. // OpenGL is a registered trademark of Silicon Graphics
  8. //
  9. //
  10. // This program is provided for educational and personal use only and
  11. // is provided without guarantee or warrantee expressed or implied.
  12. //
  13. // Commercial use is strickly prohibited without written permission
  14. // from ImageWare Development.
  15. //
  16. // This program is -not- in the public domain.
  17. //
  18. /////////////////////////////////////////////////////////////////////////////
  20. #include "stdafx.h"
  21. #include "glOOP.h"
  22. #include "3dObjectDialog.h"
  23. #include <math.h>
  25. #ifdef _DEBUG
  26. #define new DEBUG_NEW
  27. #undef THIS_FILE
  28. static char THIS_FILE[] = __FILE__;
  29. #endif
  33. //////////////////////////////////////////////////////////////////
  34. // C3dObjectLathe
  36. IMPLEMENT_DYNAMIC(C3dObjectLathe, C3dObject)
  39. /////////////////////////////////////////////////////////////////////////////
  40. // C3dShape construction
  42. C3dObjectLathe::C3dObjectLathe()
  43. {
  44. // Set the attributes to default values..
  45.   m_iType = SHAPE_OBJECT;
  46.    m_szName.Format("Lathe %u", nLatheObjects++);
  48. m_fSweepAngle  = 360.0f;
  49. m_iSegments = 20;
  50. m_bSmooth   = TRUE;
  51. m_fMaxAngle = 30.0f;
  53. // Create our C3dPointArray object
  54. m_pPointArray = new C3dPointArray;
  55. ASSERT(m_pPointArray);
  56. }
  58. /////////////////////////////////////////////////////////////////////////////
  59. // C3DWorld Destructor
  61. C3dObjectLathe::~C3dObjectLathe()
  62. {
  63. // Delete our point array
  64. if(m_pPointArray)
  65. delete m_pPointArray;
  66. }
  69. /////////////////////////////////////////////////////////////////////////////
  70. // C3dObjectLathe virtual function overrides
  72. void C3dObjectLathe::AddAttributePage(C3dWorld* pWorld, LPVOID pSht)
  73. {
  74. C3dObjectPropSheet* pSheet = (C3dObjectPropSheet*)pSht;
  75. ASSERT(pSheet);
  77. // Add the page to the property sheet
  78. pSheet->AddPage(&pSheet->m_LathePage);
  79. // Save the address of this object in the page
  80. pSheet->m_LathePage.m_pObject = this;
  81. }
  83. void C3dObjectLathe::GetShapeBounds(C3dBoundingBox* pBox)
  84. {
  85. C3dPoint* pPoint;
  87. // Set to large positive number
  88. pBox->m_fMin[X] = -(GLfloat)LARGE_NUMBER;
  89. pBox->m_fMin[Z] = (GLfloat)LARGE_NUMBER;
  91. // Set to large negative number
  92. pBox->m_fMax[X] = -(GLfloat)LARGE_NUMBER;
  93. pBox->m_fMax[Z] = -(GLfloat)LARGE_NUMBER;
  96. for(int i=0; i<m_pPointArray->m_iNumPoints; i++)
  97. {
  98. pPoint = &m_pPointArray->m_pPoints[i];
  100. if(pPoint->m_fOrigin[X] > pBox->m_fMax[X])
  101. pBox->m_fMax[X] = pPoint->m_fOrigin[X];
  103. if(pPoint->m_fOrigin[Z] > pBox->m_fMax[Z])
  104. pBox->m_fMax[Z] = pPoint->m_fOrigin[Z];
  106. if(pPoint->m_fOrigin[X] > pBox->m_fMin[X])
  107. pBox->m_fMin[X] = pPoint->m_fOrigin[X];
  109. if(pPoint->m_fOrigin[Z] < pBox->m_fMin[Z])
  110. pBox->m_fMin[Z] = pPoint->m_fOrigin[Z];
  111. }
  113. // Since we 'lathe' about the Z-Axis, copy the X-Axis
  114. // values to the Y-Axis
  115. pBox->m_fMax[Y] = pBox->m_fMax[X];
  116. pBox->m_fMin[Y] = pBox->m_fMin[X];
  119. // Since the points array only maps values 'typically' 
  120. // defined along one side of the Z-Axis, negate the min
  121. // values to indicate the 'opposite' side..
  122. pBox->m_fMin[X] *= -1.0f;
  123. pBox->m_fMin[Y] *= -1.0f;
  124. }
  126. int C3dObjectLathe::LoadBitMapImage(CImageList* pList)
  127. {
  128. CBitmap bitmap;
  130. // If the image index has been stored in this object,
  131. // return the index.
  132. if(m_iBMImage > -1)
  133. return m_iBMImage;
  135. // If the image index for this object type has been
  136. // created, store the index for this object and
  137. // return the index.
  138. if( iObjectPlaneBMImage > -1) {
  139. m_iBMImage = iObjectPlaneBMImage;
  140. return m_iBMImage;
  141. }
  143. // The image index for this object type has not been
  144. // loaded and the object image index has not been
  145. // stored.
  146. //
  147. // Load the bitmap for the non-selected light
  148. bitmap.LoadBitmap(IDB_OBJECT_LATHE);
  149. m_iBMImage = pList->Add(&bitmap, (COLORREF)0xFFFFFF);
  150. bitmap.DeleteObject();
  152. // Load the bitmap for the non-selected light
  153. bitmap.LoadBitmap(IDB_OBJECT_LATHE_SELECTED);
  154. pList->Add(&bitmap, (COLORREF)0xFFFFFF);
  155. bitmap.DeleteObject();
  157. iObjectPlaneBMImage = m_iBMImage;
  159. return m_iBMImage;
  160. }
  162. void C3dObjectLathe::Serialize(CArchive& ar, int iVersion)
  163. {
  164. CString szBuffer;
  166. if (ar.IsStoring())
  167. {
  168. // Save the Object Class header...
  169. szBuffer.Format("n%sC3dObjectLathe {n", szIndent);
  170. ar.WriteString(szBuffer);
  172. // Save the this objects' specific data...
  173. szBuffer.Format("%stSweepAngle    < %f >n", szIndent, m_fSweepAngle);
  174. ar.WriteString(szBuffer);
  175. szBuffer.Format("%stSegments      < %d >n", szIndent, m_iSegments);
  176. ar.WriteString(szBuffer);
  177. szBuffer.Format("%stNum Points    < %d >n", szIndent, m_pPointArray->m_iNumPoints);
  178. ar.WriteString(szBuffer);
  179. for(int i=0; i<m_pPointArray->m_iNumPoints; i++)
  180. {
  181. szBuffer.Format("%stt        < %f, %f, %f >n", szIndent, m_pPointArray->m_pPoints[i].m_fOrigin[0],
  182. m_pPointArray->m_pPoints[i].m_fOrigin[1],
  183. m_pPointArray->m_pPoints[i].m_fOrigin[2]);
  184. ar.WriteString(szBuffer);
  185. }
  186. szBuffer.Format("%stSmooth Faces  < %d >n", szIndent, m_bSmooth);
  187. ar.WriteString(szBuffer);
  188. szBuffer.Format("%stMax Angle     < %f >n", szIndent, m_fMaxAngle);
  189. ar.WriteString(szBuffer);
  191. // Save the base class object data...
  192. C3dObject::Serialize(ar, iVersion);
  194. szBuffer.Format("%s}n", szIndent); // end of object def
  195. ar.WriteString(szBuffer);
  196. }
  197. else
  198. {
  199. if(iVersion < 102)
  200. // Read the base class object data...
  201. C3dObject::Serialize(ar, iVersion);
  203. // Read the derived class data..
  204. ar.ReadString(szBuffer);
  205. szBuffer.TrimLeft(); // Remove leading white spaces
  206. sscanf(szBuffer, "SweepAngle    < %f >n", &m_fSweepAngle);
  207. ar.ReadString(szBuffer);
  208. szBuffer.TrimLeft();
  209. sscanf(szBuffer, "Segments      < %d >n", &m_iSegments);
  210. ar.ReadString(szBuffer);
  211. szBuffer.TrimLeft();
  212. sscanf(szBuffer, "Num Points    < %d >n", &m_pPointArray->m_iNumPoints);
  214. // Create the array of points
  215. if(!m_pPointArray->Create(m_pPointArray->m_iNumPoints))
  216. {
  217. // Now that the points array has been created,
  218. // read the point data.
  219. for(int i=0; i<m_pPointArray->m_iNumPoints; i++)
  220. {
  221. ar.ReadString(szBuffer);
  222. szBuffer.TrimLeft();
  223. sscanf(szBuffer, "< %f, %f, %f >n", &m_pPointArray->m_pPoints[i].m_fOrigin[0],
  224.  &m_pPointArray->m_pPoints[i].m_fOrigin[1],
  225.  &m_pPointArray->m_pPoints[i].m_fOrigin[2]);
  226. }
  227. }
  228. ar.ReadString(szBuffer);
  229. szBuffer.TrimLeft();
  230. sscanf(szBuffer, "Smooth Faces  < %d >n", &m_bSmooth);
  231. ar.ReadString(szBuffer);
  232. szBuffer.TrimLeft();
  233. sscanf(szBuffer, "Max Angle     < %f >n", &m_fMaxAngle);
  235. if(iVersion < 102)
  236. // Read all child objects...
  237. LoadChildObjects(ar, iVersion);
  238. else
  239. // Read the base class object data...
  240. C3dObject::Serialize(ar, iVersion);
  241. }
  242. }
  244. void C3dObjectLathe::Build(C3dWorld* pWorld, C3dCamera* pCamera)
  245. {
  246. GLfloat Theta, DTheta, HalfDTheta;
  247. GLfloat CosThetaMinus, SinThetaMinus;
  248. GLfloat CosThetaPlus, SinThetaPlus;
  249. LatheFace Vertice, Normal;
  250. GLfloat s, t;  // Texture coordinates
  251. int i, j, k;
  254. // Our angles used to define vertices
  255. DTheta=m_fSweepAngle/m_iSegments;
  256. HalfDTheta=DTheta/2;
  257. Theta=HalfDTheta;
  259. s = (1/(m_fSweepAngle/DTheta));
  260. t = (1/(GLfloat)(m_pPointArray->m_iNumPoints-1));
  262. j =  0;
  264. glNewList(m_iDisplayLists, GL_COMPILE_AND_EXECUTE);
  265.  
  266. do {
  267. i=0;
  268. k=m_pPointArray->m_iNumPoints-1;
  270. // Calcualte arc angles used to calcualte our
  271. // planes vertices
  272. CosThetaMinus=Cosf(Theta-HalfDTheta);
  273. SinThetaMinus=Sinf(Theta-HalfDTheta);
  274. CosThetaPlus=Cosf(Theta+HalfDTheta);
  275. SinThetaPlus=Sinf(Theta+HalfDTheta);
  277. do {
  279. // Calculate the plane vertices rotated about the Y-axis
  280. Vertice[0][X]=CosThetaPlus*m_pPointArray->m_pPoints[i].m_fOrigin[0];
  281. Vertice[0][Y]=SinThetaPlus*m_pPointArray->m_pPoints[i].m_fOrigin[0];
  282. Vertice[0][Z]=m_pPointArray->m_pPoints[i].m_fOrigin[2];
  284. Vertice[1][X]=CosThetaMinus*m_pPointArray->m_pPoints[i].m_fOrigin[0];
  285. Vertice[1][Y]=SinThetaMinus*m_pPointArray->m_pPoints[i].m_fOrigin[0];
  286. Vertice[1][Z]=m_pPointArray->m_pPoints[i].m_fOrigin[2];
  288. Vertice[2][X]=CosThetaMinus*m_pPointArray->m_pPoints[i+1].m_fOrigin[0];
  289. Vertice[2][Y]=SinThetaMinus*m_pPointArray->m_pPoints[i+1].m_fOrigin[0];
  290. Vertice[2][Z]=m_pPointArray->m_pPoints[i+1].m_fOrigin[2];
  292. Vertice[3][X]=CosThetaPlus*m_pPointArray->m_pPoints[i+1].m_fOrigin[0];
  293. Vertice[3][Y]=SinThetaPlus*m_pPointArray->m_pPoints[i+1].m_fOrigin[0];
  294. Vertice[3][Z]=m_pPointArray->m_pPoints[i+1].m_fOrigin[2];
  296. // Calculate the surface normals for each
  297. // of our lathe face vertices.
  298. if(m_bSmooth)
  299. CalSmoothNormals(Vertice, i, Theta, Normal);
  300. else
  301. CalNormals(Vertice, Normal);
  304. glBegin(GL_TRIANGLES);
  306. glNormal3f(Normal[0][X], Normal[0][Y], Normal[0][Z]);
  307. glTexCoord2f(s*(j+1), t*(k));
  308. glVertex3d(Vertice[0][X], Vertice[0][Y], Vertice[0][Z]);
  310. glNormal3f(Normal[1][X], Normal[1][Y], Normal[1][Z]);
  311. glTexCoord2f(s*(j), t*(k));
  312. glVertex3d(Vertice[1][X], Vertice[1][Y], Vertice[1][Z]);
  314. glNormal3f(Normal[2][X], Normal[2][Y], Normal[2][Z]);
  315. glTexCoord2f(s*(j), t*(k-1));
  316. glVertex3d(Vertice[2][X], Vertice[2][Y], Vertice[2][Z]);
  318. glTexCoord2f(s*(j), t*(k-1));
  319. glVertex3d(Vertice[2][X], Vertice[2][Y], Vertice[2][Z]);
  321. glNormal3f(Normal[3][X], Normal[3][Y], Normal[3][Z]);
  322. glTexCoord2f(s*(j+1), t*(k-1));
  323. glVertex3d(Vertice[3][X], Vertice[3][Y], Vertice[3][Z]);
  325. glNormal3f(Normal[0][X], Normal[0][Y], Normal[0][Z]);
  326. glTexCoord2f(s*(j+1), t*(k));
  327. glVertex3d(Vertice[0][X], Vertice[0][Y], Vertice[0][Z]);
  329. glEnd();
  331. ++i; // Increment face
  332. --k; // Decrement face
  334. } while(i<m_pPointArray->m_iNumPoints-1);
  336. Theta+=DTheta;
  337. ++j; // Increment segment
  339. } while(Theta<(m_fSweepAngle));
  341. glEndList();
  342. }
  346. /////////////////////////////////////////////////////////////////////////////
  347. // C3dObjectLathe function implimentation
  349. void C3dObjectLathe::CalNormals(LatheFace Vertice, LatheFace Normal)
  350. {
  351. VECTORF u, v;
  354. // Calculate the surface normals for the lathe face
  355. VecSubf(Vertice[3], Vertice[0], u);
  356. VecSubf(Vertice[1], Vertice[0], v);
  357. if(!VecLenf(v))
  358. VecSubf(Vertice[2], Vertice[0], v);
  359. VecCrossf(v, u, Normal[0]);
  360. VecNormalizef(Normal[0]);
  362. VecSubf(Vertice[0], Vertice[1], u);
  363. if(!VecLenf(u))
  364. VecSubf(Vertice[3], Vertice[1], u);
  365. VecSubf(Vertice[2], Vertice[1], v);
  366. VecCrossf(v, u, Normal[1]);
  367. VecNormalizef(Normal[1]);
  369. VecSubf(Vertice[1], Vertice[2], u);
  370. VecSubf(Vertice[3], Vertice[2], v);
  371. if(!VecLenf(v))
  372. VecSubf(Vertice[0], Vertice[2], v);
  373. VecCrossf(v, u, Normal[2]);
  374. VecNormalizef(Normal[2]);
  376. VecSubf(Vertice[2], Vertice[3], u);
  377. if(!VecLenf(u))
  378. VecSubf(Vertice[1], Vertice[3], u);
  379. VecSubf(Vertice[0], Vertice[3], v);
  380. VecCrossf(v, u, Normal[3]);
  381. VecNormalizef(Normal[3]);
  382. }
  384. void C3dObjectLathe::CalSmoothNormals(LatheFace Vertice, int iFace, float fTheta, LatheFace Normal)
  385. {
  386. // This routine calcualtes the surface normal as
  387. // an average of it's surrounding normals as long
  388. // as the angle between adjacent normals is
  389. // within the member variable m_fMaxAngle.
  390. //
  391. //            <Padj 1>     <Padj 0>  
  392. //
  393. //                _____________
  394. // <Padj 2>   P1 |            /| P0    <Padj 7>
  395. //               |          /  |
  396. //               |        /    |
  397. //               |      /      |
  398. //               |    /        |     
  399. //               |  /          |     
  400. // <Padj 3>   P2 |/____________| P3    <Padj 6> 
  401. //
  402. //
  403. //            <Padj 4>     <Padj 5>  
  404. //
  405. GLfloat DTheta, HalfDTheta;
  406. GLfloat CosThetaMinus, SinThetaMinus;
  407. GLfloat CosThetaPlus, SinThetaPlus;
  408. GLfloat CosThetaMinusMinus, SinThetaMinusMinus;
  409. GLfloat CosThetaPlusPlus, SinThetaPlusPlus;
  410. GLfloat fAngle;
  411. VECTORF AdjVertice[8];
  412. VECTORF u, v;
  413. VECTORF AdjNormal;
  414. VECTORF AveNormal;
  415. int iNumAveNormals;
  418. // Our angles used to define vertices
  419. DTheta=m_fSweepAngle/m_iSegments;
  420. HalfDTheta=DTheta/2;
  422. // Arc angles used to calcualte this 
  423. // planes vertices
  424. CosThetaMinus=Cosf(fTheta-HalfDTheta);
  425. SinThetaMinus=Sinf(fTheta-HalfDTheta);
  426. CosThetaPlus=Cosf(fTheta+HalfDTheta);
  427. SinThetaPlus=Sinf(fTheta+HalfDTheta);
  429. // Arc angles used to calcualte our
  430. // planes adjacent vertices
  431. CosThetaMinusMinus=Cosf((fTheta-DTheta)-HalfDTheta);
  432. SinThetaMinusMinus=Sinf((fTheta-DTheta)-HalfDTheta);
  433. CosThetaPlusPlus=Cosf((fTheta+DTheta)+HalfDTheta);
  434. SinThetaPlusPlus=Sinf((fTheta+DTheta)+HalfDTheta);
  436. if(iFace) {
  437. // Calculate the previous planes vertices
  438. AdjVertice[0][X]=CosThetaPlus*m_pPointArray->m_pPoints[iFace-1].m_fOrigin[0];
  439. AdjVertice[0][Y]=SinThetaPlus*m_pPointArray->m_pPoints[iFace-1].m_fOrigin[0];
  440. AdjVertice[0][Z]=m_pPointArray->m_pPoints[iFace-1].m_fOrigin[2];
  442. AdjVertice[1][X]=CosThetaMinus*m_pPointArray->m_pPoints[iFace-1].m_fOrigin[0];
  443. AdjVertice[1][Y]=SinThetaMinus*m_pPointArray->m_pPoints[iFace-1].m_fOrigin[0];
  444. AdjVertice[1][Z]=m_pPointArray->m_pPoints[iFace-1].m_fOrigin[2];
  445. }
  447. // Calculate the left planes vertices
  448. AdjVertice[2][X]=CosThetaMinusMinus*m_pPointArray->m_pPoints[iFace].m_fOrigin[0];
  449. AdjVertice[2][Y]=SinThetaMinusMinus*m_pPointArray->m_pPoints[iFace].m_fOrigin[0];
  450. AdjVertice[2][Z]=m_pPointArray->m_pPoints[iFace].m_fOrigin[2];
  452. AdjVertice[3][X]=CosThetaMinusMinus*m_pPointArray->m_pPoints[iFace+1].m_fOrigin[0];
  453. AdjVertice[3][Y]=SinThetaMinusMinus*m_pPointArray->m_pPoints[iFace+1].m_fOrigin[0];
  454. AdjVertice[3][Z]=m_pPointArray->m_pPoints[iFace+1].m_fOrigin[2];
  456. if(iFace<(m_pPointArray->m_iNumPoints-1)) {
  457. // Calculate the next planes vertices
  458. AdjVertice[4][X]=CosThetaMinus*m_pPointArray->m_pPoints[iFace+2].m_fOrigin[0];
  459. AdjVertice[4][Y]=SinThetaMinus*m_pPointArray->m_pPoints[iFace+2].m_fOrigin[0];
  460. AdjVertice[4][Z]=m_pPointArray->m_pPoints[iFace+2].m_fOrigin[2];
  462. AdjVertice[5][X]=CosThetaPlus*m_pPointArray->m_pPoints[iFace+2].m_fOrigin[0];
  463. AdjVertice[5][Y]=SinThetaPlus*m_pPointArray->m_pPoints[iFace+2].m_fOrigin[0];
  464. AdjVertice[5][Z]=m_pPointArray->m_pPoints[iFace+2].m_fOrigin[2];
  465. }
  467. // Calculate the right planes vertices
  468. AdjVertice[6][X]=CosThetaPlusPlus*m_pPointArray->m_pPoints[iFace+1].m_fOrigin[0];
  469. AdjVertice[6][Y]=SinThetaPlusPlus*m_pPointArray->m_pPoints[iFace+1].m_fOrigin[0];
  470. AdjVertice[6][Z]=m_pPointArray->m_pPoints[iFace+1].m_fOrigin[2];
  472. AdjVertice[7][X]=CosThetaPlusPlus*m_pPointArray->m_pPoints[iFace].m_fOrigin[0];
  473. AdjVertice[7][Y]=SinThetaPlusPlus*m_pPointArray->m_pPoints[iFace].m_fOrigin[0];
  474. AdjVertice[7][Z]=m_pPointArray->m_pPoints[iFace].m_fOrigin[2];
  477. // Now that we have the adjacent face vertices, 
  478. // calculate the average surface normal for each
  479. // face vertice..
  481. ///////////////////////////////////////////////////
  482. // Face Vertice '0' average surface normal:
  483. iNumAveNormals = 0;
  485. VecSubf(Vertice[3], Vertice[0], u);
  486. VecSubf(Vertice[1], Vertice[0], v);
  487. if(!VecLenf(v))
  488. VecSubf(Vertice[2], Vertice[0], v);
  489. VecCrossf(v, u, Normal[0]);
  490. VecCopy3f(Normal[0], AveNormal);
  491. ++iNumAveNormals;
  493. if(iFace) {
  494. VecSubf(Vertice[1], Vertice[0], u);
  495. VecSubf(AdjVertice[0], Vertice[0], v);
  496. VecCrossf(v, u, AdjNormal);
  498. // Calculate angle between the Normal vectors
  499. // where:
  500. // u.v = u1v1 + u2v2 + u3v3
  501. // u.v = |u||v|cos theta
  502. // theta = inv cos(u.v/|u||v|)
  503. //
  504. fAngle = Degreesf( acos( (VecDotf(Normal[0], AdjNormal)) / (VecLenf(Normal[0])*VecLenf(AdjNormal)) ));
  505. if(fAngle <= m_fMaxAngle) {
  506. VecAddf(AveNormal, AdjNormal, AveNormal);
  507. ++iNumAveNormals;
  508. }
  510. VecSubf(AdjVertice[0], Vertice[0], u);
  511. VecSubf(AdjVertice[7], Vertice[0], v);
  512. VecCrossf(v, u, AdjNormal);
  514. // Calculate angle between the Normal vectors
  515. fAngle = Degreesf( acos( (VecDotf(Normal[0], AdjNormal)) / (VecLenf(Normal[0])*VecLenf(AdjNormal)) ));
  516. if(fAngle <= m_fMaxAngle) {
  517. VecAddf(AveNormal, AdjNormal, AveNormal);
  518. ++iNumAveNormals;
  519. }
  520. }
  522. VecSubf(AdjVertice[7], Vertice[0], u);
  523. VecSubf(Vertice[3], Vertice[0], v);
  524. VecCrossf(v, u, AdjNormal);
  526. // Calculate angle between the Normal vectors
  527. fAngle = Degreesf( acos( (VecDotf(Normal[0], AdjNormal)) / (VecLenf(Normal[0])*VecLenf(AdjNormal)) ));
  528. if(fAngle <= m_fMaxAngle) {
  529. VecAddf(AveNormal, AdjNormal, AveNormal);
  530. ++iNumAveNormals;
  531. }
  533. // Calculate the average surface normal for face
  534. // vertice '0'
  535. Normal[0][X] = AveNormal[X]/iNumAveNormals;
  536. Normal[0][Y] = AveNormal[Y]/iNumAveNormals;
  537. Normal[0][Z] = AveNormal[Z]/iNumAveNormals;
  538. VecNormalizef(Normal[0]);
  542. ///////////////////////////////////////////////////
  543. // Face Vertice '1' average surface normal:
  544. iNumAveNormals = 0;
  546. VecSubf(Vertice[0], Vertice[1], u);
  547. if(!VecLenf(u))
  548. VecSubf(Vertice[3], Vertice[1], u);
  549. VecSubf(Vertice[2], Vertice[1], v);
  550. VecCrossf(v, u, Normal[1]);
  551. VecCopy3f(Normal[1], AveNormal);
  552. ++iNumAveNormals;
  554. if(iFace) {
  555. VecSubf(AdjVertice[1], Vertice[1], u);
  556. VecSubf(Vertice[0], Vertice[1], v);
  557. VecCrossf(v, u, AdjNormal);
  559. // Calculate angle between the Normal vectors
  560. // where:
  561. // u.v = u1v1 + u2v2 + u3v3
  562. // u.v = |u||v|cos theta
  563. // theta = inv cos(u.v/|u||v|)
  564. //
  565. fAngle = Degreesf( acos( (VecDotf(Normal[1], AdjNormal)) / (VecLenf(Normal[1])*VecLenf(AdjNormal)) ));
  566. if(fAngle <= m_fMaxAngle) {
  567. VecAddf(AveNormal, AdjNormal, AveNormal);
  568. ++iNumAveNormals;
  569. }
  571. VecSubf(AdjVertice[2], Vertice[1], u);
  572. VecSubf(AdjVertice[1], Vertice[1], v);
  573. VecCrossf(v, u, AdjNormal);
  575. // Calculate angle between the Normal vectors
  576. fAngle = Degreesf( acos( (VecDotf(Normal[1], AdjNormal)) / (VecLenf(Normal[1])*VecLenf(AdjNormal)) ));
  577. if(fAngle <= m_fMaxAngle) {
  578. VecAddf(AveNormal, AdjNormal, AveNormal);
  579. ++iNumAveNormals;
  580. }
  581. }
  583. VecSubf(Vertice[2], Vertice[1], u);
  584. VecSubf(AdjVertice[2], Vertice[1], v);
  585. VecCrossf(v, u, AdjNormal);
  587. // Calculate angle between the Normal vectors
  588. fAngle = Degreesf( acos( (VecDotf(Normal[1], AdjNormal)) / (VecLenf(Normal[1])*VecLenf(AdjNormal)) ));
  589. if(fAngle <= m_fMaxAngle) {
  590. VecAddf(AveNormal, AdjNormal, AveNormal);
  591. ++iNumAveNormals;
  592. }
  594. // Calculate the average surface normal for face
  595. // vertice '1'
  596. Normal[1][X] = AveNormal[X]/iNumAveNormals;
  597. Normal[1][Y] = AveNormal[Y]/iNumAveNormals;
  598. Normal[1][Z] = AveNormal[Z]/iNumAveNormals;
  599. VecNormalizef(Normal[1]);
  603. ///////////////////////////////////////////////////
  604. // Face Vertice '2' average surface normal:
  605. iNumAveNormals = 0;
  607. VecSubf(Vertice[1], Vertice[2], u);
  608. VecSubf(Vertice[3], Vertice[2], v);
  609. if(!VecLenf(v))
  610. VecSubf(Vertice[0], Vertice[2], v);
  611. VecCrossf(v, u, Normal[2]);
  612. VecCopy3f(Normal[2], AveNormal);
  613. ++iNumAveNormals;
  615. if(iFace<(m_pPointArray->m_iNumPoints-1)) {
  616. VecSubf(AdjVertice[4], Vertice[2], u);
  617. VecSubf(AdjVertice[3], Vertice[2], v);
  618. VecCrossf(v, u, AdjNormal);
  620. // Calculate angle between the Normal vectors
  621. // where:
  622. // u.v = u1v1 + u2v2 + u3v3
  623. // u.v = |u||v|cos theta
  624. // theta = inv cos(u.v/|u||v|)
  625. //
  626. fAngle = Degreesf( acos( (VecDotf(Normal[2], AdjNormal)) / (VecLenf(Normal[2])*VecLenf(AdjNormal)) ));
  627. if(fAngle <= m_fMaxAngle) {
  628. VecAddf(AveNormal, AdjNormal, AveNormal);
  629. ++iNumAveNormals;
  630. }
  632. VecSubf(Vertice[3], Vertice[2], u);
  633. VecSubf(AdjVertice[4], Vertice[2], v);
  634. VecCrossf(v, u, AdjNormal);
  636. // Calculate angle between the Normal vectors
  637. fAngle = Degreesf( acos( (VecDotf(Normal[2], AdjNormal)) / (VecLenf(Normal[2])*VecLenf(AdjNormal)) ));
  638. if(fAngle <= m_fMaxAngle) {
  639. VecAddf(AveNormal, AdjNormal, AveNormal);
  640. ++iNumAveNormals;
  641. }
  642. }
  644. VecSubf(AdjVertice[3], Vertice[2], u);
  645. VecSubf(Vertice[1], Vertice[2], v);
  646. VecCrossf(v, u, AdjNormal);
  648. // Calculate angle between the Normal vectors
  649. fAngle = Degreesf( acos( (VecDotf(Normal[2], AdjNormal)) / (VecLenf(Normal[2])*VecLenf(AdjNormal)) ));
  650. if(fAngle <= m_fMaxAngle) {
  651. VecAddf(AveNormal, AdjNormal, AveNormal);
  652. ++iNumAveNormals;
  653. }
  655. // Calculate the average surface normal for face
  656. // vertice '2'
  657. Normal[2][X] = AveNormal[X]/iNumAveNormals;
  658. Normal[2][Y] = AveNormal[Y]/iNumAveNormals;
  659. Normal[2][Z] = AveNormal[Z]/iNumAveNormals;
  660. VecNormalizef(Normal[2]);
  664. ///////////////////////////////////////////////////
  665. // Face Vertice '3' average surface normal:
  666. iNumAveNormals = 0;
  668. VecSubf(Vertice[2], Vertice[3], u);
  669. if(!VecLenf(u))
  670. VecSubf(Vertice[1], Vertice[3], u);
  671. VecSubf(Vertice[0], Vertice[3], v);
  672. VecCrossf(v, u, Normal[3]);
  673. VecCopy3f(Normal[3], AveNormal);
  674. ++iNumAveNormals;
  676. if(iFace<(m_pPointArray->m_iNumPoints-1)) {
  677. VecSubf(AdjVertice[6], Vertice[3], u);
  678. VecSubf(AdjVertice[5], Vertice[3], v);
  679. VecCrossf(v, u, AdjNormal);
  681. // Calculate angle between the Normal vectors
  682. // where:
  683. // u.v = u1v1 + u2v2 + u3v3
  684. // u.v = |u||v|cos theta
  685. // theta = inv cos(u.v/|u||v|)
  686. //
  687. fAngle = Degreesf( acos( (VecDotf(Normal[3], AdjNormal)) / (VecLenf(Normal[3])*VecLenf(AdjNormal)) ));
  688. if(fAngle <= m_fMaxAngle) {
  689. VecAddf(AveNormal, AdjNormal, AveNormal);
  690. ++iNumAveNormals;
  691. }
  693. VecSubf(AdjVertice[5], Vertice[3], u);
  694. VecSubf(Vertice[2], Vertice[3], v);
  695. VecCrossf(v, u, AdjNormal);
  697. // Calculate angle between the Normal vectors
  698. fAngle = Degreesf( acos( (VecDotf(Normal[3], AdjNormal)) / (VecLenf(Normal[3])*VecLenf(AdjNormal)) ));
  699. if(fAngle <= m_fMaxAngle) {
  700. VecAddf(AveNormal, AdjNormal, AveNormal);
  701. ++iNumAveNormals;
  702. }
  703. }
  705. VecSubf(Vertice[0], Vertice[3], u);
  706. VecSubf(AdjVertice[6], Vertice[3], v);
  707. VecCrossf(v, u, AdjNormal);
  709. // Calculate angle between the Normal vectors
  710. fAngle = Degreesf( acos( (VecDotf(Normal[3], AdjNormal)) / (VecLenf(Normal[3])*VecLenf(AdjNormal)) ));
  711. if(fAngle <= m_fMaxAngle) {
  712. VecAddf(AveNormal, AdjNormal, AveNormal);
  713. ++iNumAveNormals;
  714. }
  716. // Calculate the average surface normal for face
  717. // vertice '3'
  718. Normal[3][X] = AveNormal[X]/iNumAveNormals;
  719. Normal[3][Y] = AveNormal[Y]/iNumAveNormals;
  720. Normal[3][Z] = AveNormal[Z]/iNumAveNormals;
  721. VecNormalizef(Normal[3]);
  722. }