D3D地图Terrain类构建思想和实现

地图类的构建思想

其实无论平原，山地，丘陵，沙漠，沙滩都可以用地图网格来表示，巨大的地形网格（网格有顶点向量信息，材质光照，纹理信息）和场景物体，摄像机位置等信息来表达就可以了(2D中需要用45度菱形地图实现3D场景效果，3D中不需要的)。

实现网格信息的步骤：

1.地图高度：从raw灰色图中读取高度图，直接从二进制图片中读取，BYTE转换为int存储因为会放大高度。

2.顶点缓存：在地图网格中构建顶点信息，从传入的像素宽度和格子行列数量和格子大小，还有纹理大小来计算网格的顶点向量和uv信息。

3.索引缓存：在地图网格中构建索引信息，从左到右从上到下的遍历小方格的形式记录三角形的索引，通过假设未知量可以很容易得方格中的三角形顶点和索引的关系。

4.预计算地图中的光照，光照方程来自于L是指光源向量和H是三角形法向量之间夹角来简单决定明暗因子，夹角越小明暗因子越大和光照的镜面反射或者漫反射模型类似，但比他们简单没有计算材质反射值和光泽，观察者方向等信息。 这样SetUp预先计算光照颜色，比实时计算光照性能大幅下降，如果需要切换昼夜可以定时触发计算也比实时计算好。

5.创建一个空纹理，填入材质信息和将纹理通过D3DXFilterTexture得到多级渐进纹理mipMap 或者直接从文件里面D3DXCreateTextureFromFile加载多个纹理，用于地图中指定的网格，当绘制不同地图时候需要切换纹理。或者用纹理随机技术生成随机大小和数量植被地表的地图。

