DirectX 3D 基本框架(四)

继续扩展原来的D3D基本框架。这次将添加地形类库。做出如下修改:

1.增加一个terrain头/库文件。

代码清单:

1. //
2. // 
3. // File: terrain.h
4. // 
5. // by tianzhihen
6. //
7. // 2008.10.27, MSVC++ 8.0 
8. //          
9. //
11. #ifndef __terrainH__
12. #define __terrainH__
14. #include "d3dUtility.h"
15. #include <string>
16. #include <vector>
18. class Terrain
19. {
20. public:
21.     Terrain(
22.         IDirect3DDevice9* device,
23.         std::string heightmapFileName, 
24.         int numVertsPerRow,  
25.         int numVertsPerCol, 
26.         int cellSpacing,    // space between cells
27.         float heightScale);   
29.     ~Terrain();
31.     int  getHeightmapEntry(int row, int col);
32.     void setHeightmapEntry(int row, int col, int value);
34.     float getHeight(float x, float z);
36.     bool  loadTexture(std::string fileName);
37.     bool  genTexture(D3DXVECTOR3* directionToLight);
38.     bool  draw(D3DXMATRIX* world, bool drawTris);
40. private:
41.     IDirect3DDevice9*       _device;
42.     IDirect3DTexture9*      _tex;
43.     IDirect3DVertexBuffer9* _vb;
44.     IDirect3DIndexBuffer9*  _ib;
46.     int _numVertsPerRow;
47.     int _numVertsPerCol;
48.     int _cellSpacing;
50.     int _numCellsPerRow;
51.     int _numCellsPerCol;
52.     int _width;
53.     int _depth;
54.     int _numVertices;
55.     int _numTriangles;
57.     float _heightScale;
59.     std::vector<int> _heightmap;
61.     // 帮助器函数
62.     bool  readRawFile(std::string fileName);
63.     bool  computeVertices();
64.     bool  computeIndices();
65.     float computeShade(int cellRow, int cellCol, D3DXVECTOR3* directionToLight);
67.     struct TerrainVertex
68.     {
69.         TerrainVertex(){}
70.         TerrainVertex(float x, float y, float z, float u, float v)
71.         {
72.             _x = x; _y = y; _z = z; _u = u; _v = v;
73.         }
74.         float _x, _y, _z;
75.         float _u, _v;
77.         static const DWORD FVF;
78.     };
79. };
81. #endif // __terrainH__

