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

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

OpenGL

开发平台：

Visual C++

3dObjectTerrain.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////////
  2. // 3dObjectTerrain.cpp : implementation file
  3. //
  4. // glOOP (OpenGL Object Oriented Programming library)
  5. // Copyright (c) Craig Fahrnbach, ImageWare Development, 1997-1999
  6. // All rights reserved.
  7. //
  8. // OpenGL is a registered trademark of Silicon Graphics
  9. //
  10. //
  11. // This program is provided for educational and personal use only and
  12. // is provided without guarantee or warrantee expressed or implied.
  13. //
  14. // Commercial use is strickly prohibited without written permission
  15. // from ImageWare Development.
  16. //
  17. // This program is -not- in the public domain.
  18. //
  19. // Adapted from source code, with permission, by: Paul E. Martz
  20. /////////////////////////////////////////////////////////////////////////////
  22. #include "stdafx.h"
  23. #include "glOOP.h"
  24. #include "3dObjectDialog.h"
  25. #include <math.h>
  27. #ifdef _DEBUG
  28. #define new DEBUG_NEW
  29. #undef THIS_FILE
  30. static char THIS_FILE[] = __FILE__;
  31. #endif
  34. //////////////////////////////////////////////////////////////////
  35. // C3dObjectTerrain
  37. IMPLEMENT_DYNAMIC(C3dObjectTerrain, C3dObject)
  40. /////////////////////////////////////////////////////////////////////////////
  41. // C3dShape construction
  43. C3dObjectTerrain::C3dObjectTerrain()
  44. {
  45. // Set the attributes to default values..
  46.   m_iType = SHAPE_OBJECT;
  47.    m_szName.Format("Terrain %u", nTerrainObjects++);
  49. m_bSolidColor = FALSE;
  50. m_bSmoothNormals = TRUE;
  51. m_bReflect = FALSE;
  52. m_bMapTexturesToSubGrid = FALSE;
  53. m_bApplySubGridTextures = FALSE;
  55. m_pTextureSnow  = NULL;
  56. m_pTextureRock  = NULL;
  57. m_pTextureGrass = NULL;
  58. m_pTextureWater = NULL;
  60. m_iSize = 32;
  61. m_iTile = 1;
  62. m_fDepth = 50.0f;
  63. m_fWidth = 50.0f;
  64. m_fHeight =  1.1f;
  65. m_iHeightSeed = 0;
  66. m_fSeaLevel = 0.3f;
  68. m_iTerrainGridDisplayList = 0;
  70. m_iTexImageMap = 0;
  72. m_ColorSnow.SetColor4f(.95f, .95f, 1.f, 0.f); // White
  73. m_ColorRock.SetColor4f(.55f, .55f, .6f, 0.f); // Gray
  74. m_ColorGrass.SetColor4f(.2f, .4f, .2f, 0.f); // Green
  75. m_ColorWater.SetColor4f(.0f, .25f, .85f, 0.f); // Blue
  77. // Create our C3dPointArray object
  78. m_pPointArray = new C3dPointArray;
  79. ASSERT(m_pPointArray);
  81. // Create an array of points for our vertices
  82. if(m_pPointArray->Create((m_iSize+1)*(m_iSize+1)))
  83. {
  84. AfxMessageBox("Not enough memory to create array points!", MB_OK);
  85. m_pPointArray = NULL;
  86. return;
  87. }
  89. // Initialize our terrain vertices (points)
  90. InitTerrain();
  91. }
  94. /////////////////////////////////////////////////////////////////////////////
  95. // C3DWorld Destructor
  97. C3dObjectTerrain::~C3dObjectTerrain()
  98. {
  99. // Delete our point array
  100. if(m_pPointArray)
  101. delete m_pPointArray;
  103. // Delete our texture maps
  104. if(m_pTextureSnow)
  105. DeleteSubTexture(m_pTextureSnow);
  106. if(m_pTextureRock)
  107. DeleteSubTexture(m_pTextureRock);
  108. if(m_pTextureGrass)
  109. DeleteSubTexture(m_pTextureGrass);
  110. if(m_pTextureWater)
  111. DeleteSubTexture(m_pTextureWater);
  114. // Delete the Terrain Grid DisplayList
  115. if(m_iTerrainGridDisplayList)
  116. {
  117. glDeleteLists(m_iTerrainGridDisplayList, 1);
  118. m_iTerrainGridDisplayList = 0;
  119. }
  120. // Delete the Terrain Image Texturemap
  121. if(m_iTexImageMap)
  122. {
  123. glDeleteLists(m_iTexImageMap, 1);
  124. m_iTexImageMap = 0;
  125. }
  126. }
  129. /////////////////////////////////////////////////////////////////////////////
  130. // C3dObjectTerrain Methods or virtual function implimentation
  132. void C3dObjectTerrain::AddAttributePage(C3dWorld* pWorld, LPVOID pSht)
  133. {
  134. C3dObjectPropSheet* pSheet = (C3dObjectPropSheet*)pSht;
  135. ASSERT(pSheet);
  137. // Add the page to the property sheet
  138. pSheet->AddPage(&pSheet->m_TerrainPage);
  139. // Save the address of this object in the page
  140. pSheet->m_TerrainPage.m_pObject = this;
  142. // Add the page to the property sheet
  143. pSheet->AddPage(&pSheet->m_TerrainColorPage);
  144. // Save the address of this object in the page
  145. pSheet->m_TerrainColorPage.m_pObject = this;
  146. pSheet->m_TerrainColorPage.m_pWorld = pWorld;
  148. // Add the page to the property sheet
  149. pSheet->AddPage(&pSheet->m_TerrainTexturePage);
  150. // Save the address of this object in the page
  151. pSheet->m_TerrainTexturePage.m_pObject = this;
  152. }
  154. int C3dObjectTerrain::LoadBitMapImage(CImageList* pList)
  155. {
  156. CBitmap bitmap;
  158. // If the image index has been stored in this object,
  159. // return the index.
  160. if(m_iBMImage > -1)
  161. return m_iBMImage;
  163. // If the image index for this object type has been
  164. // created, store the index for this object and
  165. // return the index.
  166. if( iObjectTerrainBMImage > -1) {
  167. m_iBMImage = iObjectTerrainBMImage;
  168. return m_iBMImage;
  169. }
  171. // The image index for this object type has not been
  172. // loaded and the object image index has not been
  173. // stored.
  174. //
  175. // Load the bitmap for the non-selected object
  176. bitmap.LoadBitmap(IDB_OBJECT_TERRAIN);
  177. m_iBMImage = pList->Add(&bitmap, (COLORREF)0xFFFFFF);
  178. bitmap.DeleteObject();
  180. // Load the bitmap for the non-selected object
  181. bitmap.LoadBitmap(IDB_OBJECT_TERRAIN_SELECTED);
  182. pList->Add(&bitmap, (COLORREF)0xFFFFFF);
  183. bitmap.DeleteObject();
  185. iObjectTerrainBMImage = m_iBMImage;
  187. return m_iBMImage;
  188. }
  190. void C3dObjectTerrain::GetShapeBounds(C3dBoundingBox* pBox)
  191. {
  192. if(m_pPointArray)
  193. m_pPointArray->GetMinMax(pBox);
  195. // We need to calculate the overall size of the object based
  196. // on the number of times we have tiled the basic shape
  197. pBox->m_fMax[X] *= m_iTile;
  198. pBox->m_fMax[Y] *= m_iTile;
  199. pBox->m_fMin[X] *= m_iTile;
  200. pBox->m_fMin[Y] *= m_iTile;
  201. }
  203. void C3dObjectTerrain::Serialize(CArchive& ar, int iVersion)
  204. {
  205. CString szBuffer;
  207. if (ar.IsStoring())
  208. {
  209. // Save the Object Class header...
  210. szBuffer.Format("n%sC3dObjectTerrain {n", szIndent);
  211. ar.WriteString(szBuffer);
  213. // Save the this objects' specific data...
  214. szBuffer.Format("%stDepth         < %f >n", szIndent, m_fDepth);
  215. ar.WriteString(szBuffer);
  216. szBuffer.Format("%stWidth         < %f >n", szIndent, m_fWidth);
  217. ar.WriteString(szBuffer);
  218. szBuffer.Format("%stHeight        < %f >n", szIndent, m_fHeight);
  219. ar.WriteString(szBuffer);
  220. szBuffer.Format("%stHeight Seed   < %d >n", szIndent, m_iHeightSeed);
  221. ar.WriteString(szBuffer);
  222. szBuffer.Format("%stTile          < %d >n", szIndent, m_iTile);
  223. ar.WriteString(szBuffer);
  224. szBuffer.Format("%stReflectLight  < %d >n", szIndent, m_bReflect);
  225. ar.WriteString(szBuffer);
  226. szBuffer.Format("%stArraySize     < %d >n", szIndent, m_iSize);
  227. ar.WriteString(szBuffer);
  229. szBuffer.Format("%stSolid Color   < %d >n", szIndent, m_bSolidColor);
  230. ar.WriteString(szBuffer);
  231. szBuffer.Format("%stNum Points    < %d >n", szIndent, m_pPointArray->m_iNumPoints);
  232. ar.WriteString(szBuffer);
  233. for(int i=0; i<m_pPointArray->m_iNumPoints; i++)
  234. {
  235. szBuffer.Format("%stt        < %f, %f, %f >n", szIndent, m_pPointArray->m_pPoints[i].m_fOrigin[0],
  236. m_pPointArray->m_pPoints[i].m_fOrigin[1],
  237. m_pPointArray->m_pPoints[i].m_fOrigin[2]);
  238. ar.WriteString(szBuffer);
  239. }
  240. if(!m_bSolidColor)
  241. {
  242. szBuffer.Format("%st[color]n", szIndent);
  243. ar.WriteString(szBuffer);
  244. for(int i=0; i<m_pPointArray->m_iNumPoints; i++)
  245. {
  246. szBuffer.Format("%stt        < %f, %f, %f, %f >n", szIndent, m_pPointArray->m_pPoints[i].m_Color.m_fColor[0],
  247. m_pPointArray->m_pPoints[i].m_Color.m_fColor[1],
  248. m_pPointArray->m_pPoints[i].m_Color.m_fColor[2],
  249. m_pPointArray->m_pPoints[i].m_Color.m_fColor[3]);
  250. ar.WriteString(szBuffer);
  251. }
  252. }
  253. // Save the base class object data...
  254. C3dObject::Serialize(ar, iVersion);
  256. szBuffer.Format("%s}n", szIndent); // end of object def
  257. ar.WriteString(szBuffer);
  258. }
  259. else
  260. {
  261. ar.ReadString(szBuffer);
  262. szBuffer.TrimLeft(); // Remove leading white spaces
  263. sscanf(szBuffer, "Depth         < %f >n", &m_fDepth);
  264. ar.ReadString(szBuffer);
  265. szBuffer.TrimLeft();
  266. sscanf(szBuffer, "Width         < %f >n", &m_fWidth);
  267. ar.ReadString(szBuffer);
  268. szBuffer.TrimLeft();
  269. sscanf(szBuffer, "Height        < %f >n", &m_fHeight);
  270. ar.ReadString(szBuffer);
  271. szBuffer.TrimLeft();
  272. sscanf(szBuffer, "Height Seed   < %d >n", &m_iHeightSeed);
  273. ar.ReadString(szBuffer);
  274. szBuffer.TrimLeft();
  275. sscanf(szBuffer, "Tile          < %d >n", &m_iTile);
  276. ar.ReadString(szBuffer);
  277. szBuffer.TrimLeft();
  278. sscanf(szBuffer, "ReflectLight  < %d >n", &m_bReflect);
  279. ar.ReadString(szBuffer);
  280. szBuffer.TrimLeft();
  281. sscanf(szBuffer, "ArraySize     < %d >n", &m_iSize);
  283. ar.ReadString(szBuffer);
  284. szBuffer.TrimLeft();
  285. sscanf(szBuffer, "Solid Color   < %d >n", &m_bSolidColor);
  287. ar.ReadString(szBuffer);
  288. szBuffer.TrimLeft();
  289. sscanf(szBuffer, "Num Points    < %d >n", &m_pPointArray->m_iNumPoints);
  291. // Resize our control point array
  292. if(m_pPointArray->SetArraySize(m_pPointArray->m_iNumPoints))
  293. {
  294. AfxMessageBox("Not enough memory to create array points!", MB_OK);
  295. m_pPointArray = NULL;
  296. return;
  297. }
  299. // Read the shape vertice, or point data
  300. for(int i=0; i<m_pPointArray->m_iNumPoints; i++)
  301. {
  302. ar.ReadString(szBuffer);
  303. szBuffer.TrimLeft();
  304. sscanf(szBuffer, "< %f, %f, %f >n", &m_pPointArray->m_pPoints[i].m_fOrigin[X],
  305.  &m_pPointArray->m_pPoints[i].m_fOrigin[Y],
  306.  &m_pPointArray->m_pPoints[i].m_fOrigin[Z]);
  307. }
  308. if(!m_bSolidColor)
  309. {
  310. ar.ReadString(szBuffer); // [color] header
  312. // Read the shape vertice, or point data
  313. for(int i=0; i<m_pPointArray->m_iNumPoints; i++)
  314. {
  315. ar.ReadString(szBuffer);
  316. szBuffer.TrimLeft();
  317. sscanf(szBuffer, "< %f, %f, %f, %f >n", &m_pPointArray->m_pPoints[i].m_Color.m_fColor[0],
  318.  &m_pPointArray->m_pPoints[i].m_Color.m_fColor[1],
  319.  &m_pPointArray->m_pPoints[i].m_Color.m_fColor[2],
  320.  &m_pPointArray->m_pPoints[i].m_Color.m_fColor[3]);
  321. }
  323. // Initialize our terrain color height values
  324. InitColorHeightValues();
  325. }
  327. // Read the base class object data...
  328. C3dObject::Serialize(ar, iVersion);
  329. }
  330. }
  332. void C3dObjectTerrain::DisplayPoints(C3dWorld* pWorld, C3dCamera* pCamera)
  333. {
  334. static BOOL bDisplayMsg = TRUE;
  336. if(m_iTile>1 && bDisplayMsg)
  337. {
  338. AfxMessageBox("To edit the Terrain object points, the 'Tile' membern"
  339.   "variable must be set to one.", MB_OK);
  341. // Display the message only once per session
  342. bDisplayMsg = FALSE;
  343. return;
  344. }
  346. if(m_iTile==1)
  347. {
  348. // Display all points in our object
  349. if(m_pPointArray)
  350. {
  351. if(m_pPointArray->m_pPoints)
  352. m_pPointArray->Display(pWorld, pCamera, this, 5.0f, FALSE);
  353. }
  354. }
  355. }
  357. void C3dObjectTerrain::Build(C3dWorld* pWorld, C3dCamera* pCamera)
  358. {
  359. static int  iterations = 0;
  360. static BOOL textureLinear = FALSE;
  361. GLfloat x, y;
  362. int i, j;
  365. if(m_pPointArray == NULL)
  366. return;
  368. // This may take a while, so display an hour glass cursor
  369. CWaitCursor hourglass;
  371. // The following code is my initial attempt a multi-pass texturing.
  372. // The intention is to initially generate the image, with the objects
  373. // texture map, into our m_iTexImageMap texture map.  After the initial
  374. // texture is generated, we will then texture map this image onto the
  375. // terrain image with m_bReflect set appropriately.
  376. if(iterations && pWorld && pCamera)
  377. {
  378. // Render our initial Terrain and generate our m_iTexImageMap
  379. // Texture map, rendered using our C3dObject pTexture image 
  380. // if created.  (Set prior to calling this function.)
  381. RenderTextureImageMap(pWorld, pCamera);
  383. // Playing with sub texture maps
  384. // RenderTextureMaps();
  386. // Goes a little faster but looks like crud:
  387. //glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
  388. glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, (GLfloat) GL_REPLACE);
  389. glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
  390. textureLinear ? (GLfloat) GL_LINEAR : (GLfloat) GL_NEAREST);
  391. glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
  392. textureLinear ? (GLfloat) GL_LINEAR : (GLfloat) GL_NEAREST);
  394. // Enable Texture mapping, as it may be off at this time
  395. glEnable (GL_TEXTURE_2D);
  396. }
  398. // Build the final display list
  399. RenderTerrain(TRUE, m_bReflect);
  402. // Compile and build the list
  403. glNewList(m_iDisplayLists, GL_COMPILE_AND_EXECUTE);
  405. // Center our tiled image about the objects' origin
  406. glPushMatrix();
  408. glTranslatef((GLfloat)(m_fWidth * (GLfloat)(m_iTile-1))/2.0f,
  409.  (GLfloat)(m_fDepth * (GLfloat)(m_iTile-1))/2.0f,
  410.   0.0f);
  412. y = -m_fDepth * (GLfloat)(m_iTile-1);
  413. for (i=0; i<m_iTile; i++)
  414. {
  415. x = -m_fWidth * (GLfloat)(m_iTile-1);
  416. for (j=0; j<m_iTile; j++)
  417. {
  418. glPushMatrix();
  419. glTranslatef(x, y, 0.0f);
  421. if(m_iTerrainGridDisplayList)
  422. glCallList(m_iTerrainGridDisplayList);
  424. glPopMatrix ();
  425. x += m_fWidth;
  426. }
  427. y += m_fDepth;
  428. }
  430. glPopMatrix();
  432. glEndList();
  434. // Restore the cursor to its' default
  435. hourglass.Restore();
  436. }
  439. /////////////////////////////////////////////////////////////////////////////
  440. // C3dObjectTerrain Methods or Implementation
  442. void C3dObjectTerrain::CopyParameters(C3dObjectTerrain* pObj)
  443. {
  444. // Copy this objects parameters to the given terrain object.
  445. // This function is used by the CPageTerrainColor preview 
  446. // window.
  447. pObj->m_bApplySubGridTextures = m_bApplySubGridTextures;
  448. pObj->m_bMapTexturesToSubGrid = m_bMapTexturesToSubGrid;
  449. pObj->m_bReflect = m_bReflect;
  450. pObj->m_bSolidColor = m_bSolidColor;
  451. pObj->m_bSmoothNormals = m_bSmoothNormals;
  452. pObj->m_fSeaLevel = m_fSeaLevel;
  453. pObj->m_iHeightSeed = m_iHeightSeed;
  455. // Since this function is used by the preview window, we want
  456. // the image to fit 'mostly' within the window, so we will 
  457. // use our default settings.  We also want to conserve memory
  458. // so we will use the default array size setting.
  459. // pObj->m_fDepth = m_fDepth;
  460. // pObj->m_fWidth = m_fWidth;
  461. // pObj->m_fHeight = m_fHeight;
  462. // pObj->m_iSize = m_iSize;
  464. pObj->m_ColorSnow.SetColor4fv(&m_ColorSnow);
  465. pObj->m_ColorRock.SetColor4fv(&m_ColorRock);
  466. pObj->m_ColorGrass.SetColor4fv(&m_ColorGrass);
  467. pObj->m_ColorWater.SetColor4fv(&m_ColorWater);
  468. pObj->m_Color.SetColor4fv(&m_Color);
  469. }
  471. void C3dObjectTerrain::RenderTerrain(BOOL bCreateList, BOOL bReflect)
  472. {
  473. const int subSize = m_iSize;
  474.     int i, j;
  476. if(!m_iTerrainGridDisplayList)
  477. m_iTerrainGridDisplayList = glGenLists(1);// Create the DisplayList(s)
  479. if(bCreateList)
  480. {
  481. // Compile and build the list
  482. glNewList(m_iTerrainGridDisplayList, GL_COMPILE);
  484. // Call our TerrainTexImageMap as the Texture map
  485. glCallList (m_iTexImageMap);
  488. for (i=0; i<subSize; i++)
  489. {
  490. for (j=0; j<subSize; j++)
  491. {
  492. DisplayAsTriangleStrip(i, j, bReflect);
  494. // Multi-level texturing worked best displayed as triangles..
  495. // DisplayAsTriangles(i, j, bReflect);
  496. }
  497. }
  499. glEndList();
  500. }
  501. else
  502. {
  503. for (i=0; i<subSize; i++)
  504. {
  505. for (j=0; j<subSize; j++)
  506. DisplayAsTriangleStrip(i, j, bReflect);
  507. }
  509. }
  510. }
  512. void C3dObjectTerrain::DisplayAsTriangles(int i, int j, BOOL bReflect)
  513. {
  514. VECTORF p0, p1, p2, p3, normal[4];
  515. const int subSize = m_iSize, superSize = m_iSize+1;
  517. // Get the array points
  518. VecCopy3f (m_pPointArray->m_pPoints[    i*superSize+j].m_fOrigin, p0);
  519. VecCopy3f (m_pPointArray->m_pPoints[(i+1)*superSize+j].m_fOrigin, p1);
  520. VecCopy3f (m_pPointArray->m_pPoints[    i*superSize+j+1].m_fOrigin, p2);
  521. VecCopy3f (m_pPointArray->m_pPoints[(i+1)*superSize+j+1].m_fOrigin, p3);
  523. if(m_bSmoothNormals)
  524. {
  525. AvgNormals(  i,   j, m_pPointArray, &normal[0], TRUE);
  526. AvgNormals(i+1,   j, m_pPointArray, &normal[1], TRUE);
  527. AvgNormals(  i, j+1, m_pPointArray, &normal[2], TRUE);
  528. AvgNormals(i+1, j+1, m_pPointArray, &normal[3], TRUE);
  529. }
  530. else
  531. {
  532. CalNormalf(p2, p1, p0, normal[0]);
  533. CalNormalf(p1, p0, p2, normal[1]);
  534. CalNormalf(p0, p2, p1, normal[2]);
  535. CalNormalf(p3, p1, p2, normal[3]);
  536. }
  539. glBegin(GL_TRIANGLES);
  541. SetTextureList(p0, p1, p2);
  542. if(m_bApplySubGridTextures || m_bMapTexturesToSubGrid)
  543. glTexCoord2f (0.f, 0.f);
  544. else
  545. SetTextureCoord(i, j);
  547. if(!m_bSolidColor)
  548. SetTerrainColor(i, j, bReflect);
  549. glNormal3fv(normal[0]);
  550. glVertex3fv(p0);
  553. if(m_bApplySubGridTextures || m_bMapTexturesToSubGrid)
  554. glTexCoord2f (1.f, 0.f);
  555. else
  556. SetTextureCoord(i+1, j);
  557. if(!m_bSolidColor)
  558. SetTerrainColor(i+1, j, bReflect);
  559. glNormal3fv(normal[1]);
  560. glVertex3fv(p1);
  562. if(m_bApplySubGridTextures || m_bMapTexturesToSubGrid)
  563. glTexCoord2f (0.f, 1.f);
  564. else
  565. SetTextureCoord(i, j+1);
  566. if(!m_bSolidColor)
  567. SetTerrainColor(i, j+1, bReflect);
  568. glNormal3fv(normal[2]);
  569. glVertex3fv(p2);
  571. glEnd();
  573. glBegin(GL_TRIANGLES);
  575. SetTextureList(p1, p2, p3);
  578. if(m_bApplySubGridTextures || m_bMapTexturesToSubGrid)
  579. glTexCoord2f (1.f, 0.f);
  580. else
  581. SetTextureCoord(i+1, j);
  582. if(!m_bSolidColor)
  583. SetTerrainColor(i+1, j, bReflect);
  584. glNormal3fv(normal[1]);
  585. glVertex3fv(p1);
  588. if(m_bApplySubGridTextures || m_bMapTexturesToSubGrid)
  589. glTexCoord2f (0.f, 1.f);
  590. else
  591. SetTextureCoord(i, j+1);
  592. if(!m_bSolidColor)
  593. SetTerrainColor(i, j+1, bReflect);
  594. glNormal3fv(normal[2]);
  595. glVertex3fv(p2);
  597. if(m_bApplySubGridTextures || m_bMapTexturesToSubGrid)
  598. glTexCoord2f (1.f, 1.f);
  599. else
  600. SetTextureCoord(i+1, j+1);
  601. if(!m_bSolidColor)
  602. SetTerrainColor(i+1, j+1, bReflect);
  603. glNormal3fv(normal[3]);
  604. glVertex3fv(p3);
  606. glEnd ();
  607. }
  609. void C3dObjectTerrain::DisplayAsTriangleStrip(int i, int j, BOOL bReflect)
  610. {
  611. VECTORF p0, p1, p2, p3, normal[4];
  612. const int subSize = m_iSize, superSize = m_iSize+1;
  614. // Get the array points
  615. VecCopy3f (m_pPointArray->m_pPoints[    i*superSize+j].m_fOrigin, p0);
  616. VecCopy3f (m_pPointArray->m_pPoints[(i+1)*superSize+j].m_fOrigin, p1);
  617. VecCopy3f (m_pPointArray->m_pPoints[    i*superSize+j+1].m_fOrigin, p2);
  618. VecCopy3f (m_pPointArray->m_pPoints[(i+1)*superSize+j+1].m_fOrigin, p3);
  620. if(m_bSmoothNormals)
  621. {
  622. AvgNormals(  i,   j, m_pPointArray, &normal[0], TRUE);
  623. AvgNormals(i+1,   j, m_pPointArray, &normal[1], TRUE);
  624. AvgNormals(  i, j+1, m_pPointArray, &normal[2], TRUE);
  625. AvgNormals(i+1, j+1, m_pPointArray, &normal[3], TRUE);
  626. }
  627. else
  628. {
  629. CalNormalf(p2, p1, p0, normal[0]);
  630. CalNormalf(p1, p0, p2, normal[1]);
  631. CalNormalf(p0, p2, p1, normal[2]);
  632. CalNormalf(p3, p1, p2, normal[3]);
  633. }
  636. glBegin (GL_TRIANGLE_STRIP);
  638. // SetTextureList(p0, p1, p2);
  640. if(m_bApplySubGridTextures || m_bMapTexturesToSubGrid)
  641. glTexCoord2f(0.f, 0.f);
  642. else
  643. SetTextureCoord(i, j);
  644. if(!m_bSolidColor)
  645. SetTerrainColor(i, j, bReflect);
  646. glNormal3fv(normal[0]);
  647. glVertex3fv(p0);
  650. if(m_bApplySubGridTextures || m_bMapTexturesToSubGrid)
  651. glTexCoord2f(1.f, 0.f);
  652. else
  653. SetTextureCoord(i+1, j);
  654. if(!m_bSolidColor)
  655. SetTerrainColor(i+1, j, bReflect);
  656. glNormal3fv(normal[1]);
  657. glVertex3fv(p1);
  660. if(m_bApplySubGridTextures || m_bMapTexturesToSubGrid)
  661. glTexCoord2f(0.f, 1.f);
  662. else
  663. SetTextureCoord(i, j+1);
  664. if(!m_bSolidColor)
  665. SetTerrainColor(i, j+1, bReflect);
  666. glNormal3fv(normal[2]);
  667. glVertex3fv(p2);
  670. // SetTextureList(p1, p2, p3);
  672. if(m_bApplySubGridTextures || m_bMapTexturesToSubGrid)
  673. glTexCoord2f(1.f, 1.f);
  674. else
  675. SetTextureCoord(i+1, j+1);
  676. if(!m_bSolidColor)
  677. SetTerrainColor(i+1, j+1, bReflect);
  678. glNormal3fv(normal[3]);
  679. glVertex3fv(p3);
  681. glEnd ();
  682. }
  684. void C3dObjectTerrain::RenderTextureMaps()
  685. {
  686. // Render our multi-level texture maps
  687. if(m_pTextureSnow)
  688. // Apply the Dib Image to our shape..
  689. m_pTextureSnow->SetTexture();
  691. if(m_pTextureRock)
  692. // Apply the Dib Image to our shape..
  693. m_pTextureRock->SetTexture();
  695. if(m_pTextureGrass)
  696. // Apply the Dib Image to our shape..
  697. m_pTextureGrass->SetTexture();
  699. if(m_pTextureWater)
  700. // Apply the Dib Image to our shape..
  701. m_pTextureWater->SetTexture();
  702. }
  704. void C3dObjectTerrain::SetTextureCoord(int i, int j)
  705. {
  706. float steps = 1.0f/(float)(m_iSize+1);
  708. glTexCoord2f(i*steps, j*steps);
  709. }
  711. void C3dObjectTerrain::SetTextureList(VECTORF p1, VECTORF p2, VECTORF p3)
  712. {
  713. float aveHeight = (p1[Z]+p2[Z]+p3[Z])/3.0f;
  715. if(m_bMapTexturesToSubGrid)
  716. {
  717. if(aveHeight <= m_fWaterHeight)
  718. {
  719. if(m_pTextureWater)
  720. {
  721. m_pTextureWater->SetTexture();
  722. return;
  723. }
  724. }
  725. if(aveHeight <= m_fGrassHeight)
  726. {
  727. if(m_pTextureGrass)
  728. {
  729. m_pTextureGrass->SetTexture();
  730. return;
  731. }
  732. }
  733. if(aveHeight <= m_fRockHeight)
  734. {
  735. if(m_pTextureRock)
  736. {
  737. m_pTextureRock->SetTexture();
  738. return;
  739. }
  740. }
  741. if(aveHeight <= m_fSnowHeight)
  742. {
  743. if(m_pTextureSnow)
  744. {
  745. m_pTextureSnow->SetTexture();
  746. return;
  747. }
  748. }
  749. }
  751. // No Textures, so set our polygon mode to default
  752. // and disable texture maping.
  753. glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  754. glDisable(GL_TEXTURE_2D);
  755. }
  757. void C3dObjectTerrain::InitTerrain()
  758. {
  759. float scale;
  761. // Calculate our scale based on its height & width
  762. scale = (m_fWidth+m_fHeight)/2;
  764. // Resize our control point array
  765. if(m_pPointArray->SetArraySize((m_iSize+1)*(m_iSize+1)))
  766. {
  767. AfxMessageBox("Not enough memory to create array points!", MB_OK);
  768. m_pPointArray = NULL;
  769. return; // function failed
  770. }
  772. FillFractualArray (m_pPointArray->m_pPoints, m_iSize, scale, m_fHeight);
  774. // Initialize our color components
  775. if(!m_bSolidColor)
  776. InitTerrainColor();
  777. }
  779. void C3dObjectTerrain::AvgNormals(int i, int j, C3dPointArray *fa, VECTORF* pNormal, BOOL bDiagonal)
  780. {
  781. VECTORF aveNormal, normals[6];
  782. VECTORF p1, p2, p3;
  783. int subSize = m_iSize+1;
  785. if(i==0 && j==0) // Bottom Left corner
  786. {
  787. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  788. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j].m_fOrigin, p2);
  789. VecCopy3f (fa->m_pPoints[i*subSize+j+1].m_fOrigin, p3);
  790. CalNormalf(p1, p3, p2, normals[0]);
  792. if(m_iTile > 1 && bDiagonal)
  793. {
  794. // Get the average normals for the other three corners
  795. AvgNormals(m_iSize, 0, fa, &normals[1], FALSE); // Bottom Right corner
  796. AvgNormals(m_iSize, m_iSize, fa, &normals[2], FALSE);// Top Right corner
  797. AvgNormals(0, m_iSize, fa, &normals[3], FALSE); // Top Left corner
  799. VecAddf(normals[0], normals[1], aveNormal);
  800. VecAddf(normals[2], aveNormal, aveNormal);
  801. VecAddf(normals[3], aveNormal, aveNormal);
  803. aveNormal[X] /= 4.0f;
  804. aveNormal[Y] /= 4.0f;
  805. aveNormal[Z] /= 4.0f;
  807. VecCopy3f(aveNormal, *pNormal);
  808. return;
  809. }
  811. VecCopy3f(normals[0], *pNormal);
  812. return;
  813. }
  815. if(i>=m_iSize && j==0) // Bottom Right Corner
  816. {
  817. // Average the two normals
  818. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  819. VecCopy3f (fa->m_pPoints[i*subSize+j+1].m_fOrigin, p2);
  820. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j+1].m_fOrigin, p3);
  821. CalNormalf(p1, p3, p2, normals[0]);
  823. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  824. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j+1].m_fOrigin, p2);
  825. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j].m_fOrigin, p3);
  826. CalNormalf(p1, p3, p2, normals[1]);
  828. VecAddf(normals[0], normals[1], aveNormal);
  830. aveNormal[X] /= 2.0f;
  831. aveNormal[Y] /= 2.0f;
  832. aveNormal[Z] /= 2.0f;
  834. if(m_iTile > 1 && bDiagonal)
  835. {
  836. // Get the average normals for the other three corners
  837. AvgNormals(m_iSize, m_iSize, fa, &normals[2], FALSE);// Top Right corner
  838. AvgNormals(0, m_iSize, fa, &normals[3], FALSE); // Top Left corner
  839. AvgNormals(0, 0, fa, &normals[4], FALSE); // Bottom Left corner
  841. VecAddf(normals[2], aveNormal, aveNormal);
  842. VecAddf(normals[3], aveNormal, aveNormal);
  843. VecAddf(normals[4], aveNormal, aveNormal);
  845. aveNormal[X] /= 4.0f;
  846. aveNormal[Y] /= 4.0f;
  847. aveNormal[Z] /= 4.0f;
  849. VecCopy3f(aveNormal, *pNormal);
  850. return;
  851. }
  853. VecCopy3f(aveNormal, *pNormal);
  854. return;
  855. }
  857. if(j>=m_iSize && i>=m_iSize) // Top Right Corner
  858. {
  859. // Only one normal
  860. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  861. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j].m_fOrigin, p2);
  862. VecCopy3f (fa->m_pPoints[i*subSize+j-1].m_fOrigin, p3);
  863. CalNormalf(p1, p3, p2, normals[0]);
  865. if(m_iTile > 1 && bDiagonal)
  866. {
  867. // Get the average normals for the other three corners
  868. AvgNormals(0, m_iSize, fa, &normals[1], FALSE); // Top Left corner
  869. AvgNormals(0, 0, fa, &normals[2], FALSE); // Bottom Left corner
  870. AvgNormals(m_iSize, 0, fa, &normals[3], FALSE); // Bottom Right corner
  872. VecAddf(normals[0], normals[1], aveNormal);
  873. VecAddf(normals[2], aveNormal, aveNormal);
  874. VecAddf(normals[3], aveNormal, aveNormal);
  876. aveNormal[X] /= 4.0f;
  877. aveNormal[Y] /= 4.0f;
  878. aveNormal[Z] /= 4.0f;
  880. VecCopy3f(aveNormal, *pNormal);
  881. return;
  882. }
  884. VecCopy3f(normals[0], *pNormal);
  885. return;
  886. }
  888. if(i==0 && j>=m_iSize) // Top Left Corner
  889. {
  890. // Average two normals
  891. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  892. VecCopy3f (fa->m_pPoints[i*subSize+j-1].m_fOrigin, p2);
  893. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j-1].m_fOrigin, p3);
  894. CalNormalf(p1, p3, p2, normals[0]);
  896. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  897. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j-1].m_fOrigin, p2);
  898. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j].m_fOrigin, p3);
  899. CalNormalf(p1, p3, p2, normals[1]);
  901. VecAddf(normals[0], normals[1], aveNormal);
  903. aveNormal[X] /= 2.0f;
  904. aveNormal[Y] /= 2.0f;
  905. aveNormal[Z] /= 2.0f;
  907. if(m_iTile > 1 && bDiagonal)
  908. {
  909. // Get the average normals for the other three corners
  910. AvgNormals(0, 0, fa, &normals[2], FALSE); // Bottom Left corner
  911. AvgNormals(m_iSize, 0, fa, &normals[3], FALSE); // Bottom Right corner
  912. AvgNormals(m_iSize, m_iSize, fa, &normals[4], FALSE);// Top Right corner
  914. VecAddf(normals[2], aveNormal, aveNormal);
  915. VecAddf(normals[3], aveNormal, aveNormal);
  916. VecAddf(normals[4], aveNormal, aveNormal);
  918. aveNormal[X] /= 4.0f;
  919. aveNormal[Y] /= 4.0f;
  920. aveNormal[Z] /= 4.0f;
  922. VecCopy3f(aveNormal, *pNormal);
  923. return;
  924. }
  926. VecCopy3f(aveNormal, *pNormal);
  927. return;
  928. }
  930. if(j==0 && i<m_iSize) // Bottom side
  931. {
  932. // Average the three bottom normals normals
  933. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  934. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j+1].m_fOrigin, p2);
  935. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j].m_fOrigin, p3);
  936. CalNormalf(p1, p3, p2, normals[0]);
  938. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  939. VecCopy3f (fa->m_pPoints[i*subSize+j+1].m_fOrigin, p2);
  940. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j+1].m_fOrigin, p3);
  941. CalNormalf(p1, p3, p2, normals[1]);
  943. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  944. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j].m_fOrigin, p2);
  945. VecCopy3f (fa->m_pPoints[i*subSize+j+1].m_fOrigin, p3);
  946. CalNormalf(p1, p3, p2, normals[2]);
  948. VecAddf(normals[0], normals[1], aveNormal);
  949. VecAddf(normals[2], aveNormal, aveNormal);
  951. aveNormal[X] /= 3.0f;
  952. aveNormal[Y] /= 3.0f;
  953. aveNormal[Z] /= 3.0f;
  955. if(m_iTile > 1 && bDiagonal)
  956. {
  957. // Get the average normal for the array point on the Top side
  958. AvgNormals(i, m_iSize, fa, &normals[3], FALSE);
  960. VecAddf(normals[3], aveNormal, aveNormal);
  962. aveNormal[X] /= 2.0f;
  963. aveNormal[Y] /= 2.0f;
  964. aveNormal[Z] /= 2.0f;
  966. VecCopy3f(aveNormal, *pNormal);
  967. return;
  968. }
  970. VecCopy3f(aveNormal, *pNormal);
  971. return;
  972. }
  974. if(i>=m_iSize && j<m_iSize) // Right Side
  975. {
  976. // Average the three side normals
  977. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  978. VecCopy3f (fa->m_pPoints[i*subSize+j+1].m_fOrigin, p2);
  979. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j+1].m_fOrigin, p3);
  980. CalNormalf(p1, p3, p2, normals[0]);
  982. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  983. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j+1].m_fOrigin, p2);
  984. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j].m_fOrigin, p3);
  985. CalNormalf(p1, p3, p2, normals[1]);
  987. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  988. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j].m_fOrigin, p2);
  989. VecCopy3f (fa->m_pPoints[i*subSize+j-1].m_fOrigin, p3);
  990. CalNormalf(p1, p3, p2, normals[2]);
  992. VecAddf(normals[0], normals[1], aveNormal);
  993. VecAddf(normals[2], aveNormal, aveNormal);
  995. aveNormal[X] /= 3.0f;
  996. aveNormal[Y] /= 3.0f;
  997. aveNormal[Z] /= 3.0f;
  999. if(m_iTile > 1 && bDiagonal)
  1000. {
  1001. // Get the average normal for the array point on the Left side
  1002. AvgNormals(0, j, fa, &normals[3], FALSE);
  1004. VecAddf(normals[3], aveNormal, aveNormal);
  1006. aveNormal[X] /= 2.0f;
  1007. aveNormal[Y] /= 2.0f;
  1008. aveNormal[Z] /= 2.0f;
  1010. VecCopy3f(aveNormal, *pNormal);
  1011. return;
  1012. }
  1014. VecCopy3f(aveNormal, *pNormal);
  1015. return;
  1016. }
  1018. if(j>=m_iSize && i<m_iSize) // Top side
  1019. {
  1020. // Average three normals
  1021. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  1022. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j].m_fOrigin, p2);
  1023. VecCopy3f (fa->m_pPoints[i*subSize+j-1].m_fOrigin, p3);
  1024. CalNormalf(p1, p3, p2, normals[0]);
  1026. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  1027. VecCopy3f (fa->m_pPoints[i*subSize+j-1].m_fOrigin, p2);
  1028. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j-1].m_fOrigin, p3);
  1029. CalNormalf(p1, p3, p2, normals[1]);
  1031. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  1032. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j-1].m_fOrigin, p2);
  1033. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j].m_fOrigin, p3);
  1034. CalNormalf(p1, p3, p2, normals[2]);
  1036. VecAddf(normals[0], normals[1], aveNormal);
  1037. VecAddf(normals[2], aveNormal, aveNormal);
  1039. aveNormal[X] /= 3.0f;
  1040. aveNormal[Y] /= 3.0f;
  1041. aveNormal[Z] /= 3.0f;
  1043. if(m_iTile > 1 && bDiagonal)
  1044. {
  1045. // Get the average normal for the array point on the Bottom side
  1046. AvgNormals(i, 0, fa, &normals[3], FALSE);
  1048. VecAddf(normals[3], aveNormal, aveNormal);
  1050. aveNormal[X] /= 2.0f;
  1051. aveNormal[Y] /= 2.0f;
  1052. aveNormal[Z] /= 2.0f;
  1054. VecCopy3f(aveNormal, *pNormal);
  1055. return;
  1056. }
  1058. VecCopy3f(aveNormal, *pNormal);
  1059. return;
  1060. }
  1062. if(i==0 && j<m_iSize) // Left Side
  1063. {
  1064. // Average the three normals on left side
  1065. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  1066. VecCopy3f (fa->m_pPoints[i*subSize+j-1].m_fOrigin, p2);
  1067. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j-1].m_fOrigin, p3);
  1068. CalNormalf(p1, p3, p2, normals[0]);
  1070. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  1071. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j-1].m_fOrigin, p2);
  1072. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j].m_fOrigin, p3);
  1073. CalNormalf(p1, p3, p2, normals[1]);
  1075. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  1076. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j].m_fOrigin, p2);
  1077. VecCopy3f (fa->m_pPoints[i*subSize+j+1].m_fOrigin, p3);
  1078. CalNormalf(p1, p3, p2, normals[2]);
  1080. VecAddf(normals[0], normals[1], aveNormal);
  1081. VecAddf(normals[2], aveNormal, aveNormal);
  1083. aveNormal[X] /= 3.0f;
  1084. aveNormal[Y] /= 3.0f;
  1085. aveNormal[Z] /= 3.0f;
  1087. if(m_iTile > 1 && bDiagonal)
  1088. {
  1089. // Get the average normal for the array point on the Right side
  1090. AvgNormals(m_iSize, j, fa, &normals[3], FALSE);
  1092. VecAddf(normals[3], aveNormal, aveNormal);
  1094. aveNormal[X] /= 2.0f;
  1095. aveNormal[Y] /= 2.0f;
  1096. aveNormal[Z] /= 2.0f;
  1098. VecCopy3f(aveNormal, *pNormal);
  1099. return;
  1100. }
  1102. VecCopy3f(aveNormal, *pNormal);
  1103. return;
  1104. }
  1106. // Point is not on sides of our terrain, so average all
  1107. // six normals.
  1108. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  1109. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j].m_fOrigin, p2);
  1110. VecCopy3f (fa->m_pPoints[i*subSize+j+1].m_fOrigin, p3);
  1111. CalNormalf(p1, p3, p2, normals[0]);
  1113. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  1114. VecCopy3f (fa->m_pPoints[i*subSize+j+1].m_fOrigin, p2);
  1115. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j+1].m_fOrigin, p3);
  1116. CalNormalf(p1, p3, p2, normals[1]);
  1118. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  1119. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j+1].m_fOrigin, p2);
  1120. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j].m_fOrigin, p3);
  1121. CalNormalf(p1, p3, p2, normals[2]);
  1123. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  1124. VecCopy3f (fa->m_pPoints[(i-1)*subSize+j].m_fOrigin, p2);
  1125. VecCopy3f (fa->m_pPoints[i*subSize+j-1].m_fOrigin, p3);
  1126. CalNormalf(p1, p3, p2, normals[3]);
  1128. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  1129. VecCopy3f (fa->m_pPoints[i*subSize+j-1].m_fOrigin, p2);
  1130. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j-1].m_fOrigin, p3);
  1131. CalNormalf(p1, p3, p2, normals[4]);
  1133. VecCopy3f (fa->m_pPoints[i*subSize+j].m_fOrigin, p1);
  1134. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j-1].m_fOrigin, p2);
  1135. VecCopy3f (fa->m_pPoints[(i+1)*subSize+j].m_fOrigin, p3);
  1136. CalNormalf(p1, p3, p2, normals[5]);
  1138. VecAddf(normals[0], normals[1], aveNormal);
  1139. VecAddf(normals[2], aveNormal, aveNormal);
  1140. VecAddf(normals[3], aveNormal, aveNormal);
  1141. VecAddf(normals[4], aveNormal, aveNormal);
  1142. VecAddf(normals[5], aveNormal, aveNormal);
  1144. aveNormal[X] /= 6.0f;
  1145. aveNormal[Y] /= 6.0f;
  1146. aveNormal[Z] /= 6.0f;
  1148. VecCopy3f(aveNormal, *pNormal);
  1149. }
  1151. // randNum - Return a random floating point number such that
  1152. // (min <= return-value <= max)
  1153. // 32,767 values are possible for any given range.
  1154. //
  1155. float C3dObjectTerrain::RandNum (float min, float max)
  1156. {
  1157. int r;
  1158. float x;
  1160. r = rand ();
  1161. x = (float)(r & 0x7fff) /
  1162. (float)0x7fff;
  1163. return (x * (max - min) + min);
  1164. } 
  1166. // fractRand is a useful interface to randnum.
  1167. //
  1168. #define FractRand(v) RandNum (-v, v)
  1170. // powerOf2 - Returns 1 if size is a power of 2. Returns 0 if size is
  1171. // not a power of 2, or is zero.
  1172. //
  1173. int C3dObjectTerrain::PowerOf2 (int size)
  1174. {
  1175. int i, bitcount = 0;
  1177. // Note this code assumes that (sizeof(int)*8) will yield the
  1178. // number of bits in an int. Should be portable to most
  1179. // platforms.
  1180. for (i=0; i<sizeof(int)*8; i++)
  1181. if (size & (1<<i))
  1182.     bitcount++;
  1184. if (bitcount == 1)
  1185. // One bit. Must be a power of 2.
  1186. return (1);
  1187.     else
  1188. // either size==0, or size not a power of 2. Sorry, Charlie.
  1190. return (0);
  1191. }
  1193. // AvgDiamondVals - Given the i,j location as the center of a diamond,
  1194. // average the data values at the four corners of the diamond and
  1195. // return it. "Stride" represents the distance from the diamond center
  1196. // to a diamond corner.
  1197. //
  1198. float C3dObjectTerrain::AvgDiamondVals (int i, int j, int stride,
  1199.      int size, int subSize, C3dPoint *fa)
  1200. {
  1201.     /* In this diagram, our input stride is 1, the i,j location is
  1202.        indicated by "X", and the four value we want to average are
  1203.        "*"s:
  1204.            .   *   .
  1206.            *   X   *
  1208.            .   *   .
  1209.        */
  1211. // In order to support tiled surfaces which meet seamless at the
  1212. // edges (that is, they "wrap"), We need to be careful how we
  1213. // calculate averages when the i,j diamond center lies on an edge
  1214. // of the array. The first four 'if' clauses handle these
  1215. // cases. The final 'else' clause handles the general case (in
  1216. // which i,j is not on an edge).
  1217. if (i == 0)
  1218. return ((float) (fa[(i*size) + j-stride].m_fOrigin[Z] +
  1219.  fa[(i*size) + j+stride].m_fOrigin[Z] +
  1220.  fa[((subSize-stride)*size) + j].m_fOrigin[Z] +
  1221.  fa[((i+stride)*size) + j].m_fOrigin[Z]) * .25f);
  1222. else if (i == size-1)
  1223. return ((float) (fa[(i*size) + j-stride].m_fOrigin[Z] +
  1224.  fa[(i*size) + j+stride].m_fOrigin[Z] +
  1225.  fa[((i-stride)*size) + j].m_fOrigin[Z] +
  1226.  fa[((0+stride)*size) + j].m_fOrigin[Z]) * .25f);
  1227. else if (j == 0)
  1228. return ((float) (fa[((i-stride)*size) + j].m_fOrigin[Z] +
  1229.  fa[((i+stride)*size) + j].m_fOrigin[Z] +
  1230.  fa[(i*size) + j+stride].m_fOrigin[Z] +
  1231.  fa[(i*size) + subSize-stride].m_fOrigin[Z]) * .25f);
  1232. else if (j == size-1)
  1233. return ((float) (fa[((i-stride)*size) + j].m_fOrigin[Z] +
  1234.  fa[((i+stride)*size) + j].m_fOrigin[Z] +
  1235.  fa[(i*size) + j-stride].m_fOrigin[Z] +
  1236.  fa[(i*size) + 0+stride].m_fOrigin[Z]) * .25f);
  1237. else
  1238. return ((float) (fa[((i-stride)*size) + j].m_fOrigin[Z] +
  1239.  fa[((i+stride)*size) + j].m_fOrigin[Z] +
  1240.  fa[(i*size) + j-stride].m_fOrigin[Z] +
  1241.  fa[(i*size) + j+stride].m_fOrigin[Z]) * .25f);
  1242. }
  1244. // AvgSquareVals - Given the i,j location as the center of a square,
  1245. // average the data values at the four corners of the square and return
  1246. // it. "Stride" represents half the length of one side of the square.
  1247. float C3dObjectTerrain::AvgSquareVals (int i, int j, int stride, int size, C3dPoint *fa)
  1248. {
  1249.     /* In this diagram, our input stride is 1, the i,j location is
  1250.        indicated by "*", and the four value we want to average are
  1251.        "X"s:
  1252.            X   .   X
  1254.            .   *   .
  1256.            X   .   X
  1257.        */
  1258.     return ((float) (fa[((i-stride)*size) + j-stride].m_fOrigin[Z] +
  1259.      fa[((i-stride)*size) + j+stride].m_fOrigin[Z] +
  1260.      fa[((i+stride)*size) + j-stride].m_fOrigin[Z] +
  1261.      fa[((i+stride)*size) + j+stride].m_fOrigin[Z]) * .25f);
  1262. }
  1264. // FillFractualArray - Use the diamond-square algorithm to tessalate a
  1265. // grid of float values into a fractal height map.
  1266. //
  1267. void C3dObjectTerrain::FillFractualArray (C3dPoint *fa, int size,
  1268.  float heightScale, float h)
  1269. {
  1270. int i, j;
  1271. int stride;
  1272. int oddline;
  1273. int subSize;
  1274. int seedValue;
  1275. float ratio, scale;
  1277. if (!PowerOf2(size) || (size==1))
  1278. {
  1279. // We can't tesselate the array if it is not a power of 2.
  1280. #ifdef DEBUG
  1281. printf ("Error: FillFractualArray: size %d is not a power of 2.n");
  1282. #endif /* DEBUG */
  1284. return;
  1285.     }
  1287. // subSize is the dimension of the array in terms of connected line
  1288. // segments, while size is the dimension in terms of number of
  1289. // vertices.
  1290. subSize = size;
  1291. size++;
  1293. // Initialize random number generator
  1294. if(m_iHeightSeed < 0)
  1295. {
  1296. // Seed the random-number generator with current time so that
  1297. // the numbers will be different every time we run.
  1298. seedValue = (unsigned)time( NULL );
  1299. srand( seedValue );
  1300. m_iHeightSeed = seedValue;
  1301. }
  1302. else
  1303.     srand (m_iHeightSeed);
  1305.     // Set up our roughness constants.
  1306. // Random numbers are always generated in the range 0.0 to 1.0.
  1307. // 'scale' is multiplied by the randum number.
  1308. // 'ratio' is multiplied by 'scale' after each iteration
  1309. // to effectively reduce the random number range.
  1310. ratio = (float) pow ((double)2.0,(double)-h);
  1311. scale = heightScale * ratio;
  1314.     /* Seed the first four values. For example, in a 4x4 array, we
  1315.        would initialize the data points indicated by '*':
  1317.            *   .   .   .   *
  1319.            .   .   .   .   .
  1321.            .   .   .   .   .
  1323.            .   .   .   .   .
  1325.            *   .   .   .   *
  1327.        In terms of the "diamond-square" algorithm, this gives us
  1328.        "squares".
  1330.        We want the four corners of the array to have the same
  1331.        point. This will allow us to tile the arrays next to each other
  1332.        such that they join seemlessly.
  1333.    */
  1335. stride = subSize / 2;
  1336. fa[(0*size)+0].m_fOrigin[Z] = fa[(subSize*size)+0].m_fOrigin[Z] =
  1337. fa[(subSize*size)+subSize].m_fOrigin[Z] =
  1338. fa[(0*size)+subSize].m_fOrigin[Z] = 0.f;
  1340. // Now we add ever-increasing detail based on the "diamond" seeded
  1341. // values. We loop over stride, which gets cut in half at the
  1342. // bottom of the loop. Since it's an int, eventually division by 2
  1343. // will produce a zero result, terminating the loop.
  1345. while (stride)
  1346. {
  1347. /* Take the existing "square" data and produce "diamond"
  1348.    data. On the first pass through with a 4x4 matrix, the
  1349.    existing data is shown as "X"s, and we need to generate the
  1350.        "*" now:
  1352.                X   .   .   .   X
  1354.                .   .   .   .   .
  1356.                .   .   *   .   .
  1358.                .   .   .   .   .
  1360.                X   .   .   .   X
  1361.   It doesn't look like diamonds. What it actually is, for the
  1362.       first pass, is the corners of four diamonds meeting at the
  1363.       center of the array. */
  1364. for (i=stride; i<subSize; i+=stride)
  1365. {
  1366. for (j=stride; j<subSize; j+=stride)
  1367. {
  1368. fa[(i * size) + j].m_fOrigin[Z] = scale * FractRand (.5f) +
  1369. AvgSquareVals (i, j, stride, size, fa);
  1370. j += stride;
  1371. }
  1372. i += stride;
  1373. }
  1375. /* Take the existing "diamond" data and make it into
  1376.        "squares". Back to our 4X4 example: The first time we
  1377.        encounter this code, the existing values are represented by
  1378.        "X"s, and the values we want to generate here are "*"s:
  1380.                X   .   *   .   X
  1382.                .   .   .   .   .
  1384.                *   .   X   .   *
  1386.                .   .   .   .   .
  1388.                X   .   *   .   X
  1390.        i and j represent our (x,y) position in the array. The
  1391.        first value we want to generate is at (i=2,j=0), and we use
  1392.        "oddline" and "stride" to increment j to the desired value.
  1393.        */
  1394. oddline = 0;
  1395. for (i=0; i<subSize; i+=stride)
  1396. {
  1397.     oddline = (oddline == 0);
  1398. for (j=0; j<subSize; j+=stride)
  1399. {
  1400. if ((oddline) && !j)
  1401. j+=stride;
  1403. // i and j are setup. Call avgDiamondVals with the
  1404. // current position. It will return the average of the
  1405. // surrounding diamond data points.
  1406. fa[(i * size) + j].m_fOrigin[Z] = scale * FractRand (.5f) +
  1407. AvgDiamondVals (i, j, stride, size, subSize, fa);
  1409. // To wrap edges seamlessly, copy edge values around
  1410. // to other side of array.
  1411. if (i==0)
  1412. fa[(subSize*size) + j].m_fOrigin[Z] =
  1413. fa[(i * size) + j].m_fOrigin[Z];
  1414. if (j==0)
  1415. fa[(i*size) + subSize].m_fOrigin[Z] =
  1416. fa[(i * size) + j].m_fOrigin[Z];
  1418. j+=stride;
  1419. }
  1420. }
  1422. // reduce random number range.
  1423. scale *= ratio;
  1424. stride >>= 1;
  1425.     }
  1428. // Now that we have the terrain height values, calculate
  1429. // the width and depth values.
  1430. float width, depth;
  1431. width = -m_fWidth/2.0f;
  1433. // Initialize our terrain color height values
  1434. InitColorHeightValues();
  1436. float seaHeight;
  1437. if(m_fSeaLevel > .0f)
  1438. seaHeight = ((m_fSnowHeight-m_fWaterHeight)*m_fSeaLevel) + m_fWaterHeight;
  1440. for(i=0; i<size; i++)
  1441. {
  1442. depth = -m_fDepth/2.0f;
  1444. for(j=0; j<size; j++)
  1445. {
  1446. fa[(i*size) + j].m_fOrigin[X]=width;
  1447. fa[(i*size) + j].m_fOrigin[Y]=depth;
  1449. if(m_fSeaLevel > .0f)
  1450. {
  1451. if(fa[(i*size) + j].m_fOrigin[Z]<=seaHeight)
  1452. fa[(i*size) + j].m_fOrigin[Z]=seaHeight;
  1453. }
  1455. depth += (m_fDepth/(GLfloat)subSize);
  1456. }
  1457. width += (m_fWidth/(GLfloat)subSize);
  1458. }
  1460. }
  1462. // InitColorHeightValues
  1463. //
  1464. // The h1 and h2 parameters are set to 1/3 and 2/3 of the height values and 
  1465. // h3 and h4 will be the max and min height values height values stored in the
  1466. // 2D fract array.
  1467. void C3dObjectTerrain::InitColorHeightValues()
  1468. {
  1469. float min, max;
  1470. int i;
  1472. // Set the min/max initially to very large opposite numbers
  1473.     min = (float)LARGE_NUMBER;
  1474.     max = (float)-LARGE_NUMBER;
  1476. for (i=0; i<m_pPointArray->m_iNumPoints; i++)
  1477. {
  1478. if(m_pPointArray->m_pPoints[i].m_fOrigin[Z] > max)
  1479. max = m_pPointArray->m_pPoints[i].m_fOrigin[Z];
  1480. else if(m_pPointArray->m_pPoints[i].m_fOrigin[Z] < min)
  1481.     min = m_pPointArray->m_pPoints[i].m_fOrigin[Z];
  1482. }
  1484. m_fSnowHeight  = max;
  1485. m_fRockHeight  = (max - min) * .66f + min;
  1486. m_fGrassHeight = (max - min) * .33f + min;
  1487. m_fWaterHeight = min;
  1488. }
  1490. void C3dObjectTerrain::InitTerrainColor()
  1491. {
  1492.     int i;
  1494. // Set our terrain color height values.  These settings are then used in
  1495. // our rinky-dink-but-effective coloring, scheme wherein the lower 1/3
  1496. // of terrain is colored dark green, the middle third is colored grey,
  1497. // and the upper third is white.  Our sealevel is colored blue.
  1498. InitColorHeightValues();
  1500. for (i=0; i<m_pPointArray->m_iNumPoints; i++)
  1501. {
  1502. float z = m_pPointArray->m_pPoints[i].m_fOrigin[Z];
  1504. if(z > m_fRockHeight)
  1505. m_pPointArray->m_pPoints[i].m_Color.SetColor4fv(&m_ColorSnow);
  1506. else if(z > m_fGrassHeight)
  1507. m_pPointArray->m_pPoints[i].m_Color.SetColor4fv(&m_ColorRock);
  1508. else
  1509. m_pPointArray->m_pPoints[i].m_Color.SetColor4fv(&m_ColorGrass);
  1510. if(m_fSeaLevel > .0f)
  1511. {
  1512. if(z == m_fWaterHeight)
  1513. m_pPointArray->m_pPoints[i].m_Color.SetColor4fv(&m_ColorWater);
  1514. }
  1515. }
  1517. }
  1519. void C3dObjectTerrain::SetTerrainColor(int i, int j, BOOL bReflect)
  1520. {
  1521. static C3dColor LastColor;
  1522. float h1;
  1524. if(i+j != 0)
  1525. {
  1526. // To DRAMATICALLY reduce the size of the display list, and hence, increase
  1527. // the speed, lets' minimize setting the material properties..
  1529. if(m_pPointArray->m_pPoints[i*(m_iSize+1)+j].m_Color.Compare(&LastColor))
  1530. // This points color components are identical to the last one set,
  1531. // so there is no need to set the material properties again.
  1532. return;
  1533. }
  1535. h1 = m_pPointArray->m_pPoints[i*(m_iSize+1)+j].m_fOrigin[Z];
  1537. if(h1 == m_fWaterHeight || h1 > m_fRockHeight)
  1538. {
  1539. if(bReflect)
  1540. {
  1541. // Set snow material properties
  1542. GLfloat ambColor[] = {0.2f, 0.2f, 0.2f, 1.0f};
  1543. GLfloat difColor[] = {0.8f, 0.8f, 0.8f, 1.0f};
  1544. GLfloat spcColor[] = {0.9f, 0.9f, 0.9f, 1.0f};
  1545. GLfloat emmColor[] = {0.0f, 0.0f, 0.0f, 1.0f};
  1547. // Set material properties to default values
  1548. glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT,  ambColor);
  1549. glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE,  difColor);
  1550. glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, spcColor);
  1551. glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emmColor);
  1552. glMaterialf(GL_FRONT, GL_SHININESS, 20.0f);
  1553. }
  1554. }
  1555. else
  1556. {
  1557. if(bReflect)
  1558. {
  1559. // All three vertices lay in the horizonal plane, so set its
  1560. // color and water material properties
  1561. GLfloat ambColor[] = {0.2f, 0.2f, 0.2f, 1.0f};
  1562. GLfloat difColor[] = {0.8f, 0.8f, 0.8f, 1.0f};
  1563. GLfloat spcColor[] = {0.0f, 0.0f, 0.0f, 1.0f};
  1564. GLfloat emmColor[] = {0.0f, 0.0f, 0.0f, 1.0f};
  1566. // Set material properties to default values
  1567. glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT,  ambColor);
  1568. glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE,  difColor);
  1569. glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, spcColor);
  1570. glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emmColor);
  1571. glMaterialf(GL_FRONT, GL_SHININESS, 0.0f);
  1572. }
  1573. }
  1575. glColor4fv(m_pPointArray->m_pPoints[i*(m_iSize+1)+j].m_Color.m_fColor);
  1577. // Save the color components
  1578. LastColor.SetColor4fv(&m_pPointArray->m_pPoints[i*(m_iSize+1)+j].m_Color);
  1579. }
  1581. BOOL C3dObjectTerrain::AddSubTexture(LPSTR szFileName, CTexture** pTexture)
  1582. {
  1583. if(*pTexture)
  1584. // If we already have a texture, delete it
  1585. DeleteSubTexture(*pTexture);
  1587. // Create a TextureMap of the appropriate type
  1588. CTexture::CreateTexture(szFileName, the3dEngine.m_hPalette, pTexture);
  1590. if(pTexture)
  1591. {
  1592. CTexture* pText = *pTexture;
  1594. // Is the TextureMap an CTextureAviMovie?
  1595. if( pText->IsKindOf(RUNTIME_CLASS(CTextureAviMovie)) )
  1596. {
  1597. // Create an AVI animation and add to the list
  1598. CAnimAVI* pAnim = new CAnimAVI;
  1599. ASSERT(pAnim);
  1600. m_AnimList.Append(pAnim);
  1602. // Cross link the two objects so that they are 'aware' of
  1603. // each other..
  1605. // Save the CTextureAviMovie pointer
  1606. pAnim->m_pAviMovie = (CTextureAviMovie*)pTexture;
  1608. // Save the CAnimAVI pointer
  1609. CTextureAviMovie* pAviVideo = (CTextureAviMovie*)pTexture;
  1610. pAviVideo->m_pAnimAVI = pAnim;
  1611. }
  1612. return TRUE;
  1613. }
  1614. else
  1615. return FALSE;
  1616. }
  1618. void C3dObjectTerrain::DeleteSubTexture(CTexture* pTexture)
  1619. {
  1620. if(pTexture)
  1621. {
  1622. if( pTexture->IsKindOf(RUNTIME_CLASS(CTextureAviMovie)) )
  1623. {
  1624. // TextureMap is of class type CTextureAviMovie, so find the animation
  1625. // procedure in the list, remove from list and delete it..
  1626. CAnimation* pAnimation = m_AnimList.Find(SZ_ANIMATE_AVI);
  1627. if(pAnimation)
  1628. {
  1629. m_AnimList.Remove(pAnimation);
  1630. delete pAnimation;
  1631. }
  1632. }
  1634. // Now that we have removed any associated object members,
  1635. // delete the texturemap
  1636. delete pTexture;
  1637. pTexture = NULL;
  1638. }
  1639. }
  1642. // renderTeximageMap
  1643. //
  1644. // If the teximage map is dirty, allocate and tesselate a new
  1645. // one. Render it to the screen as lit triangles. Read the
  1646. // image back and set it as a texture map in a display list.
  1647. BOOL C3dObjectTerrain::RenderTextureImageMap(C3dWorld* pWorld, C3dCamera* pCamera)
  1648. {
  1649. UINT pmapDim, smallDim;
  1651. // Find the biggest power of two that will fit
  1652. // in the current window. This is where we will 
  1653. // draw the image.
  1654. smallDim = (pCamera->m_iScreenWidth > pCamera->m_iScreenHeight) ?
  1655. pCamera->m_iScreenHeight : pCamera->m_iScreenWidth;
  1656. pmapDim = 1 << (UINT) (log ((float) smallDim) / log (2.));
  1658. // Save our gl States
  1659. glPushAttrib (0xfffffff);
  1661. // Only draw into biggest power of 2 square.
  1662. glViewport (0, 0, pmapDim, pmapDim);
  1663. glMatrixMode (GL_PROJECTION);
  1664.     glLoadIdentity ();
  1665. glOrtho (-m_fWidth/2.0f, m_fWidth/2.0f,
  1666.  -m_fDepth/2.0f, m_fDepth/2.0f, 0.0f, pCamera->m_fFar);
  1667. glMatrixMode (GL_MODELVIEW);
  1668.     glLoadIdentity ();
  1670. // The terrain array is rendered into the XY plane as viewed looking
  1671. // along the -Z axis. We need to move the 'camera' position up in Z
  1672. // so that we don't clip any polygons.
  1673. glTranslatef(0.f, 0.f, -10.f);
  1675. // Init lights now. Light position must be specified
  1676. // after our translation.
  1677. pWorld->InitializeLights(pCamera);
  1679. // Set our state flags
  1680. glDisable (GL_DEPTH_TEST);
  1681. glDisable (GL_FOG);
  1682. glEnable (GL_LIGHTING);
  1683. glDisable (GL_BLEND);
  1685.     // Clear our color buffer
  1686. glClear (GL_COLOR_BUFFER_BIT);
  1688. // Render the terrain
  1689. RenderTerrain(FALSE, FALSE);
  1691. // Flush all commands to draw the image
  1692. glFlush ();
  1695. GLubyte *pmap;
  1697. pmap = (GLubyte *) malloc (pmapDim*pmapDim*3);
  1698. if (pmap==NULL)
  1699. return (FALSE);
  1701. // Read the screen pixels
  1702. glReadPixels (0, 0, pmapDim, pmapDim, GL_RGB, GL_UNSIGNED_BYTE, pmap);
  1704. if(!m_iTexImageMap)
  1705. // Create our texture map display list
  1706. m_iTexImageMap = glGenLists(1);// Create the DisplayList(s)
  1708. glNewList(m_iTexImageMap, GL_COMPILE);
  1709. glTexImage2D (GL_TEXTURE_2D, 0, // lod
  1710.   3, // Number of components
  1711.   pmapDim, pmapDim, // width, height
  1712.   0, // Border
  1713.   GL_RGB, // Format
  1714.   GL_UNSIGNED_BYTE, // Type
  1715.   pmap); // Pointer to our pixels
  1716. glEndList ();
  1718. // Now that we have our texture map display list, 
  1719. // free our pixel memory
  1720. free (pmap);
  1722. // Restore our gl States
  1723. glPopAttrib ();
  1725. // Clear the buffers
  1726. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  1728. // Re-position our camera and lights to their original position
  1729. pCamera->ResetView(0, 0);
  1730. pCamera->PositionCamera();
  1731. pWorld->InitializeLights(pCamera);
  1733. return (TRUE);
  1734. }