6. 传入当前的摄像机像素位置，挪动坐标算出当前所处的格子位置，由格子位置得到左上角的摄像机高度 。再由向量相加的三角法则，对y方向的向量进行加法得到摄像机当前真实高度(当前所处的格子三角形左上还是右下需要判断，还需要对当前摄像机位置偏移左上角位置或者右下角位置，进行插值计算得到当前高度信息，插值是线性插值a0 + (b-a)t计算即可）。

7.丰富地表表现实现方法：多层纹理的融合的混合地表实现，根据alpha值来计算纹理值，可以得到草地和沙地，岩石和雪贴图根据随机的alpha随机融合的得到满意的地表效果。如果要美术绘制复杂地表，也是可以做到的，但是要改变就比较麻烦。

实现代码及其分析注释

#ifndef __terrainH__
#define __terrainH__

#include "d3dUtility.h"
#include <string>
#include <vector>

class Terrain
{
public:
	Terrain(
		IDirect3DDevice9* device,
		std::string heightmapFileName, 
		int numVertsPerRow,  
		int numVertsPerCol, 
		int cellSpacing,    // space between cells
		float heightScale);   

	~Terrain();

	int  getHeightmapEntry(int row, int col);
	void setHeightmapEntry(int row, int col, int value);

	// 传入当前的摄像机像素位置，挪动坐标算出当前所处的格子位置，由格子位置得到左上角的摄像机高度
	// 再由向量相加的三角法则，对y方向的向量进行加法得到摄像机当前真实高度(当前所处的格子三角形左上还是右下需要判断，
	// 还需要对当前摄像机位置偏移左上角位置或者右下角位置，进行插值计算得到当前高度信息，插值是线性插值a0 + (b-a)t计算即可）。
	float getHeight(float x, float z);

	bool  loadTexture(std::string fileName);
	// 创建一个空纹理，填入材质信息和将纹理通过D3DXFilterTexture得到多级渐进纹理mipMap
	// 或者直接从文件里面D3DXCreateTextureFromFile加载多个纹理，用于地图中指定的网格，当绘制不同地图时候需要切换纹理。
	// 或者用纹理随机技术生成随机大小和数量植被地表的地图。
	bool  genTexture(D3DXVECTOR3* directionToLight);

	bool  draw(D3DXMATRIX* world, bool drawTris);

private:
	IDirect3DDevice9*       _device;
	// 地图包含了一张纹理图片，自己创建的
	IDirect3DTexture9*      _tex;
	// 顶点缓存
	IDirect3DVertexBuffer9* _vb;
	// 索引缓存
	IDirect3DIndexBuffer9*  _ib;

	// 每行顶点数
	int _numVertsPerRow;
	// 每列顶点数
	int _numVertsPerCol;
	// 每个小方格的像素数
	int _cellSpacing;

	// 每行的小方格数是每行顶点数减去1
	int _numCellsPerRow;
	// 每列的小方格数是每列顶点数减去1
	int _numCellsPerCol;
	// x方向像素宽度
	int _width;
	// z方向像素深度
	int _depth;
	// 地图的顶点个数
	int _numVertices;
	// 地图的三角形个数
	int _numTriangles;

	// 实际虚拟空间中对高度图的缩放系数，一般比高度图1大
	float _heightScale;

	// 存放对高度图缩放后的地图高度的数据，对应每个顶点
	std::vector<int> _heightmap;

	// helper methods
	// 1.从raw文件中读取高度图，直接从二进制图片中读取，BYTE转换为int存储因为会放大高度
	bool  readRawFile(std::string fileName);

	// 2.在地图网格中构建顶点信息，从传入的像素宽度和格子数量，还有纹理大小计算顶点向量和uv信息
	bool  computeVertices();

	// 3.在地图网格中构建索引信息，从左到右从上到下的遍历小方格的形式记录三角形的索引，
	// 通过假设未知量可以很容易得方格中的三角形顶点和索引的关系
	bool  computeIndices();

	// 4.预计算地图中的光照，光照方程来自于L是指光源向量和H是三角形法向量之间夹角来简单决定明暗因子，夹角越小明暗因子越大
	// 和光照的镜面反射或者漫反射模型类似，但比他们简单没有计算材质反射值和光泽，观察者方向等信息
	// 这样SetUp预先计算光照颜色，比实时计算光照性能大幅下降，如果需要切换昼夜可以定时触发计算也比实时计算好。
	bool  lightTerrain(D3DXVECTOR3* directionToLight);
	// 传入单元格，和到光源的向量，得到明暗因子
	float computeShade(int cellRow, int cellCol, D3DXVECTOR3* directionToLight);

	struct TerrainVertex
	{
		TerrainVertex(){}
		TerrainVertex(float x, float y, float z, float u, float v)
		{
			_x = x; _y = y; _z = z; _u = u; _v = v;
		}
		float _x, _y, _z;
		float _u, _v;

		static const DWORD FVF;
	};
};

#endif

#include "terrain.h"
#include <fstream>
#include <cmath>

const DWORD Terrain::TerrainVertex::FVF = D3DFVF_XYZ | D3DFVF_TEX1;

Terrain::Terrain(IDirect3DDevice9* device,
				 std::string heightmapFileName,
				 int numVertsPerRow,
				 int numVertsPerCol,
				 int cellSpacing,
				 float heightScale)
{
	_device         = device;
	_numVertsPerRow = numVertsPerRow;
	_numVertsPerCol = numVertsPerCol;
	_cellSpacing    = cellSpacing;

	_numCellsPerRow = _numVertsPerRow - 1;
	_numCellsPerCol = _numVertsPerCol - 1;

	_width = _numCellsPerRow * _cellSpacing;
	_depth = _numCellsPerCol * _cellSpacing;

	_numVertices  = _numVertsPerRow * _numVertsPerCol;
	_numTriangles = _numCellsPerRow * _numCellsPerCol * 2;

	_heightScale = heightScale;

	// load heightmap
	if( !readRawFile(heightmapFileName) )
	{
		::MessageBox(0, "readRawFile - FAILED", 0, 0);
		::PostQuitMessage(0);
	}

	// scale heights
	// 将高度信息，直接乘以缩放比例得到高度图信息
	for(int i = 0; i < _heightmap.size(); i++)
		_heightmap[i] *= heightScale;

	// compute the vertices
	if( !computeVertices() )
	{
		::MessageBox(0, "computeVertices - FAILED", 0, 0);
		::PostQuitMessage(0);
	}

	// compute the indices
	if( !computeIndices() )
	{
		::MessageBox(0, "computeIndices - FAILED", 0, 0);
		::PostQuitMessage(0);
	}
}

Terrain::~Terrain()
{
	d3d::Release<IDirect3DVertexBuffer9*>(_vb);
	d3d::Release<IDirect3DIndexBuffer9*>(_ib);
	d3d::Release<IDirect3DTexture9*>(_tex);
}

int Terrain::getHeightmapEntry(int row, int col)
{
	return _heightmap[row * _numVertsPerRow + col];
}

void Terrain::setHeightmapEntry(int row, int col, int value)
{
	_heightmap[row * _numVertsPerRow + col] = value;
}

bool Terrain::computeVertices()
{
	HRESULT hr = 0;
	// 地图网格中，直接创建顶点缓存，顶点缓存的个数行顶点数乘以列顶点数
	hr = _device->CreateVertexBuffer(
		_numVertices * sizeof(TerrainVertex),
		D3DUSAGE_WRITEONLY,
		TerrainVertex::FVF,
		D3DPOOL_DEFAULT,
		&_vb,
		0);

	if(FAILED(hr))
		return false;

	// coordinates to start generating vertices at
	// 二维地图中的左上角，开始的像素位置
	int startX = -_width / 2;
	int startZ =  _depth / 2;

	// coordinates to end generating vertices at
	int endX =  _width / 2;
	int endZ = -_depth / 2;

	// compute the increment size of the texture coordinates
	// from one vertex to the next.
	// 纹理坐标的u方向的增长，确保了j等于_numCellsPerRow时候为1
	float uCoordIncrementSize = 1.0f / (float)_numCellsPerRow;
	// 纹理坐标的v方向的增长，确保了i等于_numCellsPerCol时候为1
	float vCoordIncrementSize = 1.0f / (float)_numCellsPerCol;

	TerrainVertex* v = 0;
	_vb->Lock(0, 0, (void**)&v, 0);

	int i = 0;
	for(int z = startZ; z >= endZ; z -= _cellSpacing)
	{
		int j = 0;
		for(int x = startX; x <= endX; x += _cellSpacing)
		{
			// compute the correct index into the vertex buffer and heightmap
			// based on where we are in the nested loop.
			// 获取顶点下标，和填充顶点位置和纹理信息
			int index = i * _numVertsPerRow + j;
			v[index] = TerrainVertex(
				(float)x,
				(float)_heightmap[index],
				(float)z,
				(float)j * uCoordIncrementSize,
				(float)i * vCoordIncrementSize);

			j++; // next column
		}
		i++; // next row
	}

	_vb->Unlock();

	return true;
}

bool Terrain::computeIndices()
{
	HRESULT hr = 0;

	hr = _device->CreateIndexBuffer(
		_numTriangles * 3 * sizeof(WORD), // 3 indices per triangle
		D3DUSAGE_WRITEONLY,
		D3DFMT_INDEX16,
		D3DPOOL_DEFAULT,
		&_ib,
		0);

	if(FAILED(hr))
		return false;

	WORD* indices = 0;
	_ib->Lock(0, 0, (void**)&indices, 0);

	// index to start of a group of 6 indices that describe the
	// two triangles that make up a quad
	int baseIndex = 0;

	// loop through and compute the triangles of each quad
	// 从左到右，从上到下，得到每个三角形的索引
	// 可以通过很简单的观察得到i   * _numVertsPerRow + j，i   * _numVertsPerRow + j + 1，(i+1) * _numVertsPerRow + j
	// 的规律
	for(int i = 0; i < _numCellsPerCol; i++)
	{
		for(int j = 0; j < _numCellsPerRow; j++)
		{
			indices[baseIndex]     =   i   * _numVertsPerRow + j;
			indices[baseIndex + 1] =   i   * _numVertsPerRow + j + 1;
			indices[baseIndex + 2] = (i+1) * _numVertsPerRow + j;

			indices[baseIndex + 3] = (i+1) * _numVertsPerRow + j;
			indices[baseIndex + 4] =   i   * _numVertsPerRow + j + 1;
			indices[baseIndex + 5] = (i+1) * _numVertsPerRow + j + 1;

			// next quad
			baseIndex += 6;
		}
	}

	_ib->Unlock();

	return true;
}

bool Terrain::loadTexture(std::string fileName)
{
	HRESULT hr = 0;

	hr = D3DXCreateTextureFromFile(
		_device,
		fileName.c_str(),
		&_tex);

	if(FAILED(hr))
		return false;

	return true;
}

bool Terrain::genTexture(D3DXVECTOR3* directionToLight)
{
	// Method fills the top surface of a texture procedurally.  Then
	// lights the top surface.  Finally, it fills the other mipmap
	// surfaces based on the top surface data using D3DXFilterTexture.

	HRESULT hr = 0;

	// texel for each quad cell
	int texWidth  = _numCellsPerRow;
	int texHeight = _numCellsPerCol;

	// create an empty texture
	hr = D3DXCreateTexture(
		_device,
		texWidth, texHeight,
		0, // create a complete mipmap chain
		0, // usage
		D3DFMT_X8R8G8B8,// 32 bit XRGB format
		D3DPOOL_MANAGED, &_tex);

	if(FAILED(hr))
		return false;

	D3DSURFACE_DESC textureDesc; 
	_tex->GetLevelDesc(0 /*level*/, &textureDesc);

	// make sure we got the requested format because our code 
	// that fills the texture is hard coded to a 32 bit pixel depth.
	if( textureDesc.Format != D3DFMT_X8R8G8B8 )
		return false;
		
	D3DLOCKED_RECT lockedRect;
	_tex->LockRect(0/*lock top surface*/, &lockedRect, 
		0 /* lock entire tex*/, 0/*flags*/);         

	DWORD* imageData = (DWORD*)lockedRect.pBits;
	for(int i = 0; i < texHeight; i++)
	{
		for(int j = 0; j < texWidth; j++)
		{
			D3DXCOLOR c;

			// get height of upper left vertex of quad.
			float height = (float)getHeightmapEntry(i, j) / _heightScale;

			if( (height) < 42.5f ) 		 c = d3d::BEACH_SAND;
			else if( (height) < 85.0f )	 c = d3d::LIGHT_YELLOW_GREEN;
			else if( (height) < 127.5f ) c = d3d::PUREGREEN;
			else if( (height) < 170.0f ) c = d3d::DARK_YELLOW_GREEN;
			else if( (height) < 212.5f ) c = d3d::DARKBROWN;
			else	                     c = d3d::WHITE;

			// fill locked data, note we divide the pitch by four because the
			// pitch is given in bytes and there are 4 bytes per DWORD.
			// lockedRect.Pitch是上一行中结束位置的字节数，lockedRect.Pitch / 4就是DWORD个数
			imageData[i * lockedRect.Pitch / 4 + j] = (D3DCOLOR)c;
		}
	}

	_tex->UnlockRect(0);

	// 这里的光照和纹理颜色，是将纹理颜色和光照的明暗因子进行相乘得到最后颜色的结果，并非融合的方式
	if(!lightTerrain(directionToLight))
	{
		::MessageBox(0, "lightTerrain() - FAILED", 0, 0);
		return false;
	}
	
	// 计算出其它多级纹理层中的纹理元
	// 例如_tex是源纹理是256x256的，那么D3DXFilterTexture可以生成其它大小的纹理，例如128x128的，64x64的
	// 这样自定义填充的纹理，就类似于D3DXCreateTextureFromFile一样拥有mipMap Texture多级纹理的纹理。
	hr = D3DXFilterTexture(
		_tex,
		0, // default palette
		0, // use top level as source level
		D3DX_DEFAULT); // default filter

	if(FAILED(hr))
	{
		::MessageBox(0, "D3DXFilterTexture() - FAILED", 0, 0);
		return false;
	}

	return true;
}

bool Terrain::lightTerrain(D3DXVECTOR3* directionToLight)
{
	HRESULT hr = 0;

	D3DSURFACE_DESC textureDesc; 
	_tex->GetLevelDesc(0 /*level*/, &textureDesc);

	// make sure we got the requested format because our code that fills the
	// texture is hard coded to a 32 bit pixel depth.
	if( textureDesc.Format != D3DFMT_X8R8G8B8 )
		return false;
		
	D3DLOCKED_RECT lockedRect;
	_tex->LockRect(
		0,          // lock top surface level in mipmap chain
		&lockedRect,// pointer to receive locked data
		0,          // lock entire texture image
		0);         // no lock flags specified

	DWORD* imageData = (DWORD*)lockedRect.pBits;
	for(int i = 0; i < textureDesc.Height; i++)
	{
		for(int j = 0; j < textureDesc.Width; j++)
		{
			// index into texture, note we use the pitch and divide by 
			// four since the pitch is given in bytes and there are 
			// 4 bytes per DWORD.
			// lockedRect.Pitch是上一行中结束位置的字节数，lockedRect.Pitch / 4就是DWORD个数
			int index = i * lockedRect.Pitch / 4 + j;

			// get current color of quad
			D3DXCOLOR c( imageData[index] );

			// shade current quad
			// 颜色乘以明暗因子，得到光照计算后的颜色
			c *= computeShade(i, j, directionToLight);;

			// save shaded color
			imageData[index] = (D3DCOLOR)c;
		}
	}

	_tex->UnlockRect(0);

	return true;
}

float Terrain::computeShade(int cellRow, int cellCol, D3DXVECTOR3* directionToLight)
{
	// get heights of three vertices on the quad
	float heightA = getHeightmapEntry(cellRow,   cellCol);
	float heightB = getHeightmapEntry(cellRow,   cellCol+1);
	float heightC = getHeightmapEntry(cellRow+1, cellCol);

	// build two vectors on the quad
	// 计算uv,y方向上用向量三角规则来进行计算
	D3DXVECTOR3 u(_cellSpacing, heightB - heightA, 0.0f);
	D3DXVECTOR3 v(0.0f,         heightC - heightA, -_cellSpacing);

	// find the normal by taking the cross product of two
	// vectors on the quad.
	// 得到平面法向量
	D3DXVECTOR3 n;
	D3DXVec3Cross(&n, &u, &v);
	D3DXVec3Normalize(&n, &n);

	// L.N得到明暗因子
	float cosine = D3DXVec3Dot(&n, directionToLight);

	if(cosine < 0.0f)
		cosine = 0.0f;

	return cosine;
}

bool Terrain::readRawFile(std::string fileName)
{
	// Restriction: RAW file dimensions must be >= to the
	// dimensions of the terrain.  That is a 128x128 RAW file
	// can only be used with a terrain constructed with at most
	// 128x128 vertices.

	// A height for each vertex
	std::vector<BYTE> in( _numVertices );

	std::ifstream inFile(fileName.c_str(), std::ios_base::binary);

	if( inFile == 0 )
		return false;
	// 直接将二进制数据读取到数组中
	inFile.read(
		(char*)&in[0], // buffer
		in.size());// number of bytes to read into buffer

	inFile.close();

	// copy BYTE vector to int vector
	// 这个拷贝也是因为BYTE类型转换为int类型需要引入的
	_heightmap.resize( _numVertices );
	for(int i = 0; i < in.size(); i++)
		_heightmap[i] = in[i];

	return true;
}

float Terrain::getHeight(float x, float z)
{
	float fWidthLimit = _width * 0.5f;
	if( x < -fWidthLimit || x > fWidthLimit )
	{
		return 0.0f;
	}
	float fDepthLimit = _depth * 0.5f;
	if( z < -fDepthLimit || z > fDepthLimit )
	{
		return 0.0f;
	}
	// Translate on xz-plane by the transformation that takes
	// the terrain START point to the origin.
	// x像素宽度从[-w/2,w/2]到[0,w]
	x = ((float)_width / 2.0f) + x;
	// z像素深度从[d/2,-d/2]到[0,d]
	z = ((float)_depth / 2.0f) - z;

	// Scale down by the transformation that makes the 
	// cellspacing equal to one.  This is given by 
	// 1 / cellspacing since; cellspacing * 1 / cellspacing = 1.
	// x,z从像素深度，除以一个小方格的宽度，得到当前所属于的方格数
	x /= (float)_cellSpacing;
	z /= (float)_cellSpacing;

	// From now on, we will interpret our positive z-axis as
	// going in the 'down' direction, rather than the 'up' direction.
	// This allows to extract the row and column simply by 'flooring'
	// x and z:
	// 得到所属的方格数，去小于等于的整数，也就是左上角的方格数
	float col = ::floorf(x);
	float row = ::floorf(z);

	// get the heights of the quad we're in:
	// 
    //  A   B
    //  *---*
    //  | / |
    //  *---*  
    //  C   D

	float A = getHeightmapEntry(row,   col);
	float B = getHeightmapEntry(row,   col+1);
	float C = getHeightmapEntry(row+1, col);
	float D = getHeightmapEntry(row+1, col+1);

	//
	// Find the triangle we are in:
	//

	// Translate by the transformation that takes the upper-left
	// corner of the cell we are in to the origin.  Recall that our 
	// cellspacing was nomalized to 1.  Thus we have a unit square
	// at the origin of our +x -> 'right' and +z -> 'down' system.
	// 得到x,z相对于左上角方格数的偏差，也就是当前高度需要的dx,dz浮点值
	float dx = x - col;
	float dz = z - row;

	// Note the below compuations of u and v are unneccessary, we really
	// only need the height, but we compute the entire vector to emphasis
	// the books discussion.
	// 选择三角形，在x + y = 1直线的左上部分，还是右下部分
	// dz < 1.0f - dx是左上的三角形
	float height = 0.0f;
	if(dz < 1.0f - dx)  // upper triangle ABC
	{
		float uy = B - A; // A->B
		float vy = C - A; // A->C

		// Linearly interpolate on each vector.  The height is the vertex
		// height the vectors u and v originate from {A}, plus the heights
		// found by interpolating on each vector u and v.
		// a0 + (uy-a0)dx线性插值，这里a0是0，也就是得到uy*dx的值
		// 由三角形法则，因为uy,vy可正可负，且dx,dz是两点间的[0,1]之间的偏差值
		// 三角形法则中因为不需要x,z方向的，只需要y方向的值，所以拿高度进行A + dxuy + dzvy就会得到当前的高度值
		height = A + d3d::Lerp(0.0f, uy, dx) + d3d::Lerp(0.0f, vy, dz);
	}
	else // lower triangle DCB
	{
		//  A   B
		//  *---*
		//  | / |
		//  *---*  
		//  C   D
		float uy = C - D; // D->C
		float vy = B - D; // D->B

		// Linearly interpolate on each vector.  The height is the vertex
		// height the vectors u and v originate from {D}, plus the heights
		// found by interpolating on each vector u and v.
		// 因为dx是[0,dx,1]之间的一个值，现在从上限处开始算所以是1-dx;1-dz也是指后面部分的值
		// uy,vy来决定正负，1-dx, 1-dy只是个相对量。
		height = D + d3d::Lerp(0.0f, uy, 1.0f - dx) + d3d::Lerp(0.0f, vy, 1.0f - dz);
	}

	// 得到射线机的高度，就可以在上面行走了
	return height;
}

bool Terrain::draw(D3DXMATRIX* world, bool drawTris)
{
	HRESULT hr = 0;

	if( _device )
	{
		_device->SetTransform(D3DTS_WORLD, world);

		_device->SetStreamSource(0, _vb, 0, sizeof(TerrainVertex));
		_device->SetFVF(TerrainVertex::FVF);
		_device->SetIndices(_ib);
		
		// 设置创建好颜色且填充好光照明暗的多级纹理
		_device->SetTexture(0, _tex);

		// turn off lighting since we're lighting it ourselves
		_device->SetRenderState(D3DRS_LIGHTING, false);

		// 绘制时候直接绘制顶点缓存和索引缓存即可
		hr =_device->DrawIndexedPrimitive(
			D3DPT_TRIANGLELIST,
			0,
			0,
			_numVertices,
			0,
			_numTriangles);

		
		_device->SetRenderState(D3DRS_LIGHTING, true);

		// 绘制三角形网格
		if( drawTris )
		{
			// 填充模式 默认是D3DFILL_SOLID，The default value is D3DFILL_SOLID
			_device->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
			hr =_device->DrawIndexedPrimitive(
				D3DPT_TRIANGLELIST,
				0,
				0,
				_numVertices,
				0,
				_numTriangles);

			_device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
		}

		if(FAILED(hr))
			return false;
	}

	return true;
}

调用端代码：

bool Setup()
{
	//
	// Create the terrain.
	//

	D3DXVECTOR3 lightDirection(0.0f, 1.0f, 0.0f);
	TheTerrain = new Terrain(Device, "coastMountain64.raw", 64, 64, 10, 0.5f);
	TheTerrain->genTexture(&lightDirection);
	//TheTerrain->loadTexture("grass.bmp");

	//
	// Create the font.
	//

	FPS = new FPSCounter(Device);

	//
	// Set texture filters.
	//

	Device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
	Device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
	Device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);

	//
	// Set projection matrix.
	//

	D3DXMATRIX proj;
	D3DXMatrixPerspectiveFovLH(
			&proj,
			D3DX_PI * 0.25f, // 45 - degree
			(float)Width / (float)Height,
			1.0f,
			1000.0f);
	Device->SetTransform(D3DTS_PROJECTION, &proj);

	return true;
}