1. //
2. // 
3. // File: terrain.cpp
4. // 
5. // by tianzhihen
6. //
7. // 2008.10.27, MSVC++ 8.0 
8. //          
9. //
11. #include "terrain.h"
12. #include <fstream>
13. #include <cmath>
15. const DWORD Terrain::TerrainVertex::FVF = D3DFVF_XYZ | D3DFVF_TEX1;
17. Terrain::Terrain(IDirect3DDevice9* device,
18.                  std::string heightmapFileName,
19.                  int numVertsPerRow,
20.                  int numVertsPerCol,
21.                  int cellSpacing,
22.                  float heightScale)
23. {
24.     _device         = device;
25.     _numVertsPerRow = numVertsPerRow;
26.     _numVertsPerCol = numVertsPerCol;
27.     _cellSpacing    = cellSpacing;
29.     _numCellsPerRow = _numVertsPerRow - 1;
30.     _numCellsPerCol = _numVertsPerCol - 1;
32.     _width = _numCellsPerRow * _cellSpacing;
33.     _depth = _numCellsPerCol * _cellSpacing;
35.     _numVertices  = _numVertsPerRow * _numVertsPerCol;
36.     _numTriangles = _numCellsPerRow * _numCellsPerCol * 2;
38.     _heightScale = heightScale;
40.     // 加载高度图
41.     if( !readRawFile(heightmapFileName) )
42.     {
43.         ::MessageBox(0, "readRawFile - FAILED", 0, 0);
44.         ::PostQuitMessage(0);
45.     }
47.     // 缩放高度
48.     for(int i = 0; i < _heightmap.size(); i++)
49.         _heightmap[i] *= heightScale;
51.     // 计算顶点坐标
52.     if( !computeVertices() )
53.     {
54.         ::MessageBox(0, "computeVertices - FAILED", 0, 0);
55.         ::PostQuitMessage(0);
56.     }
58.     // 计算索引坐标
59.     if( !computeIndices() )
60.     {
61.         ::MessageBox(0, "computeIndices - FAILED", 0, 0);
62.         ::PostQuitMessage(0);
63.     }
64. }
66. Terrain::~Terrain()
67. {
68.     d3d::Release<IDirect3DVertexBuffer9*>(_vb);
69.     d3d::Release<IDirect3DIndexBuffer9*>(_ib);
70.     d3d::Release<IDirect3DTexture9*>(_tex);
71. }
73. int Terrain::getHeightmapEntry(int row, int col)
74. {
75.     return _heightmap[row * _numVertsPerRow + col];
76. }
78. void Terrain::setHeightmapEntry(int row, int col, int value)
79. {
80.     _heightmap[row * _numVertsPerRow + col] = value;
81. }
83. bool Terrain::computeVertices()
84. {
85.     HRESULT hr = 0;
87.     hr = _device->CreateVertexBuffer(
88.         _numVertices * sizeof(TerrainVertex),
89.         D3DUSAGE_WRITEONLY,
90.         TerrainVertex::FVF,
91.         D3DPOOL_MANAGED,
92.         &_vb,
93.         0);
95.     if(FAILED(hr))
96.         return false;
98.     // 起始顶点坐标
99.     int startX = -_width / 2;
100.     int startZ =  _depth / 2;
102.     // 终点顶点坐标
103.     int endX =  _width / 2;
104.     int endZ = -_depth / 2;
106.     //计算纹理坐标([0,1]之间)的增量
107.     float uCoordIncrementSize = 1.0f / (float)_numCellsPerRow;
108.     float vCoordIncrementSize = 1.0f / (float)_numCellsPerCol;
110.     TerrainVertex* v = 0;
111.     _vb->Lock(0, 0, (void**)&v, 0);
113.     int i = 0;
114.     for(int z = startZ; z >= endZ; z -= _cellSpacing)
115.     {
116.         int j = 0;
117.         for(int x = startX; x <= endX; x += _cellSpacing)
118.         {
119.             // 设置空间坐标及纹理坐标
120.             
121.             int index = i * _numVertsPerRow + j;
123.             v[index] = TerrainVertex(
124.                 (float)x,
125.                 (float)_heightmap[index],
126.                 (float)z,
127.                 (float)j * uCoordIncrementSize,
128.                 (float)i * vCoordIncrementSize);
130.             j++; // next column
131.         }
132.         i++; // next row
133.     }
135.     _vb->Unlock();
137.     return true;
138. }
140. bool Terrain::computeIndices()
141. {
142.     HRESULT hr = 0;
144.     hr = _device->CreateIndexBuffer(
145.         _numTriangles * 3 * sizeof(WORD), // 3 indices per triangle
146.         D3DUSAGE_WRITEONLY,
147.         D3DFMT_INDEX16,
148.         D3DPOOL_MANAGED,
149.         &_ib,
150.         0);
152.     if(FAILED(hr))
153.         return false;
155.     WORD* indices = 0;
156.     _ib->Lock(0, 0, (void**)&indices, 0);
158.     int baseIndex = 0;
160.     // 循环计算每个四边形的索引值
161.     for(int i = 0; i < _numCellsPerCol; i++)
162.     {
163.         for(int j = 0; j < _numCellsPerRow; j++)
164.         {
165.             indices[baseIndex]     =   i   * _numVertsPerRow + j;
166.             indices[baseIndex + 1] =   i   * _numVertsPerRow + j + 1;
167.             indices[baseIndex + 2] = (i+1) * _numVertsPerRow + j;
169.             indices[baseIndex + 3] = (i+1) * _numVertsPerRow + j;
170.             indices[baseIndex + 4] =   i   * _numVertsPerRow + j + 1;
171.             indices[baseIndex + 5] = (i+1) * _numVertsPerRow + j + 1;
173.             // next quad
174.             baseIndex += 6;
175.         }
176.     }
178.     _ib->Unlock();
180.     return true;
181. }
183. bool Terrain::loadTexture(std::string fileName)
184. {
185.     // 加载已创建好的纹理文件
187.     HRESULT hr = 0;
189.     hr = D3DXCreateTextureFromFile(
190.         _device,
191.         fileName.c_str(),
192.         &_tex);
194.     if(FAILED(hr))
195.         return false;
197.     return true;
198. }
200. bool Terrain::genTexture(D3DXVECTOR3* directionToLight)
201. {
202.     // 一种过程化方法 —— 首先创建一个空纹理,然后基于地形的高度图逐个计算纹理元的颜色
204.     HRESULT hr = 0;
206.     // 纹理元宽/高
207.     int texWidth  = _numCellsPerRow;
208.     int texHeight = _numCellsPerCol;
210.     // 创建空纹理
211.     hr = D3DXCreateTexture(
212.         _device,
213.         texWidth, texHeight,
214.         0, // create a complete mipmap chain
215.         0, // usage
216.         D3DFMT_X8R8G8B8,// 32 bit XRGB format
217.         D3DPOOL_MANAGED, &_tex);
219.     if(FAILED(hr))
220.         return false;
222.     D3DSURFACE_DESC textureDesc; 
223.     _tex->GetLevelDesc(0 /*level*/, &textureDesc);
225.     // 验证纹理元格式
226.     if( textureDesc.Format != D3DFMT_X8R8G8B8 )
227.         return false;
228.         
229.     D3DLOCKED_RECT lockedRect;
230.     _tex->LockRect(0/*lock top surface*/, &lockedRect, 
231.         0 /* lock entire tex*/, 0/*flags*/);         
233.     DWORD* imageData = (DWORD*)lockedRect.pBits;
234.     for(int i = 0; i < texHeight; i++)
235.     {
236.         for(int j = 0; j < texWidth; j++)
237.         {
238.             D3DXCOLOR c;
240.             // 取得顶点高度
241.             float height = (float)getHeightmapEntry(i, j) / _heightScale;
243.             // 确定顶点颜色
244.             if( (height) < 42.5f )       c = d3d::BEACH_SAND;
245.             else if( (height) < 85.0f )  c = d3d::LIGHT_YELLOW_GREEN;
246.             else if( (height) < 127.5f ) c = d3d::PUREGREEN;
247.             else if( (height) < 170.0f ) c = d3d::DARK_YELLOW_GREEN;
248.             else if( (height) < 212.5f ) c = d3d::DARKBROWN;
249.             else                         c = d3d::WHITE;
250.     
251.             // 确定单位纹理元明暗度
252.             c *=  computeShade(i, j, directionToLight);
253.         
254.             imageData[i * lockedRect.Pitch / 4 + j] = (D3DCOLOR)c;//float->DWORD
255.         }
256.     }
258.     _tex->UnlockRect(0);
260.     //纹理过滤  
261.     hr = D3DXFilterTexture(
262.         _tex,
263.         0, // default palette
264.         0, // use top level as source level
265.         D3DX_DEFAULT); // default filter
267.     if(FAILED(hr))
268.     {
269.         ::MessageBox(0, "D3DXFilterTexture() - FAILED", 0, 0);
270.         return false;
271.     }
273.     return true;
274. }
278. float Terrain::computeShade(int cellRow, int cellCol, D3DXVECTOR3* directionToLight)
279. {
280.     // 计算三角形平面顶点高度值
281.     float heightA = getHeightmapEntry(cellRow,   cellCol);
282.     float heightB = getHeightmapEntry(cellRow,   cellCol+1);
283.     float heightC = getHeightmapEntry(cellRow+1, cellCol);
285.     // 创建 u/v 向量
286.     D3DXVECTOR3 u(_cellSpacing, heightB - heightA, 0.0f);
287.     D3DXVECTOR3 v(0.0f,         heightC - heightA, -_cellSpacing);
289.     // 计算平面法向量
290.     D3DXVECTOR3 n;
291.     D3DXVec3Cross(&n, &u, &v);
292.     D3DXVec3Normalize(&n, &n);
294.     // 计算法向量与方向光的cos值
295.     float cosine = D3DXVec3Dot(&n, directionToLight);
297.     if(cosine < 0.0f)
298.         cosine = 0.0f;
300.     return cosine;
301. }
303. bool Terrain::readRawFile(std::string fileName)
304. {
305.     // 读取RAW文件(128x128) 最多128x128个顶点 
307.     // 每个顶点对应一个高度值
308.     std::vector<BYTE> in( _numVertices );
310.     std::ifstream inFile(fileName.c_str(), std::ios_base::binary);
312.     if( inFile == 0 )
313.         return false;
315.     inFile.read(
316.         (char*)&in[0], // buffer
317.         in.size());// number of bytes to read into buffer
319.     inFile.close();
321.     // 重置高度图vector大小
322.     _heightmap.resize( _numVertices );
324.     for(int i = 0; i < in.size(); i++)
325.         _heightmap[i] = in[i];
327.     return true;
328. }
330. float Terrain::getHeight(float x, float z)
331. {
332.     // 求得点所在高度(计算视点矩阵用)
334.     // 变换坐标系——使原点位于左上角,而不是原来的中心
335.     x = ((float)_width / 2.0f) + x;
336.     z = ((float)_depth / 2.0f) - z;
338.     // 变换坐标系单位长度——不是原来的_cellSpacing,而是1
339.     x /= (float)_cellSpacing;
340.     z /= (float)_cellSpacing;
342.     // 取不大于 x/z 的最大整数
343.     float col = ::floorf(x);
344.     float row = ::floorf(z);
346.     // 取得所求点所在方格的4个顶点高度
347.     // 
348.     //  A   B
349.     //  *---*
350.     //  | / |
351.     //  *---*  
352.     //  C   D
354.     float A = getHeightmapEntry(row,   col);
355.     float B = getHeightmapEntry(row,   col+1);
356.     float C = getHeightmapEntry(row+1, col);
357.     float D = getHeightmapEntry(row+1, col+1);
360.     // 继续变换坐标——使dx/dz位于左上第一个方格内
361.     float dx = x - col;
362.     float dz = z - row;
364.     float height = 0.0f;
365.     if(dz < 1.0f - dx)  //点位于上三角ABC
366.     {
367.         float uy = B - A; // A->B
368.         float vy = C - A; // A->C
369.         // (A + dxu + dzv)的y分量就是该点所处高度
370.         height = A + d3d::Lerp(0.0f, uy, dx) + d3d::Lerp(0.0f, vy, dz);
371.     }
372.     else // 点位于下三角DCB
373.     {
374.         float uy = C - D; // D->C
375.         float vy = B - D; // D->B
376.         height = D + d3d::Lerp(0.0f, uy, 1.0f - dx) + d3d::Lerp(0.0f, vy, 1.0f - dz);
377.     }
379.     return height;
380. }
382. bool Terrain::draw(D3DXMATRIX* world, bool drawTris)
383. {
384.     HRESULT hr = 0;
386.     if( _device )
387.     {
388.         _device->SetTransform(D3DTS_WORLD, world);
390.         _device->SetStreamSource(0, _vb, 0, sizeof(TerrainVertex));
391.         _device->SetFVF(TerrainVertex::FVF);
392.         _device->SetIndices(_ib);
393.         
394.         _device->SetTexture(0, _tex);
396.         // 不使用光照直到我们开启
397.         _device->SetRenderState(D3DRS_LIGHTING, false);
399.         hr =_device->DrawIndexedPrimitive(
400.             D3DPT_TRIANGLELIST,
401.             0,
402.             0,
403.             _numVertices,
404.             0,
405.             _numTriangles);
407.         _device->SetRenderState(D3DRS_LIGHTING, true);
409.         if( drawTris )
410.         {
411.             _device->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
412.             hr =_device->DrawIndexedPrimitive(
413.                 D3DPT_TRIANGLELIST,
414.                 0,
415.                 0,
416.                 _numVertices,
417.                 0,
418.                 _numTriangles);
420.             _device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
421.         }
423.         if(FAILED(hr))
424.             return false;
425.     }
427.     return true;
428. }

