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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
Fractal ExampleView.cpp
资源名称：Visual_C++GameDevelop.rar　[点击查看]
上传用户：sycq158
上传日期：2008-10-22
资源大小：15361k
文件大小：27k
源码类别：

游戏

开发平台：

Visual C++

Fractal ExampleView.cpp：源码内容
  1. // Fractal ExampleView.cpp : implementation of the CFractalExampleView class
  2. //
  4. //
  5. // Written by: Paul E. Martz
  6. // 
  7. // Copyright 1997 by Paul E. Martz, all right reserved
  8. //
  9. // Non-commercial use by individuals is permitted.
  10. //
  13. #include "stdafx.h"
  14. #include <math.h>
  15. #include "Fractal Example.h"
  17. #include "Fractal ExampleDoc.h"
  18. #include "Fractal ExampleView.h"
  19. #include "FractalOptionsDlg.h"
  21. #include "fractmod.h"
  23. #define CLOUDMAP 10
  24. #define TEXIMAGEMAP 20
  26. /////////////////////////////////////////////////////////////////////////////
  27. #ifdef _DEBUG
  28. #define new DEBUG_NEW
  29. #undef THIS_FILE
  30. static char THIS_FILE[] = __FILE__;
  31. #endif
  33. /////////////////////////////////////////////////////////////////////////////
  34. // CFractalExampleView
  36. IMPLEMENT_DYNCREATE(CFractalExampleView, COpenGLView)
  38. BEGIN_MESSAGE_MAP(CFractalExampleView, COpenGLView)
  39. //{{AFX_MSG_MAP(CFractalExampleView)
  40. ON_COMMAND(ID_VIEW_OPTIONS, OnViewOptions)
  41. ON_WM_KEYDOWN()
  42. ON_WM_KEYUP()
  43. ON_WM_DESTROY()
  44. //}}AFX_MSG_MAP
  45. END_MESSAGE_MAP()
  47. /////////////////////////////////////////////////////////////////////////////
  48. // CFractalExampleView construction/destruction
  50. CFractalExampleView::CFractalExampleView()
  51. {
  52. // TODO: add construction code here
  54. }
  56. CFractalExampleView::~CFractalExampleView()
  57. {
  58. }
  60. /////////////////////////////////////////////////////////////////////////////
  61. // CFractalExampleView drawing
  64. /////////////////////////////////////////////////////////////////////////////
  65. // CFractalExampleView diagnostics
  67. #ifdef _DEBUG
  68. void CFractalExampleView::AssertValid() const
  69. {
  70. CView::AssertValid();
  71. }
  73. void CFractalExampleView::Dump(CDumpContext& dc) const
  74. {
  75. CView::Dump(dc);
  76. }
  78. CFractalExampleDoc* CFractalExampleView::GetDocument() // non-debug version is inline
  79. {
  80. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CFractalExampleDoc)));
  81. return (CFractalExampleDoc*)m_pDocument;
  82. }
  83. #endif //_DEBUG
  86. ///////////////////////////////////////////
  87. // static routines used for rendering
  89. // Scale value passed into fractal generation routines.
  90. #define DEF_HEIGHT_SCALE 1.f
  92. // Keep linker happy
  93. #ifdef __cplusplus
  94. extern "C" {
  95. #endif
  97. // These next few routines are declared external by fractmod.c
  98. // They are referenced by fractmod.c's functions:
  99. //   draw1DFractArrayAsLines
  100. //   draw2DFractArrayAsLines
  101. //   draw2DFractArrayAsTriangles
  102. // If you don't use those functions from fractmod.c, these
  103. // functions here could be left blank. However they would
  104. // still need to be declared to resolve the symbols (unless
  105. // you removed their references in fractmod.c).
  107. void draw3DTriangle (float x1, float y1, float z1,
  108.      float x2, float y2, float z2,
  109.      float x3, float y3, float z3,
  110.      float nx, float ny, float nz)
  111. {
  112.     glBegin (GL_TRIANGLES);
  113.     glNormal3f (nx, ny, nz);
  114.     glVertex3f (x1, y1, z1);
  115.     glVertex3f (x2, y2, z2);
  116.     glVertex3f (x3, y3, z3);
  117.     glEnd ();
  118. }
  119. void draw3DLine (float x1, float y1, float z1,
  120.  float x2, float y2, float z2)
  121. {
  122.     glBegin (GL_LINES);
  123.     glVertex3f (x1, y1, z1);
  124.     glVertex3f (x2, y2, z2);
  125.     glEnd ();
  126. }
  127. void draw2DLine (float x1, float y1,
  128.  float x2, float y2)
  129. {
  130.     glBegin (GL_LINES);
  131.     glVertex2f (x1, y1);
  132.     glVertex2f (x2, y2);
  133.     glEnd ();
  134. }
  135. #ifdef __cplusplus
  136. }
  137. #endif
  139. // Sets up lighting in OpenGL but does not enable it.
  140. // Lighting will be enabled in ::renderTeximageMap().
  141. static void initLights ()
  142. {
  143.     GLfloat light_ambient[]  = {.5f, .5f, .5f, 1.f};
  144.     GLfloat light_specular[] = {0.f, 0.f, 0.f, 1.f};
  145.     GLfloat light_diffuse[]  = {1.f, 1.f, 1.f, 1.f};
  146.     GLfloat light_position[] = {1.f, .5f, 1.f, 0.f}; /* w=0 ==> directional */
  148.     glLightfv (GL_LIGHT1, GL_POSITION, light_position);
  149.     glLightfv (GL_LIGHT1, GL_DIFFUSE, light_diffuse);
  150.     glLightfv (GL_LIGHT1, GL_SPECULAR, light_specular);
  152.     glLightModelfv (GL_LIGHT_MODEL_AMBIENT, light_ambient);
  153.     glEnable (GL_LIGHT1);
  154.     glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
  155.     glEnable (GL_COLOR_MATERIAL);
  156. }
  159. /////////////////////////////////////////////////////////////////////////////
  160. // CFractalExampleView message handlers
  162. void CFractalExampleView::OnInitialUpdate() 
  163. {
  164. COpenGLView::OnInitialUpdate();
  166. // Probably not the best place in the world to 
  167. // initialize all this stuff. But it works for me.
  168. // And after all, this is a hack, isn't it?
  170.     glPixelStorei(GL_PACK_ALIGNMENT, 1);
  171.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  173. //* Default values you see in the View Options dialog box.
  174. colorInvert = FALSE;
  175. iterations = 2;
  176. cloudIter = 5;
  177. teximageIter = 8;
  178. renderMode = twoDR_lines;
  179. arrayIs2D = TRUE;
  180. tile = 1;
  181. randomSeed = 0;
  182. aaLines = TRUE;
  183. textureLinear = TRUE;
  185. // Initial rotations, translations, and a toggle for 
  186. // the shift key status.
  187. shiftKeyStatus = FALSE;
  188. yRot = 0.f;
  189. yTrans = -.5f;
  190. zTrans = -3.f;
  192. // Ptrs to data and dirty flags. Initially, all 
  193. // are NULL and dirty.
  194. surfFA = NULL;
  195. surfFAdirty = TRUE;
  196. teximageFA = NULL;
  197. teximageFAdirty = TRUE;
  198. cloudFA = NULL;
  199. cloudFAdirty = TRUE;
  201. cloudH = surfaceH = teximageH = 0.7f;
  202. }
  204. // surfToSky
  205. //
  206. // Converts a 2D fract array into a nice blue and white
  207. // cloudy sky texture map. First, it finds the average height
  208. // value in the map. Then it clamps values to +/- SKY_LIMIT
  209. // around the average value. Values in the array are then
  210. // mapped from a medium blue to white. The resulting RGB 
  211. // values are stored in skyTex.
  212. //
  213. // Note that while the fract array is assumed to have dimension
  214. // (size+1)X(size+1), skyTex must have dimension sizeXsize.
  215. // This facilitates its being used as an OpenGL texture map.
  216. static void surfToSky (float *fa, int size, GLubyte *skyTex)
  217. {
  218.     int i, j;
  219.     const int subSize = size;
  220.     unsigned char *skyptr;
  221.     float shadeFactor;
  222.     float skyAv=0.f;
  224.     size++;
  225.     for (i=0; i<size*size; i++)
  226. skyAv += fa[i];
  227. skyAv /= (float)(size*size);
  229. #define SKY_LIMIT 0.2f
  230.     skyptr = skyTex;
  231.     for (i=0; i<subSize; i++) {
  232. for (j=0; j<subSize; j++) {
  233. if (fa[i*size+j] < (skyAv - SKY_LIMIT))
  234. shadeFactor = -SKY_LIMIT;
  235. else if (fa[i*size+j] > (skyAv + SKY_LIMIT))
  236. shadeFactor = SKY_LIMIT;
  237. else
  238. shadeFactor = fa[i*size+j] - skyAv;
  240. /* shadeFactor is now in range -SKY_LIMIT - SKY_LIMIT.
  241.    scale shadeFactor to range 0.0 - 0.5 */
  242. shadeFactor = ((shadeFactor + SKY_LIMIT) *
  243.    (.5f / (2.f * SKY_LIMIT)));
  245. /* Make red and green range from 0.41 - 0.9 */
  246. skyptr[0] = (GLubyte)((.4 + shadeFactor) * 255); /* red */
  247. skyptr[1] = (GLubyte)((.4 + shadeFactor) * 255); /* green */
  248. skyptr[2] = (GLubyte)(.9 * 255.); /* blue */
  250. skyptr += 3;
  251. }
  252.     }
  253. }
  255. // renderCloudMap
  256. //
  257. // Render the cloud texture map. If the cloud fract array
  258. // doesn't already exist, allocate it, tesselate it, and
  259. // create the texture map using surfToSky. Then create a 
  260. // display list with this texture map in the list.
  261. //
  262. // Once we have the texture map, we simply draw a quad as
  263. // big as will fit in the window, with the cloud texture map
  264. // applied to it.
  265. BOOL CFractalExampleView::renderCloudMap ()
  266. {
  267. CWaitCursor hourglass;
  268.     int size = 1 << cloudIter;
  270. if (cloudFA && cloudFAdirty) {
  271. freeFractArray (cloudFA);
  272. cloudFA = NULL;
  273. }
  274. if (!cloudFA) {
  275. cloudFA = alloc2DFractArray (size);
  276. if (cloudFA==NULL) return (FALSE);
  277. fill2DFractArray (cloudFA, size, randomSeed,
  278. DEF_HEIGHT_SCALE, cloudH);
  279. }
  281. glPushAttrib (0xfffffff);
  283. if (cloudFAdirty) {
  284. GLubyte *tmap;
  286. tmap = (GLubyte *) malloc (size*size*3);
  287. if (tmap==NULL) return (FALSE);
  289. surfToSky (cloudFA, size, tmap);
  291. glNewList (CLOUDMAP, GL_COMPILE);
  293. glTexImage2D (GL_TEXTURE_2D, 0, /* lod */
  294.       3, /* num components */
  295.       size, size, /* width, height */
  296.       0, /* border */
  297.       GL_RGB, GL_UNSIGNED_BYTE, /* format, type */
  298.       tmap);
  300. glEndList ();
  302. free (tmap);
  303. }
  304. glCallList (CLOUDMAP);
  306. glMatrixMode (GL_PROJECTION);
  307.     glLoadIdentity ();
  308. if (currentWidth > currentHeight)
  309. glOrtho (-1.f, aspectRatio*2.f-1.f,
  310. -1.f, 1.f, 1., -1.);
  311. else 
  312.   glOrtho (-1.f, 1.f,
  313. -1.f, 2.f/aspectRatio-1.f, 1., -1.);
  314. glMatrixMode (GL_MODELVIEW);
  315.     glLoadIdentity ();
  317. glDisable (GL_DEPTH_TEST);
  318. glDisable (GL_FOG);
  319. glDisable (GL_LIGHTING);
  320. glDisable (GL_BLEND);
  321. glEnable (GL_TEXTURE_2D);
  322.     
  323. glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, 
  324. (GLfloat) GL_REPLACE);
  325. glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
  326. (GLfloat) GL_NEAREST);
  327. glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
  328. (GLfloat) GL_NEAREST);
  330. glClear (GL_COLOR_BUFFER_BIT);
  332. glBegin (GL_QUADS); {
  333. glTexCoord2f (0.f, 0.f); glVertex2f (-1.f, -1.f);
  334. glTexCoord2f (1.f, 0.f); glVertex2f (1.f, -1.f);
  335. glTexCoord2f (1.f, 1.f); glVertex2f (1.f, 1.f);
  336. glTexCoord2f (0.f, 1.f); glVertex2f (-1.f, 1.f);
  337. } glEnd ();
  338. glFlush ();
  340. glPopAttrib ();
  342. cloudFAdirty = FALSE;
  343. return (TRUE);
  344. }
  346. // setH1H2
  347. //
  348. // The h1 and h2 parameters are set to 1/3 and 2/3 of the
  349. // height values stored in the 2D fract array. These values
  350. // are then used in our rinky-dink-but-effective coloring,
  351. // scheme wherein the lower 1/3 of terrain is colored dark
  352. // green, the middle third is colored grey, and the upper
  353. // third is white.
  354. void setH1H2 (float *fa, int size, float *h1, float *h2)
  355. {
  356.     float min, max;
  357.     int i;
  359.     size++;
  360.     min = 2.f;
  361.     max = -2.f;
  362.     for (i=0; i<size*size; i++) {
  363. if (fa[i] > max)
  364.     max = fa[i];
  365. else if (fa[i] < min)
  366.     min = fa[i];
  367.     }
  368.     *h1 = (max - min) * .66f + min;
  369.     *h2 = (max - min) * .33f + min;
  370. }
  372. // SET_COLOR -- Based on the height value, set the current 
  373. // color to dark green, grey, or white.
  374. #define SET_COLOR(h,h1,h2)
  375. { 
  376.     if (h > h1) 
  377. glColor3f (.95f, .95f, 1.f); 
  378.     else if (h > h2) 
  379. glColor3f (.55f, .55f, .6f); 
  380.     else 
  381. glColor3f (.2f, .4f, .2f); 
  382. }
  384. // TEXCOORD -- Based on the current values of X and Z passed
  385. // in as U and V, Set the texture coordinate. Sinze X and Z
  386. // could range from -1.0 to 1.0, this is simply a matter of
  387. // adding 1 and dividing by 2.
  388. #define TEXCOORD(u,v) 
  389.     glTexCoord2f ((u+1.f)*.5f, -((v-1.f)*.5f))
  391. // getNormal
  392. //
  393. // Given the three vertices of a triangle, return a surface
  394. // normal to that triangle.
  395. static void getNormal (float x1, float y1, float z1,
  396.        float x2, float y2, float z2,
  397.        float x3, float y3, float z3,
  398.        float *normal)
  399. {
  400.     float len;
  401.     float v1x, v1y, v1z;
  402.     float v2x, v2y, v2z;
  405.     v1x = x2 - x1;
  406.     v1y = y2 - y1;
  407.     v1z = z2 - z1;
  408.     v2x = x3 - x1;
  409.     v2y = y3 - y1;
  410.     v2z = z3 - z1;
  412.     normal[0] = v1y*v2z - v1z*v2y;
  413.     normal[1] = v1z*v2x - v1x*v2z;
  414.     normal[2] = v1x*v2y - v1y*v2x;
  416.     len = (float) sqrt (normal[0]*normal[0] + normal[1]*normal[1] +
  417. normal[2]*normal[2]);
  419.     normal[0] /= len;
  420.     normal[1] /= len;
  421.     normal[2] /= len;
  422. }
  424. // genNormal
  425. //
  426. // Use getNormal to get the Normal for the specified triangle.
  427. // Then set the current normal in OpenGL.
  428. static void genNormal (float x1, float y1, float z1,
  429.        float x2, float y2, float z2,
  430.        float x3, float y3, float z3)
  431. {
  432.     float norm[3];
  434.     getNormal (x1, y1, z1,
  435.        x2, y2, z2,
  436.        x3, y3, z3, norm);
  437.     glNormal3f (norm[0], norm[1], norm[2]);
  438. }
  440. // renderAsTriangle
  441. //
  442. // As far as OpenGL efficiency goes, this routine will be better
  443. // than fractmod.c's draw2DFractArrayAsTriangles because it uses
  444. // the triangle strip primitive. If the "lights" param is non-zero,
  445. // surface normals are specified. If the "dotex" param is non-zero,
  446. // texture coordinates are sprcified.
  447. static void renderAsTriangles (float *fa, int sz,
  448.        int lights, int dotex)
  449. {
  450. float h1, h2;
  451.     int i, j;
  452.     float x, z, inc;
  453.     const int subSize = sz, superSize = sz+1;
  455. // h1 and h2 will be 1/3 and 2/3 of our height
  456. // values. The SET_COLOR macro uses this to determine
  457. // the syrface color for a given height.
  458.   setH1H2 (fa, subSize, &h1, &h2);
  460. inc = 2.f / subSize;
  461.     z = -1.f;
  462.     for (i=0; i<subSize; i++) {
  463. glBegin (GL_TRIANGLE_STRIP);
  464. x = -1.f, j=0;
  465. if (dotex)
  466. TEXCOORD (x, z);
  467. else {
  468. if (lights)
  469. genNormal (x, fa[i*superSize+j], z,
  470.    x, fa[(i+1)*superSize+j], z+inc,
  471.    x+inc, fa[i*superSize+j+1], z);
  472. SET_COLOR (fa[i*superSize+j], h1, h2);
  473. }
  474. glVertex3f (x, fa[i*superSize+j], z);
  475. if (dotex)
  476.     TEXCOORD (x, z+inc);
  477. else {
  478.     if (lights)
  479. genNormal (x, fa[(i+1)*superSize+j], z+inc,
  480.    x+inc, fa[(i+1)*superSize+j+1], z+inc,
  481.    x+inc, fa[i*superSize+j+1], z);
  482.     SET_COLOR (fa[(i+1)*superSize+j], h1, h2);
  483. }
  484. glVertex3f (x, fa[(i+1)*superSize+j], z+inc);
  485. for (; j<subSize; j++) {
  486. if (dotex)
  487. TEXCOORD (x+inc, z);
  488.     else {
  489. if (lights)
  490. genNormal (x, fa[(i*superSize)+j], z,
  491.        x, fa[(i+1)*superSize+j], z+inc,
  492.        x+inc, fa[i*superSize+j+1], z);
  493. SET_COLOR (fa[i*superSize+j+1], h1, h2);
  494.     }
  495.     glVertex3f (x+inc, fa[i*superSize+j+1], z);
  496. if (dotex)
  497. TEXCOORD (x+inc, z+inc);
  498.     else {
  499. if (lights)
  500. genNormal (x, fa[(i+1)*superSize+j], z+inc,
  501.        x+inc, fa[(i+1)*superSize+j+1], z+inc,
  502.        x+inc, fa[i*superSize+j+1], z);
  503. SET_COLOR (fa[(i+1)*superSize+j+1], h1, h2);
  504. }
  505.     glVertex3f (x+inc, fa[(i+1)*superSize+j+1], z+inc);
  506.     x += inc;
  507. }
  508. z += inc;
  509. glEnd ();
  510.     }
  511. }
  513. // renderTeximageMap
  514. //
  515. // If the teximage map is dirty, allocate and tesselate a new
  516. // one. Render it to the screen as lit triangles. Read the
  517. // image back and set it as a texture map in a display list.
  518. BOOL CFractalExampleView::renderTeximageMap ()
  519. {
  520. CWaitCursor hourglass;
  521.     int size = 1 << teximageIter;
  522. UINT pmapDim, smallDim;
  524. if (teximageFA && teximageFAdirty) {
  525. freeFractArray (teximageFA);
  526. teximageFA = NULL;
  527. }
  528. if (!teximageFA) {
  529. teximageFA = alloc2DFractArray (size);
  530. if (teximageFA==NULL) return (FALSE);
  531. fill2DFractArray (teximageFA, size, randomSeed,
  532. DEF_HEIGHT_SCALE, teximageH);
  533. }
  535. // Find the biggest power of two that will fit
  536. // in the current window. This is where we will 
  537. // draw the image.
  538. smallDim = (currentWidth > currentHeight) ?
  539. currentHeight : currentWidth;
  540. pmapDim = 1 << (UINT) (log ((float) smallDim) / log (2.));
  542. glPushAttrib (0xfffffff);
  544. // Only draw into biggest power of 2 square.
  545. glViewport (0, 0, pmapDim, pmapDim);
  546. glMatrixMode (GL_PROJECTION);
  547.     glLoadIdentity ();
  548. glOrtho (-1.f, 1.f,
  549. -1.f, 1.f, 1., -1.);
  550. glMatrixMode (GL_MODELVIEW);
  551.     glLoadIdentity ();
  552. // The array is rendered into the XZ plane. We need to
  553. // rotate by 90 degrees so we will be looking at it
  554. // "top down".
  555. glRotatef (90.f, 1.f, 0.f, 0.f);
  556. // Init lights now. Light position must be specified
  557. // after the rotate, or else it won't be rotated.
  558. initLights ();
  560. glDisable (GL_DEPTH_TEST);
  561. glDisable (GL_FOG);
  562. glEnable (GL_LIGHTING);
  563. glDisable (GL_BLEND);
  564.     
  565. glClear (GL_COLOR_BUFFER_BIT);
  567. renderAsTriangles (teximageFA, size, 1, 0);
  568. glFlush ();
  570. glPopAttrib ();
  573. if (teximageFAdirty) {
  574. GLubyte *pmap;
  576. pmap = (GLubyte *) malloc (pmapDim*pmapDim*3);
  577. if (pmap==NULL) return (FALSE);
  579. glReadPixels (0, 0, pmapDim, pmapDim,
  580.       GL_RGB, GL_UNSIGNED_BYTE, pmap);
  582. glNewList (TEXIMAGEMAP, GL_COMPILE);
  583. glTexImage2D (GL_TEXTURE_2D, 0, /* lod */
  584.       3, /* num components */
  585.       pmapDim, pmapDim, /* width, height */
  586.       0, /* border */
  587.       GL_RGB, GL_UNSIGNED_BYTE, /* format, type */
  588.       pmap);
  590. glEndList ();
  592. free (pmap);
  593. }
  595. teximageFAdirty = FALSE;
  596. return (TRUE);
  597. }
  599. // renderFullImage
  600. //
  601. // First we render the sky. If the sky fract array is dirty,
  602. // we make a new one by calling renderCloudMap. The sky is
  603. // rendering as an 8-sided pyramid.
  604. // The apex is at (0,2,0), just above
  605. // the origin. The base of the eight walls are positioned
  606. // roughly in a circle of radius 15, in the XZ plane, around
  607. // the point (0,-1,0). Fig is enabled for the sky with a fog
  608. // range of (3,11). For speed, no Z buffering when rendering
  609. // the sky.
  610. // 
  611. // Then, we render the surface fract array for as many times
  612. // as it is tiled, and it is texture mapped with the teximage
  613. // map. If the teximage map is dirty, we make a clean one by
  614. // calling renderTeximageMap.
  615. BOOL CFractalExampleView::renderFullImage ()
  616. {
  617. CWaitCursor hourglass;
  618.     int size = 1 << iterations;
  619. GLfloat fogColor[4] = {.84f, .87f, 1.f, 1.f};
  621. // Validate the surface texture map
  622. if (teximageFAdirty)
  623. renderTeximageMap ();
  624. // validate the cloud texture map
  625. if (cloudFAdirty)
  626. renderCloudMap ();
  628. // validate the surface
  629. if (surfFA && surfFAdirty) {
  630. freeFractArray (surfFA);
  631. surfFA = NULL;
  632. }
  633. if (!surfFA) {
  634. surfFA = alloc2DFractArray (size);
  635. if (surfFA==NULL) return (FALSE);
  636. fill2DFractArray (surfFA, size, randomSeed,
  637. DEF_HEIGHT_SCALE, surfaceH);
  638. surfFAdirty = FALSE;
  639. }
  641. glMatrixMode (GL_PROJECTION);
  642.     glLoadIdentity ();
  643. gluPerspective (60., aspectRatio, .1, 15.0);
  644.     glMatrixMode (GL_MODELVIEW);
  645.     glLoadIdentity ();
  646. glTranslatef (0.f, yTrans, zTrans);
  647.     glRotatef (yRot, 0.f, 1.f, 0.f);
  649. glPushAttrib (0xffffffff);
  651. // fog range will be 3 to 11 for sky, but will
  652. // be a little closer when we render the terrain.
  653. // This creates that nice kind of true atmospheric
  654. // effect when looking through more air (along
  655. // the horizon) as opposed to straight up.
  656. glFogf (GL_FOG_DENSITY, 1.f);
  657. glFogf (GL_FOG_START, 3.f);
  658. glFogf (GL_FOG_END, 11.f);
  659. glFogi (GL_FOG_MODE, GL_LINEAR);
  660. glFogfv (GL_FOG_COLOR, fogColor);
  661. glEnable (GL_FOG);
  663. glDisable (GL_DITHER);
  664. // invertColors doesn't apply here; clear to fog color.
  665. glClearColor (fogColor[0], fogColor[1], fogColor[2], 1.f);
  666. glClear (GL_COLOR_BUFFER_BIT |
  667. GL_DEPTH_BUFFER_BIT);
  669. glDisable (GL_LIGHTING);
  670. glDisable (GL_DEPTH_TEST);
  672. // Goes a little faster but looks like crud:
  673. //glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
  674. glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, 
  675. (GLfloat) GL_REPLACE);
  676. glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
  677. textureLinear ? (GLfloat) GL_LINEAR
  678. : (GLfloat) GL_NEAREST);
  679. glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
  680. textureLinear ? (GLfloat) GL_LINEAR
  681. : (GLfloat) GL_NEAREST);
  682. glEnable (GL_TEXTURE_2D);
  684. glCallList (CLOUDMAP);
  685. // TMMAX defines texture map wrapping.
  686. #define TMMAX 3.f // wrap from -3 to 3, or six times across our pyramid
  687. #define TMMAX45 (TMMAX * 0.707f) // roughly sine(TMMAX)
  688. // Kludgey, but it works:
  689. // This is an 8-sided pyramid covered with the cloud
  690. // texture, wrapped 4 times.
  691. glBegin (GL_TRIANGLE_FAN); {
  692. glTexCoord2f (0.f, 0.f); glVertex3f (0.f, 2.f, 0.f);
  693. glTexCoord2f (-TMMAX45, -TMMAX45); glVertex3f (-10.f, -1.f, 10.f);
  694. glTexCoord2f (0.f, -TMMAX); glVertex3f (0.f, -1.f, 15.f);
  695. glTexCoord2f (TMMAX45, -TMMAX45); glVertex3f (10.f, -1.f, 10.f);
  696. glTexCoord2f (TMMAX, 0.f); glVertex3f (15.f, -1.f, 0.f);
  697. glTexCoord2f (TMMAX45, TMMAX45); glVertex3f (10.f, -1.f, -10.f);
  698. glTexCoord2f (0.f, TMMAX); glVertex3f (0.f, -1.f, -15.f);
  699. glTexCoord2f (-TMMAX45, TMMAX45); glVertex3f (-10.f, -1.f, -10.f);
  700. glTexCoord2f (-TMMAX, 0.f); glVertex3f (-15.f, -1.f, 0.f);
  701. glTexCoord2f (-TMMAX45, -TMMAX45); glVertex3f (-10.f, -1.f, 10.f);
  702. } glEnd ();
  704. // Don't need depth test for sky but turn it on for
  705. // rendering the height map because I'm too lazy to do
  706. // painter's algorithm.
  707. glEnable (GL_DEPTH_TEST);
  708. glEnable (GL_CULL_FACE);
  710. // Here's the tighter fog range for the surface.
  711. glFogf (GL_FOG_START, 2.f);
  712. glFogf (GL_FOG_END, 7.f);
  714. // surface texture map
  715. glCallList (TEXIMAGEMAP);
  717. float x, z;
  718. UINT i, j;
  720. z = -1.f * (float) (tile-1);
  721. for (i=0; i<tile; i++) {
  722. x = -1.f * (float) (tile-1);
  723. for (j=0; j<tile; j++) {
  724. glPushMatrix ();
  725. glTranslatef (x, 0.f, z);
  727. renderAsTriangles (surfFA, size, 0, 1);
  729. glPopMatrix ();
  730. x += 2.f;
  731. }
  732. z += 2.f;
  733. }
  735. glPopAttrib ();
  737. return (TRUE);
  738. }
  740. // RenderScene
  741. //
  742. // This function overrides the same function in COpenGLView.
  743. // Here we handle rendering 1D midpoint displacement or 2D mesh
  744. // / lines, both of which are line rendering modes. If our
  745. // renderMode variable is set to anything else, we call
  746. // another function to handle the rendering. BOOL CFractalExampleView::RenderScene() {
  747.     int size = 1 << iterations;
  748. GLfloat black[4] = {0.f, 0.f, 0.f, 1.f};
  749. GLfloat white[4] = {1.f, 1.f, 1.f, 1.f};
  751. // Handle inverted colors.
  752. if (colorInvert)
  753.     glClearColor (black[0], black[1], black[2], black[3]);
  754. else
  755.     glClearColor (white[0], white[1], white[2], white[3]);
  757. // Handle non line mode renderMode settings.
  758. if (renderMode == twoDR_clouds)
  759. return (renderCloudMap ());
  760. else if (renderMode == twoDR_teximage)
  761. return (renderTeximageMap ());
  762. else if (renderMode == twoDR_rendered)
  763. return (renderFullImage ());
  765. // Shouldn't take too long, unless drawing huge
  766. // AA scenes, but what the heck...
  767. CWaitCursor hourglass;
  769. glMatrixMode (GL_PROJECTION);
  770.     glLoadIdentity ();
  771. if (arrayIs2D)
  772. // Needs to be identical to the same call in renderFullScene.
  773.     gluPerspective (60., aspectRatio, .1, 15.0);
  774. else
  775. glOrtho (-aspectRatio, aspectRatio, -1., 1., 1., -1.);
  776.     glMatrixMode (GL_MODELVIEW);
  777.     glLoadIdentity ();
  778. if (arrayIs2D) {
  779.     glTranslatef (0.f, yTrans, zTrans);
  780. glRotatef (yRot, 0.f, 1.f, 0.f);
  781. }
  783. glPushAttrib (0xffffffff);
  785. glDisable (GL_DEPTH_TEST);
  786. glDisable (GL_LIGHTING);
  787. if (colorInvert)
  788. glColor4fv (white);
  789. else
  790. glColor4fv (black);
  792. if (aaLines) {
  793. glEnable (GL_LINE_SMOOTH);
  794. glEnable (GL_BLEND);
  795. glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  796. }
  797. else {
  798. glDisable (GL_LINE_SMOOTH);
  799. glDisable (GL_BLEND);
  800. }
  801.     
  802. glClear (GL_COLOR_BUFFER_BIT |
  803. GL_DEPTH_BUFFER_BIT);
  805. if (arrayIs2D) {
  806. float x, z;
  807. UINT i, j;
  809. // validate surface
  810. if (surfFA && surfFAdirty) {
  811. freeFractArray (surfFA);
  812. surfFA = NULL;
  813. }
  814. if (!surfFA) {
  815. surfFA = alloc2DFractArray (size);
  816. if (surfFA==NULL) return (FALSE);
  817. fill2DFractArray (surfFA, size, randomSeed,
  818. DEF_HEIGHT_SCALE, surfaceH);
  819. surfFAdirty = FALSE;
  820. }
  822. z = -1.f * (float) (tile-1);
  823. for (i=0; i<tile; i++) {
  824. x = -1.f * (float) (tile-1);
  825. for (j=0; j<tile; j++) {
  826. glPushMatrix ();
  827. glTranslatef (x, 0.f, z);
  829. draw2DFractArrayAsLines (surfFA, size);
  831. glPopMatrix ();
  832. x += 2.f;
  833. }
  834. z += 2.f;
  835. }
  836. }
  837. else {
  838. float x;
  839. UINT i;
  840.     float *fa;
  842. // Always validate and free 1D array.
  843. // We won't be doing any realtime transformations on it.
  844. fa = alloc1DFractArray (size);
  845. if (fa==NULL) return (FALSE);
  846. fill1DFractArray (fa, size, randomSeed,
  847. DEF_HEIGHT_SCALE, surfaceH);
  849. x = -1.f * (float) (tile-1);
  850. for (i=0; i<tile; i++) {
  852. glPushMatrix ();
  853. glTranslatef (x, 0.f, 0.f);
  855. draw1DFractArrayAsLines (fa, size);
  857. glPopMatrix ();
  858. x += 2.f;
  859. }
  861. freeFractArray (fa);
  862. }
  864. glFlush();
  865. glPopAttrib ();
  867. return (TRUE);
  868. }
  869. // OnViewOptions
  870. //
  871. // Handles dialog box paramter changes and records them in the View.
  872. void CFractalExampleView::OnViewOptions() 
  873. {
  874. CFractalOptionsDlg dlg;
  875. CString oneD = "1D midpoint displacement";
  876. CString twoDLines = "2D mesh / lines";
  877. CString twoDClouds = "2D mesh / clouds";
  878. CString twoDTeximage = "2D mesh / teximage";
  879. CString twoDRendered = "2D mesh / rendered";
  881. dlg.m_invert = colorInvert;
  882. dlg.m_aaLines = aaLines;
  883. dlg.m_textureLinear = textureLinear;
  884. dlg.m_randomSeed = randomSeed;
  885. dlg.m_tile = tile;
  886. dlg.m_iterations = iterations;
  887. dlg.m_cloudIter = cloudIter;
  888. dlg.m_teximageIter = teximageIter;
  889. if (!arrayIs2D)
  890. dlg.m_renderType = oneD;
  891. else if (renderMode == twoDR_lines)
  892. dlg.m_renderType = twoDLines;
  893. else if (renderMode == twoDR_clouds)
  894. dlg.m_renderType = twoDClouds;
  895. else if (renderMode == twoDR_teximage)
  896. dlg.m_renderType = twoDTeximage;
  897. else if (renderMode == twoDR_rendered)
  898. dlg.m_renderType = twoDRendered;
  899. dlg.m_cloudH = cloudH;
  900. dlg.m_surfaceH = surfaceH;
  901. dlg.m_teximageH = teximageH;
  903. if (dlg.DoModal () == IDOK) {
  904. teximageFAdirty = (teximageFAdirty ||
  905. (teximageH != dlg.m_teximageH) ||
  906. (randomSeed != dlg.m_randomSeed) ||
  907. (teximageIter != dlg.m_teximageIter));
  908. surfFAdirty = (surfFAdirty ||
  909. (surfaceH != dlg.m_surfaceH) ||
  910. (randomSeed != dlg.m_randomSeed) ||
  911. (iterations != dlg.m_iterations));
  912. cloudFAdirty = (cloudFAdirty ||
  913. (cloudH != dlg.m_cloudH) ||
  914. (randomSeed != dlg.m_randomSeed) ||
  915. (cloudIter != dlg.m_cloudIter));
  917. colorInvert = dlg.m_invert;
  918. aaLines = dlg.m_aaLines;
  919. textureLinear = dlg.m_textureLinear;
  920. randomSeed = dlg.m_randomSeed;
  921. tile = dlg.m_tile;
  922. iterations = dlg.m_iterations;
  923. cloudIter = dlg.m_cloudIter;
  924. teximageIter = dlg.m_teximageIter;
  926. arrayIs2D = !(dlg.m_renderType == oneD);
  928. if (dlg.m_renderType == twoDClouds)
  929. renderMode = twoDR_clouds;
  930. else if (dlg.m_renderType == twoDTeximage)
  931. renderMode = twoDR_teximage;
  932. else if (dlg.m_renderType == twoDRendered)
  933. renderMode = twoDR_rendered;
  934. else // default: if (dlg.m_renderType == twoDLines)
  935. renderMode = twoDR_lines;
  937. cloudH = dlg.m_cloudH;
  938. surfaceH = dlg.m_surfaceH;
  939. teximageH = dlg.m_teximageH;
  942. OnDraw ( GetDC() );
  943. }
  944. }
  946. //OnSize
  947. //
  948. // Handles resize events. Records width, height, and 
  949. //aspectRatio in the View. void CFractalExampleView::OnSize (UINT nType, int cx, int cy) { CView::OnSize(nType, cx, cy);
  951. if (0 >= cx || 0 >= cy)
  952. return;
  954. currentWidth = cx;
  955. currentHeight = cy;
  956. glViewport(0, 0, cx, cy);
  958. // compute the aspect ratio
  959. // this will keep all dimension scales equal
  960. aspectRatio = (float)cx/(float)cy;
  961. }
  962. // OnKeyDown
  963. //
  964. // Translates keypress events to rotations or translations
  965. // which are then recorded in the View object.
  966. void CFractalExampleView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  967. {
  968. BOOL needRedraw = FALSE;
  970. switch (nChar) {
  971. case VK_LEFT:
  972. yRot += 3.f;
  973. needRedraw = TRUE;
  974. break;
  975. case VK_UP:
  976. if (shiftKeyStatus)
  977. yTrans += .05f;
  978. else
  979. zTrans += .05f;
  980. needRedraw = TRUE;
  981. break;
  982. case VK_RIGHT:
  983. yRot -= 3.f;
  984. needRedraw = TRUE;
  985. break;
  986. case VK_DOWN:
  987. if (shiftKeyStatus)
  988. yTrans -= .05f;
  989. else
  990. zTrans -= .05f;
  991. needRedraw = TRUE;
  992. break;
  993. case VK_SHIFT:
  994. shiftKeyStatus = TRUE;
  995. return;
  996. }
  998. if (needRedraw) {
  999. OnDraw ( GetDC() );
  1000. return;
  1001. }
  1002. else
  1003. // Let parent class handle other keys.
  1004. COpenGLView::OnKeyDown(nChar, nRepCnt, nFlags);
  1005. }
  1007. // OnKeyUp
  1008. //
  1009. // Tracks state of the shift key. There's got to be a better
  1010. // way to tell whether a key is shifted or not than by
  1011. // tracking press and release events on the shift key.
  1012. void CFractalExampleView::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) 
  1013. {
  1014. switch (nChar) {
  1015. case VK_SHIFT:
  1016. shiftKeyStatus = FALSE;
  1017. return;
  1018. }
  1019. COpenGLView::OnKeyUp(nChar, nRepCnt, nFlags);
  1020. }
  1022. // OnDestroy
  1023. //
  1024. // Free all that memory.
  1025. void CFractalExampleView::OnDestroy() 
  1026. {
  1027. COpenGLView::OnDestroy();
  1029. if (surfFA) 
  1030. freeFractArray (surfFA);
  1031. if (teximageFA) 
  1032. freeFractArray (teximageFA);
  1033. if (cloudFA)
  1034. freeFractArray (cloudFA);
  1035. }