void Cleanup()
{
	d3d::Delete<Terrain*>(TheTerrain);
	d3d::Delete<FPSCounter*>(FPS);
}

bool Display(float timeDelta)
{
	//
	// Update the scene:
	//

	if( Device )
	{
		// walk是沿_look轴的移动，地面摄像机不能绕_look旋转
		if( ::GetAsyncKeyState(VK_UP) & 0x8000f )
			TheCamera.walk(100.0f * timeDelta);

		if( ::GetAsyncKeyState(VK_DOWN) & 0x8000f )
			TheCamera.walk(-100.0f * timeDelta);

		// yaw是绕_up轴偏航，地面摄像机是绕世界y轴旋转；地面摄像机不能沿_up上下移动
		if( ::GetAsyncKeyState(VK_LEFT) & 0x8000f )
			TheCamera.yaw(-1.0f * timeDelta);
		
		if( ::GetAsyncKeyState(VK_RIGHT) & 0x8000f )
			TheCamera.yaw(1.0f * timeDelta);

		// MN是沿_right左右摆动
		if( ::GetAsyncKeyState('N') & 0x8000f )
			TheCamera.strafe(-100.0f * timeDelta);

		if( ::GetAsyncKeyState('M') & 0x8000f )
			TheCamera.strafe(100.0f * timeDelta);

		// pith是绕_right轴的仰俯
		if( ::GetAsyncKeyState('W') & 0x8000f )
			TheCamera.pitch(1.0f * timeDelta);

		if( ::GetAsyncKeyState('S') & 0x8000f )
			TheCamera.pitch(-1.0f * timeDelta);

		D3DXVECTOR3 pos;
		TheCamera.getPosition(&pos);
		float height = TheTerrain->getHeight( pos.x, pos.z );
		if( !d3d::gFltEquip( height, 0.0f) )
		{
			pos.y = height + 5.0f; // add height because we're standing up
		}
		
		TheCamera.setPosition(&pos);

		D3DXMATRIX V;
		TheCamera.getViewMatrix(&V);
		Device->SetTransform(D3DTS_VIEW, &V);

		//
		// Draw the scene:
		//

		Device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff000000, 1.0f, 0);
		Device->BeginScene();

		D3DXMATRIX I;
		D3DXMatrixIdentity(&I);

		// 绘制地形，直接使用设置好的纹理和预计算的光照明暗纹理颜色，根据顶点索引绘制顶点缓存即可
		if( TheTerrain )
			TheTerrain->draw(&I, true/*false*/);

		// 绘制FPS文字，因为整个顶点缓存比较影响性能
		if( FPS )
			FPS->render(0xffffffff, timeDelta);

		Device->EndScene();
		Device->Present(0, 0, 0, 0);
	}
	return true;
}