2.增加一个FPS类(计算帧频)

代码清单:

1. //
2. // 
3. // File: fps.h
4. // 
5. // by tianzhihen
6. //
7. // 2008.10.27, MSVC++ 8.0 
8. //          
9. //
11. #ifndef __fpsH__
12. #define __fpsH__
14. #include "d3dfont.h"
16. class FPSCounter
17. {
18. public:
19.     FPSCounter(IDirect3DDevice9* device);
20.     ~FPSCounter();
22.     bool render(D3DCOLOR color, float timeDelta);
23. private:
24.     IDirect3DDevice9* _device;
25.     
26.     CD3DFont* _font;
27.     DWORD     _frameCnt;
28.     float     _timeElapsed;
29.     float     _fps;
30.     char      _fpsString[9];
31.     
32. };
33. #endif // __fpsH__

1. //
2. // 
3. // File: fps.cpp
4. // 
5. // by tianzhihen
6. //
7. // 2008.10.27, MSVC++ 8.0 
8. //          
9. //
11. #include "fps.h"
12. #include <cstdio>
14. FPSCounter::FPSCounter(IDirect3DDevice9* device)
15. {
16.     _device = device;
18.     _font = new CD3DFont("Times New Roman", 24, 0);
19.     _font->InitDeviceObjects( _device );
20.     _font->RestoreDeviceObjects();
22.     _frameCnt = 0;
23.     _timeElapsed = 0.0f;
24.     _fps         = 0.0f;
25. }
27. FPSCounter::~FPSCounter()
28. {
29.     if( _font )
30.     {
31.         _font->InvalidateDeviceObjects();
32.         _font->DeleteDeviceObjects();
33.         delete _font;
34.     }
35. }
37. bool FPSCounter::render(D3DCOLOR color, float timeDelta)
38. {
39.     if( _font )
40.     {
41.         _frameCnt++;
43.         _timeElapsed += timeDelta;
45.         if(_timeElapsed >= 1.0f)
46.         {
47.             _fps = (float)_frameCnt / _timeElapsed;
49.             sprintf(_fpsString, "%f", _fps);
50.             _fpsString[8] = '/0'; // mark end of string
52.             _timeElapsed = 0.0f;
53.             _frameCnt    = 0;
54.         }
56.         _font->DrawText(20, 20, color, _fpsString); 
57.     }
58.     return true;
59. }

3.增加相应DX框架文件。因为FPS类用到了d3dfont.h头文件,因此需添加相应的框架文件。列举如下:

d3dfont.h   d3dfont.cpp   dxutil.h   dxutil.cpp   d3dutil.h   d3dutil.cpp 

 

4.保持camera类不变。d3dUtility.cpp添加Lerp()函数。

1. float d3d::Lerp(float a, float b, float t)
2. {
3.     return a - (a*t) + (b*t);
4. }

相应的d3dUtility.h须包含此函数声明。

1.     float Lerp(float a, float b, float t);

5.在d3dUtility.h中添加一些颜色常量。

1.     const D3DXCOLOR BEACH_SAND( D3DCOLOR_XRGB(255, 249, 157) );
2.     const D3DXCOLOR DESERT_SAND( D3DCOLOR_XRGB(250, 205, 135) );
4.     const D3DXCOLOR LIGHTGREEN( D3DCOLOR_XRGB( 60, 184, 120) );
5.     const D3DXCOLOR  PUREGREEN( D3DCOLOR_XRGB(  0, 166,  81) );
6.     const D3DXCOLOR  DARKGREEN( D3DCOLOR_XRGB(  0, 114,  54) );
8.     const D3DXCOLOR LIGHT_YELLOW_GREEN( D3DCOLOR_XRGB(124, 197, 118) );
9.     const D3DXCOLOR  PURE_YELLOW_GREEN( D3DCOLOR_XRGB( 57, 181,  74) );
10.     const D3DXCOLOR  DARK_YELLOW_GREEN( D3DCOLOR_XRGB( 25, 123,  48) );
12.     const D3DXCOLOR LIGHTBROWN(D3DCOLOR_XRGB(198, 156, 109));
13.     const D3DXCOLOR DARKBROWN( D3DCOLOR_XRGB(115, 100,  87));