加载TLBB场景（二）

#include "StdAfx.h"

#include "TerrainScene.h"

#include <tinyxml/tinyxml.h>



#ifdef _DEBUG

#pragma comment(lib, "tinyxml_d.lib")

#else

#pragma comment(lib, "tinyxml.lib")

#endif



struct CUSTOMVERTEX

{

	float x, y, z;	   // 世界坐标

	float u, v;      // 纹理坐标

};



struct GeometryData

{

	unsigned int			numVertices;

	unsigned int			numIndices;

	std::vector<CUSTOMVERTEX>	vertexData;	

	std::vector<unsigned int>	indexData;

	TexturePtr			pTexture;

};



struct PixMap

{

	int textureId;

	float left;

	float top;

	float right;

	float bottom;

};	



struct GridHeader

{

	unsigned int nMagic;

	// 版本号

	unsigned int nVersion;

	// 地表宽度(横向格子数)

	int nWidth;

	// 地表高度(纵向格子数)

	int nHeight;

};



struct GridInfo

{

	// 该值即为pixelmap的索引（第几个pixelmap）

	short    nFirstLayer;

	// 对nFirstLayer的操作，取值是上面几个定义的宏，可以互相组合

	unsigned char    nFirstLayerOp;

	// 该值为pixelmap的索引

	//天龙八部的地表最多可以两层融合，说白了就是每个点里有两层UV，这里为第二层pixelmap的索引

	short    nSecondLayer;

	// 对nSecondLayer的操作，取值同nFirstLayerOp

	unsigned char    nSecondLayerOp;

	// 对格子的三角形的操作，可能取值如下

	//    0正常三角形索引

	//    1不同于正常的三角形索引

	unsigned char    IndexOrder;



	// 图片水平翻转，即左右翻转

#define FLIP_HORIZINTAL 1

	// 图片垂直翻转，即上下翻转

#define FLIP_VERTICAL 2

	// 逆时针旋转90度

#define ANTICLOCKWISE_90 4

	// 以三角形的对角线镜像，IndexOrder==0时就把左上的纹理坐标复制到右下，否则把右上的坐标复制到左下

#define FLIP_DIAGONAL 8



};



CTerrainScene::CTerrainScene(void)

{

	m_pSceneManager  = NULL;

	m_iTerrainWidth  = 0;

	m_iTerrainHeight = 0;

	m_pHeightMapData = NULL;



	for( int idx = 0; idx < 3; ++idx )

	{

		m_fTerrainScale[idx] = 1.0f;

	}

}



CTerrainScene::~CTerrainScene(void)

{

	ClearScene();



	m_pSceneManager = NULL;

}



void CTerrainScene::SetSceneManager( SceneManager* pManager )

{

	m_pSceneManager = pManager;

}



void CTerrainScene::LoadScene( const char* strFileName, SceneNode* pRootNode )

{

	if( m_pSceneManager == NULL )

		return;



	TiXmlDocument doc;



	String FileName = strFileName;

	String FullPath = "";

	{

		ResourceGroupManager::LocationList locates = ResourceGroupManager::getSingleton().getResourceLocationList(

			ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);



		ResourceGroupManager::LocationList::iterator it_begin = locates.begin();

		ResourceGroupManager::LocationList::iterator it_end = locates.end();

		while( it_begin != it_end )

		{		

			FullPath = (*it_begin)->archive->getName() + String("/") + FileName; 

			FILE* pFile = fopen( FullPath.c_str(), "rb" );

			if( pFile != NULL )

			{

				fclose(pFile);

				break;

			}

			++it_begin;

		}

		if( it_begin == it_end )

			return;

	}	



	doc.LoadFile(FullPath.c_str(), TIXML_ENCODING_UTF8);

	TiXmlElement* pRoot = doc.FirstChildElement("Scene");

	if( pRoot == NULL )

		return;



	TiXmlElement* pChild = pRoot->FirstChildElement();



	while( pChild != NULL )

	{	

		const char* pUtf8NodeName = pChild->Value();

		if( pUtf8NodeName != NULL )

		{

			if( strcmp( pUtf8NodeName, "Terrain") == 0 )

			{

				const char* pUtf8FileName = pChild->Attribute("filename");

				if( pUtf8FileName != NULL )

				{

					int len = MultiByteToWideChar( CP_UTF8, 0, pUtf8FileName, -1, NULL, 0 );

					wchar_t* pwFileName = new wchar_t[len];

					MultiByteToWideChar(CP_UTF8, 0, pUtf8FileName, -1, pwFileName, len );		

					len = WideCharToMultiByte( CP_ACP, 0, pwFileName, -1, NULL, 0, NULL, NULL );

					char* pFileName = new char[len];

					WideCharToMultiByte( CP_ACP, 0, pwFileName, -1, pFileName, len, NULL, NULL );

					delete[] pwFileName;



					LoadTerrain(pFileName, pRootNode);



					delete pFileName;

				}

			}

			else if( strcmp( pUtf8NodeName, "Object") == 0 )

			{

				const char* pUtf8Type = pChild->Attribute("type");

				if( stricmp(pUtf8Type, "StaticEntity") == 0 ||

					stricmp(pUtf8Type, "Model")  == 0 )

				{

					SceneNode* pEntityNode = NULL;

					float pos[3] = {0.0f, 0.0f, 0.0f};

					float orientation[4] = {1.0f, 0.0f, 0.0f, 0.0f};

					float scale[3] = {1.0f, 1.0f, 1.0f};



					TiXmlElement* pProperty = pChild->FirstChildElement();

					while( pProperty != NULL )

					{

						const char* pUtf8Name = pProperty->Attribute("name");

						int tagMesh = stricmp(pUtf8Name, "mesh name");

						int tagModel = stricmp(pUtf8Name, "model name");

						if(  tagMesh == 0 || tagModel == 0 )

						{

							const char* pUtf8Value = pProperty->Attribute("value");

							if( pUtf8Value != NULL )

							{

								int len = MultiByteToWideChar(CP_UTF8, 0, pUtf8Value, -1, NULL, 0);

								wchar_t* pwValue = new wchar_t[len];

								MultiByteToWideChar(CP_UTF8, 0, pUtf8Value, -1, pwValue, len);

								len = WideCharToMultiByte(CP_ACP, 0, pwValue, -1, NULL, 0, NULL, NULL);

								char* pMeshName = new char[len];

								WideCharToMultiByte(CP_ACP, 0, pwValue, -1, pMeshName, len, NULL, NULL);



								pEntityNode = pRootNode->createChildSceneNode();

								if( tagMesh == 0 )

								{

									Entity* pEntity = NULL;

									if( ResourceGroupManager::getSingleton().resourceExists(

										ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, 

										pMeshName) )

									{

										pEntity = m_pSceneManager->createEntity(pMeshName);

										pEntityNode->attachObject(pEntity);

									}

								}

								else

								{

									LoadModelObject( pMeshName, pEntityNode);

								}



								delete[] pwValue;

								delete[] pMeshName;

							}

						}

						else if( stricmp(pUtf8Name, "position") == 0 )

						{

							const char* pUtf8Value = pProperty->Attribute("value");

							if( pUtf8Value != NULL )

							{

								int len = strlen(pUtf8Value);

								char* pValue = new char[len + 1];



								const char* p1 = pUtf8Value;

								const char* p2 = pUtf8Value;

								int idx = 0;



								while( *p1 != NULL && idx < 3 )

								{

									if( *p1 == ' ' )

									{

										int interval = p1 - p2;

										memcpy( pValue, p2, interval);

										pValue[interval] = NULL;

										pos[idx] = atof(pValue);

										p2 = p1 + 1;

										++idx;

									}

									++p1;

								}

								if( idx < 3 )

								{

									int interval = p1 - p2;

									memcpy( pValue, p2, interval);

									pValue[interval] = NULL;

									pos[idx] = atof(pValue);

								}



								delete[] pValue;

							}

						}

						else if( stricmp(pUtf8Name, "orientation") == 0 )

						{

							const char* pUtf8Value = pProperty->Attribute("value");

							if( pUtf8Value != NULL )

							{

								int len = strlen(pUtf8Value);

								char* pValue = new char[len + 1];



								const char* p1 = pUtf8Value;

								const char* p2 = pUtf8Value;

								int idx = 0;



								while( *p1 != NULL && idx < 4 )

								{

									if( *p1 == ' ' )

									{

										int interval = p1 - p2;

										memcpy( pValue, p2, interval);

										pValue[interval] = NULL;

										orientation[idx] = atof(pValue);

										p2 = p1 + 1;

										++idx;

									}

									++p1;

								}

								if( idx < 4 )

								{

									int interval = p1 - p2;

									memcpy( pValue, p2, interval);

									pValue[interval] = NULL;

									orientation[idx] = atof(pValue);

								}



								delete[] pValue;

							}

						}

						else if( stricmp(pUtf8Name, "scale") == 0 )

						{

							const char* pUtf8Value = pProperty->Attribute("value");

							if( pUtf8Value != NULL )

							{

								int len = strlen(pUtf8Value);

								char* pValue = new char[len + 1];



								const char* p1 = pUtf8Value;

								const char* p2 = pUtf8Value;

								int idx = 0;



								while( *p1 != NULL && idx < 3 )

								{

									if( *p1 == ' ' )

									{

										int interval = p1 - p2;

										memcpy( pValue, p2, interval);

										pValue[interval] = NULL;

										scale[idx] = atof(pValue);

										p2 = p1 + 1;

										++idx;

									}

									++p1;

								}

								if( idx < 3 )

								{

									int interval = p1 - p2;

									memcpy( pValue, p2, interval);

									pValue[interval] = NULL;

									scale[idx] = atof(pValue);

								}



								delete[] pValue;

							}

						}



						pProperty = pProperty->NextSiblingElement();

					}



					if( pEntityNode != NULL )

					{

						pEntityNode->setScale(scale[0], scale[1], scale[2]);

						pEntityNode->setPosition(pos[0], pos[1], pos[2]);

						pEntityNode->setOrientation(orientation[0], orientation[1], orientation[2], orientation[3]);

					}

				}

			}

		}



		pChild = pChild->NextSiblingElement();

	}

}



void CTerrainScene::LoadTerrain( const char* strFileName, SceneNode* pRootNode )

{

	if( m_pSceneManager == NULL )

		return;



	String FileName = strFileName;

	String FullPath = "";

	{

		ResourceGroupManager::LocationList locates = ResourceGroupManager::getSingleton().getResourceLocationList(

			ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);



		ResourceGroupManager::LocationList::iterator it_begin = locates.begin();

		ResourceGroupManager::LocationList::iterator it_end = locates.end();

		while( it_begin != it_end )

		{		

			FullPath = (*it_begin)->archive->getName() + String("/") + FileName; 

			FILE* pFile = fopen( FullPath.c_str(), "rb" );

			if( pFile != NULL )

			{

				fclose(pFile);

				break;

			}

			++it_begin;

		}

		if(it_begin == it_end)

			return; 

	}

	TiXmlDocument doc;

	doc.LoadFile( FullPath.c_str(), TIXML_ENCODING_UTF8);

	TiXmlElement* pTerrainNode = doc.RootElement();

	if( pTerrainNode == NULL )

		return;

	const char* pUtf8XSize = pTerrainNode->Attribute("xsize");

	const char* pUtf8ZSize = pTerrainNode->Attribute("zsize");

	

	m_iTerrainWidth		= atoi(pUtf8XSize) + 1;

	m_iTerrainHeight	= atoi(pUtf8ZSize) + 1;



	TiXmlElement* texturesElement = pTerrainNode->FirstChildElement("textures");

	TiXmlElement* textureElement = texturesElement->FirstChildElement();

	int size_textures = 0;



	std::vector<TexturePtr> list_textures;



	while( textureElement != NULL )

	{	

		const char* p = textureElement->Attribute("filename");



		int len = MultiByteToWideChar(CP_UTF8, 0, p, -1, 0, 0 );

		wchar_t* wFilename = new wchar_t[len];

		MultiByteToWideChar(CP_UTF8, 0, p, -1, wFilename, len);



		len = WideCharToMultiByte(CP_ACP, 0, wFilename, -1, 0, 0, NULL, NULL);

		char* Filename = new char[len];

		WideCharToMultiByte(CP_ACP, 0, wFilename, -1, Filename, len, NULL, NULL);



		TexturePtr texturePtr = 

			TextureManager::getSingleton().getByName( Filename );

		if( texturePtr.isNull() )

		{	

			texturePtr = TextureManager::getSingleton().create( Filename, 

				ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );			    

			texturePtr->load();

		}



		list_textures.push_back(texturePtr);



		++size_textures;



		delete[] wFilename;

		delete[] Filename;



		textureElement = textureElement->NextSiblingElement();

	}



	TiXmlElement* pixmapsElement = pTerrainNode->FirstChildElement("pixmaps");

	TiXmlElement* pixmapElement = pixmapsElement->FirstChildElement();



	std::vector<PixMap> pixmaps;



	while( pixmapElement != NULL )

	{	

		PixMap pixmap;



		const char* p = pixmapElement->Attribute("textureId");

		pixmap.textureId = atof(p);

		const char* pLeftVal = pixmapElement->Attribute("left");

		if( pLeftVal != NULL )

			pixmap.left = atof(pLeftVal);

		else

			pixmap.left = 0.0f;



		const char* pTopVal = pixmapElement->Attribute("top");

		if( pTopVal != NULL )

			pixmap.top = atof(pTopVal);

		else

			pixmap.top = 0.0f;



		const char* pRightVal = pixmapElement->Attribute("right");

		if( pRightVal != NULL )

			pixmap.right = atof(pRightVal);

		else

			pixmap.right = 1.0f;



		const char* pBottomVal = pixmapElement->Attribute("bottom");

		if( pBottomVal != NULL )

			pixmap.bottom = atof(pBottomVal);

		else

			pixmap.bottom = 1.0f;



		pixmaps.push_back(pixmap);



		pixmapElement = pixmapElement->NextSiblingElement();

	}



	TiXmlElement* height_map_element =

		pTerrainNode->FirstChildElement("heightmap");

	const char* height_map_filename = height_map_element->Attribute("filename");

	TiXmlElement* gridinfo_element =

		pTerrainNode->FirstChildElement("gridInfo");

	const char* gridinfo_filename = gridinfo_element->Attribute("filename");



	int height_map_width = 0;

	int height_map_height = 0;



	if( height_map_filename != NULL )

	{

		int len = MultiByteToWideChar( CP_UTF8, 0, height_map_filename, -1, NULL, 0 );

		wchar_t* pwFileName = new wchar_t[len];

		MultiByteToWideChar(CP_UTF8, 0, height_map_filename, -1, pwFileName, len );		

		len = WideCharToMultiByte( CP_ACP, 0, pwFileName, -1, NULL, 0, NULL, NULL );

		char* pFileName = new char[len];

		WideCharToMultiByte( CP_ACP, 0, pwFileName, -1, pFileName, len, NULL, NULL );

		delete[] pwFileName;



		FileName = pFileName;

		delete[] pFileName;

		{

			ResourceGroupManager::LocationList locates = ResourceGroupManager::getSingleton().getResourceLocationList(

				ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);



			ResourceGroupManager::LocationList::iterator it_begin = locates.begin();

			ResourceGroupManager::LocationList::iterator it_end = locates.end();

			while( it_begin != it_end )

			{		

				FullPath = (*it_begin)->archive->getName() + String("/") + FileName; 

				FILE* pFile = fopen( FullPath.c_str(), "rb" );

				if( pFile != NULL )

				{

					fclose(pFile);

					break;

				}

				++it_begin;

			}

			if(it_begin != it_end)

			{

				FILE* pHeightFile = fopen( FullPath.c_str(), "rb" );

				fseek( pHeightFile, 8, SEEK_CUR );

				fread( &height_map_width, sizeof(unsigned int), 1, pHeightFile );

				fread( &height_map_height, sizeof(unsigned int), 1, pHeightFile );

				m_pHeightMapData = new float[height_map_width * height_map_height];	

				fread( m_pHeightMapData, sizeof(float), 

					height_map_width * height_map_height, pHeightFile );	

				fclose( pHeightFile );

			}

		}		

	}



	GridInfo* pGridData = NULL;

	unsigned int grid_width = 0;

	unsigned int grid_height = 0;

	if( gridinfo_filename != NULL )

	{

		int len = MultiByteToWideChar( CP_UTF8, 0, gridinfo_filename, -1, NULL, 0 );

		wchar_t* pwFileName = new wchar_t[len];

		MultiByteToWideChar(CP_UTF8, 0, gridinfo_filename, -1, pwFileName, len );		

		len = WideCharToMultiByte( CP_ACP, 0, pwFileName, -1, NULL, 0, NULL, NULL );

		char* pFileName = new char[len];

		WideCharToMultiByte( CP_ACP, 0, pwFileName, -1, pFileName, len, NULL, NULL );

		delete[] pwFileName;



		FileName = pFileName;		

		delete[] pFileName;

		{

			ResourceGroupManager::LocationList locates = ResourceGroupManager::getSingleton().getResourceLocationList(

				ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);



			ResourceGroupManager::LocationList::iterator it_begin = locates.begin();

			ResourceGroupManager::LocationList::iterator it_end = locates.end();

			while( it_begin != it_end )

			{		

				FullPath = (*it_begin)->archive->getName() + String("/") + FileName; 

				FILE* pFile = fopen( FullPath.c_str(), "rb" );

				if( pFile != NULL )

				{

					fclose(pFile);

					break;

				}

				++it_begin;

			}

			if(it_begin != it_end)

			{

				LoadGridInfo( FullPath.c_str(), NULL, &grid_width, &grid_height );

				pGridData = new GridInfo[grid_width * grid_height];

				LoadGridInfo( FullPath.c_str(), pGridData, &grid_width, &grid_height );

			}

		}		

	}



	TiXmlElement* ScaleNode =

		pTerrainNode->FirstChildElement("scale");

	if( ScaleNode != NULL )

	{

		const char* XScale = ScaleNode->Attribute("x");

		const char* YScale = ScaleNode->Attribute("y");

		const char* ZScale = ScaleNode->Attribute("z");

		if( XScale != NULL && YScale != NULL && ZScale != NULL )

		{

			m_fTerrainScale[0] = atof(XScale);

			m_fTerrainScale[1] = atof(YScale);

			m_fTerrainScale[2] = atof(ZScale);

		}

	}



	float Min[3] = {  999999,  999999,  999999 };

	float Max[3] = { -999999, -999999, -999999 };

	Min[0] = -m_fTerrainScale[0] * m_iTerrainWidth / 2.0f;	

	Max[0] =  m_fTerrainScale[0] * m_iTerrainWidth / 2.0f;

	Min[2] = -m_fTerrainScale[2] * m_iTerrainHeight / 2.0f;

	Max[2] =  m_fTerrainScale[2] * m_iTerrainHeight / 2.0f;



	float height_map_value = 0.0f;

	CUSTOMVERTEX* pTerrainVertices = new CUSTOMVERTEX[m_iTerrainWidth * m_iTerrainHeight];

	for( int i = 0; i < m_iTerrainHeight; ++i )

	{

		for( int j = 0; j < m_iTerrainWidth; ++j )

		{

			int idx = i * m_iTerrainWidth + j;



			if( m_pHeightMapData != NULL )

				height_map_value = m_pHeightMapData[idx];



			pTerrainVertices[idx].x = -m_fTerrainScale[0] * (m_iTerrainWidth / 2.0f - j);

			pTerrainVertices[idx].y =  height_map_value * m_fTerrainScale[1];

			pTerrainVertices[idx].z = -m_fTerrainScale[2] * (m_iTerrainHeight / 2.0f - i);



			if( pTerrainVertices[idx].y >Max[1] )

				Max[1] = pTerrainVertices[idx].y;

			if( pTerrainVertices[idx].y < Min[1] )

				Min[1] = pTerrainVertices[idx].y;

		}

	}



	if( m_pHeightMapData != NULL )

		delete[] m_pHeightMapData;



	std::vector<GeometryData> vecMeshes1;

	std::vector<GeometryData> vecMeshes2;

	vecMeshes1.resize(size_textures);

	vecMeshes2.resize(size_textures);



	for( int i = 0; i < size_textures; ++i )

	{

		vecMeshes1[i].pTexture = list_textures[i];

		vecMeshes1[i].numIndices = 0;

		vecMeshes1[i].numVertices = 0;



		vecMeshes2[i].pTexture = list_textures[i];

		vecMeshes2[i].numIndices = 0;

		vecMeshes2[i].numVertices = 0;

	}



	std::vector<GeometryData>* pVecMeshes = NULL;

	int pixmap_idx = -1;

	unsigned char layerOp = 0;



	for( int i = 0; i < grid_height; ++i )

	{

		for( int j = 0; j < grid_width; ++j )

		{

			for( int idx = 0; idx < 2; ++idx )

			{

				if( idx > 0 )

				{

					pixmap_idx = pGridData[i * grid_width + j].nSecondLayer;

					layerOp = pGridData[i * grid_width + j].nSecondLayerOp;

					pVecMeshes = &vecMeshes2;

				}

				else

				{

					pixmap_idx = pGridData[i * grid_width + j].nFirstLayer;

					layerOp = pGridData[i * grid_width + j].nFirstLayerOp;

					pVecMeshes = &vecMeshes1;

				}



				if( pixmap_idx < 0 )

					continue;

				for( int k = 0; k < 4; ++k )

				{

					CUSTOMVERTEX* p = &pTerrainVertices[(i + (k/2)) * m_iTerrainWidth + j + (k % 2)];

					switch(k) 

					{

					case 0:

						p->u = pixmaps[pixmap_idx].left;

						p->v = pixmaps[pixmap_idx].top;

						break;

					case 1:

						p->u = pixmaps[pixmap_idx].right;

						p->v = pixmaps[pixmap_idx].top;

						break;

					case 2:

						p->u = pixmaps[pixmap_idx].left;

						p->v = pixmaps[pixmap_idx].bottom;

						break;

					case 3:

						p->u = pixmaps[pixmap_idx].right;

						p->v = pixmaps[pixmap_idx].bottom;

						break;

					default:

						break;

					}



					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData.push_back(*p);

				}

				(*pVecMeshes)[pixmaps[pixmap_idx].textureId].numVertices = 

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData.size();



				int vertex_index = (*pVecMeshes)[pixmaps[pixmap_idx].textureId].numVertices - 1;



				if( layerOp & 0x01)

				{

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index].u = 

						pixmaps[pixmap_idx].left;

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 1].u = 

						pixmaps[pixmap_idx].right;

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 2].u = 

						pixmaps[pixmap_idx].left;

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 3].u = 

						pixmaps[pixmap_idx].right;

				}



				if( layerOp & 0x02)

				{

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index].v = 

						pixmaps[pixmap_idx].top;

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 1].v = 

						pixmaps[pixmap_idx].top;

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 2].v = 

						pixmaps[pixmap_idx].bottom;

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 3].v = 

						pixmaps[pixmap_idx].bottom;

				}



				if( layerOp & 0x04)

				{

					float u1 = (*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index].u;

					float v1 = (*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index].v;



					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index].u = 

						(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 1].u;



					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 1].u = 

						(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 3].u;

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 1].v = 

						(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 3].v;



					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 3].u = 

						(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 2].u;



					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 2].u = u1;								

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 2].v = v1;

				}



				if( layerOp & 0x08)

				{

					float u = (*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 1].u;

					float v = (*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 1].v;



					if( pGridData[i * grid_width + j].IndexOrder == 0)

					{

						(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index].u = 

							(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 3].u;

						(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index].v = 

							(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 3].v;

					}

					else

					{

						(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 1].u = 

							(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 2].u;

						(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 1].v = 

							(*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData[vertex_index - 2].v;

					}

				}



				int vert_index = (*pVecMeshes)[pixmaps[pixmap_idx].textureId].vertexData.size() - 4;



				if( pGridData[i * grid_width + j].IndexOrder == 0)

				{

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].indexData.push_back(

						vert_index);

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].indexData.push_back(

						vert_index + 2);

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].indexData.push_back(

						vert_index + 1);

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].indexData.push_back(

						vert_index + 1);

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].indexData.push_back(

						vert_index + 2);

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].indexData.push_back(

						vert_index + 3);

				}

				else

				{

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].indexData.push_back(

						vert_index);

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].indexData.push_back(

						vert_index + 2);

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].indexData.push_back(

						vert_index + 3);

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].indexData.push_back(

						vert_index + 3);

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].indexData.push_back(

						vert_index + 1);

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].indexData.push_back(

						vert_index + 0);

				}

				(*pVecMeshes)[pixmaps[pixmap_idx].textureId].numIndices = 

					(*pVecMeshes)[pixmaps[pixmap_idx].textureId].indexData.size();

			}

		}

	}	



	delete[] pTerrainVertices;

	delete[] pGridData;	



	MeshPtr pMesh = MeshManager::getSingleton().createManual( strFileName, 

		ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );



	static unsigned int index = 0;

	std::vector<GeometryData>::iterator it_begin, it_end;



	for( int i = 0; i < 2; ++i )

	{				

		if( i > 0 )

		{

			it_begin = vecMeshes2.begin();

			it_end = vecMeshes2.end();			

		}

		else

		{

			it_begin = vecMeshes1.begin();

			it_end = vecMeshes1.end();

		}



		while( it_begin != it_end )

		{

			if( it_begin->numVertices < 3 )

			{

				++it_begin;

				continue;

			}

			String materialName = it_begin->pTexture->getName() + StringConverter::toString(index);

			MaterialPtr material = Ogre::MaterialManager::getSingleton().create( materialName, "General", true );

			Ogre::Technique* technique = material->getTechnique(0);



			Ogre::Pass* pass = technique->getPass(0);



			if( i > 0 )

				pass->setSceneBlending( SBF_SOURCE_ALPHA, SBF_ONE_MINUS_SOURCE_ALPHA );

			Ogre::TextureUnitState* textureUnitState = pass->createTextureUnitState();

			textureUnitState->setTextureAddressingMode( Ogre::TextureUnitState::TAM_CLAMP );

			textureUnitState->setTextureName( it_begin->pTexture->getName() );

			++index;



			SubMesh* sm = pMesh->createSubMesh();

			sm->useSharedVertices = false;

			sm->vertexData = new VertexData();

			sm->vertexData->vertexStart = 0;

			sm->vertexData->vertexCount = it_begin->numVertices;

			VertexDeclaration* dcl = sm->vertexData->vertexDeclaration;

			size_t offset = 0;

			dcl->addElement(0, offset, VET_FLOAT3, VES_POSITION);

			offset += VertexElement::getTypeSize(VET_FLOAT3);

			dcl->addElement(0, offset, VET_FLOAT3, VES_NORMAL);

			offset += VertexElement::getTypeSize(VET_FLOAT3);

			dcl->addElement(0, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES);

			offset += VertexElement::getTypeSize(VET_FLOAT2);



			HardwareVertexBufferSharedPtr vbuf = HardwareBufferManager::getSingleton()

				.createVertexBuffer(

				offset, sm->vertexData->vertexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY );

			float* pReal = static_cast<float*>(vbuf->lock(HardwareBuffer::HBL_DISCARD));



			for( int j = 0; j < sm->vertexData->vertexCount; j++ )

			{

				*pReal++ = it_begin->vertexData[j].x;

				*pReal++ = it_begin->vertexData[j].y;

				*pReal++ = it_begin->vertexData[j].z;



				*pReal++ = 0.0f;

				*pReal++ = 1.0f;

				*pReal++ = 0.0f;



				*pReal++ = it_begin->vertexData[j].u;

				*pReal++ = it_begin->vertexData[j].v;

			}

			vbuf->unlock();

			sm->vertexData->vertexBufferBinding->setBinding( 0, vbuf);

			sm->indexData->indexCount = it_begin->numIndices;

			sm->indexData->indexBuffer = HardwareBufferManager::getSingleton()

				.createIndexBuffer(HardwareIndexBuffer::IT_32BIT, sm->indexData->indexCount,

				HardwareBuffer::HBU_STATIC_WRITE_ONLY);

			uint32* pI = static_cast<uint32*>(

				sm->indexData->indexBuffer->lock(HardwareBuffer::HBL_DISCARD));

			for( uint32 j = 0; j < sm->indexData->indexCount; j++ )

			{

				*pI++ = it_begin->indexData[j];

			}



			sm->indexData->indexBuffer->unlock();



			sm->setMaterialName( materialName );



			++it_begin;

		}

	}



	pMesh->_setBounds(AxisAlignedBox( Min[0], Min[1], Min[2], Max[0], Max[1], Max[2]));

	pMesh->_setBoundingSphereRadius(

		std::max( Max[0] - Min[0], std::max(Max[1] - Min[1], Max[2] - Min[2])) / 2.0f );

	pMesh->load();



	Entity* pEntity = m_pSceneManager->createEntity(pMesh->getName());

	pRootNode->attachObject(pEntity);

}



void CTerrainScene::LoadGridInfo( const char* strFileName, void* pGridInfo, unsigned int* pWidth, unsigned int* pHeight )

{

	if( m_pSceneManager == NULL )

		return;



	FILE* pFile = fopen( strFileName, "rb" );



	GridHeader header; 

	fread( &header, sizeof(GridHeader), 1, pFile );



	if( pGridInfo == NULL )

	{

		*pWidth = header.nWidth;

		*pHeight = header.nHeight;

		fclose(pFile);

		return;

	}



	if( *pWidth > header.nWidth || *pHeight > header.nHeight )

	{

		fclose(pFile);

		return;

	}



	char LargeVersion = 0;

	// 看版本号大于这个，就表示后面跟着有个标记用来表示结构体的大小是7字节的版本还是5字节的版本

	if( header.nVersion >= 0x00100001 )

	{

		fread(&LargeVersion , sizeof(LargeVersion), 1, pFile);

	}



	unsigned char byteValue;

	GridInfo* pInfo = (GridInfo*)pGridInfo;

	size_t numGrids = header.nWidth * header.nHeight;

	for(size_t i = 0 ; i < numGrids ; i ++)

	{		

		if( LargeVersion )

		{

			fread(&pInfo->nFirstLayer, sizeof(short), 1, pFile);

			fread(&pInfo->nFirstLayerOp, sizeof(char), 1, pFile);

			fread(&pInfo->nSecondLayer, sizeof(short), 1, pFile);			

		}

		else

		{

			fread(&byteValue, sizeof(char), 1, pFile);

			pInfo->nFirstLayer = byteValue;

			fread(&pInfo->nFirstLayerOp, 1, 1, pFile);						

			fread(&byteValue, sizeof(char), 1, pFile);

			pInfo->nSecondLayer = byteValue;

		}

		fread(&pInfo->nSecondLayerOp, sizeof(char), 1, pFile);

		fread(&pInfo->IndexOrder, sizeof(char), 1, pFile);



		pInfo->nFirstLayer--;

		pInfo->nSecondLayer--;	



		++pInfo;

	}

	fclose(pFile);

}



void CTerrainScene::TraverseBonesAndBuildSceneNodes( Node* pNode, SceneNode* pSceneNode, String suffix, bool bRoot )

{

	Node::ChildNodeIterator pChildNode = pNode->getChildIterator();



	if( bRoot )

		pSceneNode = pSceneNode->createChildSceneNode();

	else

		pSceneNode = static_cast<SceneNode*>(pSceneNode->getParent())->createChildSceneNode();

	pSceneNode->setScale(pNode->getScale());

	pSceneNode->setPosition(pNode->getPosition());

	pSceneNode->setOrientation(pNode->getOrientation());



	pSceneNode = pSceneNode->createChildSceneNode();

	pSceneNode = pSceneNode->createChildSceneNode(pNode->getName() + suffix);



	while( pChildNode.hasMoreElements() )

	{

		Node* pBone = pChildNode.getNext();		

		TraverseBonesAndBuildSceneNodes(pBone, pSceneNode, suffix, false);

	}

}



void CTerrainScene::LoadModelObject( const char* strFileName, SceneNode* pRootNode )

{	

	if( m_pSceneManager == NULL )

		return;



	String FileName = strFileName;

	String FullPath = "";

	{

		ResourceGroupManager::LocationList locates = ResourceGroupManager::getSingleton().getResourceLocationList(

			ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);



		ResourceGroupManager::LocationList::iterator it_begin = locates.begin();

		ResourceGroupManager::LocationList::iterator it_end = locates.end();

		while( it_begin != it_end )

		{		

			FullPath = (*it_begin)->archive->getName() + String("/") + FileName; 

			FILE* pFile = fopen( FullPath.c_str(), "rb" );

			if( pFile != NULL )

			{

				fclose(pFile);

				break;

			}

			++it_begin;

		}

		if(it_begin == it_end)

			return;

	}



	static unsigned int model_count = 0;

	++model_count;

	int name_len = strlen(strFileName);



	const char* p1 = strFileName + name_len;

	const char* p2 = strFileName;

	while( p1 > strFileName )

	{

		if( *p1 == '/' || *p1 == '\\')

		{

			++p1;

			break;

		}

		--p1;

	}

	int interval = p1 - p2;

	String prefix = "";

	if( interval != 1 )

	{

		char* pPrefix = new char[interval + 1];

		memcpy( pPrefix, p2, interval + 1);

		pPrefix[interval] = NULL;

		prefix = pPrefix;

		delete[] pPrefix;

	}

	TiXmlDocument doc;

	doc.LoadFile( FullPath.c_str(), TIXML_ENCODING_UTF8);



	TiXmlElement* pRoot = doc.FirstChildElement("model");

	if( pRoot == NULL )

		return;



	TiXmlElement* pFrameElem = pRoot->FirstChildElement("frame");

	std::vector<String> m_vecRootBoneName;



	if( pFrameElem != NULL )

	{

		const char* pText = pFrameElem->Attribute("name");

		int len = MultiByteToWideChar( CP_UTF8, 0, pText, -1, NULL, 0 );

		wchar_t* pwFileName = new wchar_t[len];

		MultiByteToWideChar( CP_UTF8, 0, pText, -1, pwFileName, len );

		len = WideCharToMultiByte( CP_ACP, 0, pwFileName, -1, NULL, 0, NULL, NULL );

		char* pFileName = new char[len];

		WideCharToMultiByte( CP_ACP, 0, pwFileName, -1, pFileName, len, NULL, NULL );





		SkeletonPtr pSkeleton = SkeletonManager::getSingleton().load(prefix + String(pFileName), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );

		unsigned short numAnimation = pSkeleton->getNumAnimations();

		Skeleton::BoneIterator root_bone = pSkeleton->getRootBoneIterator();



		String suffix = StringConverter::toString(model_count);



		while( root_bone.hasMoreElements() )

		{

			Bone* pBone = root_bone.getNext();

			TraverseBonesAndBuildSceneNodes( pBone, pRootNode, suffix );

		}



		for( unsigned short i = 0; i < numAnimation; ++i )

		{

			Animation* pAnim = pSkeleton->getAnimation(i);

			Animation::NodeTrackIterator it = pAnim->getNodeTrackIterator();



			String AnimName = String(pFileName) + StringConverter::toString(model_count);

			Animation* pDestAnim = m_pSceneManager->createAnimation( AnimName, pAnim->getLength() );

			pDestAnim->setInterpolationMode(pAnim->getInterpolationMode());

			AnimationState* pAnimState = m_pSceneManager->createAnimationState(AnimName);

			pAnimState->setLoop(true);

			pAnimState->setEnabled(true);		



			while( it.hasMoreElements() )

			{

				NodeAnimationTrack* pTrack = it.getNext();

				String name = pTrack->getAssociatedNode()->getName();



				SceneNode* pSceneNode = m_pSceneManager->getSceneNode(String(name) + suffix);

				NodeAnimationTrack* pDestTrack = 

					pDestAnim->createNodeTrack(pTrack->getHandle(), pSceneNode->getParent());



				unsigned short numKeyFrames = pTrack->getNumKeyFrames();

				for( unsigned short index = 0; index < numKeyFrames; ++index )

				{

					TransformKeyFrame* keyframe = 

						pDestTrack->createNodeKeyFrame(pTrack->getKeyFrame(index)->getTime()); 

					*keyframe = *(TransformKeyFrame*)(pTrack->getKeyFrame(index));

				}

			}

		}



		delete[]pwFileName;

		delete[]pFileName;

	}

	TiXmlElement* pEntityElem = pRoot->FirstChildElement("entity");

	while( pEntityElem != NULL )

	{

		const char* pUtf8MeshName = pEntityElem->Attribute("mesh");

		const char* pUtf8NodeName = pEntityElem->Attribute("node");

		SceneNode* pSceneNode = NULL;



		if( pUtf8NodeName != NULL )

		{

			int len = MultiByteToWideChar(CP_UTF8, 0, pUtf8NodeName, -1, NULL, 0 );

			wchar_t* pwNodeName = new wchar_t[len];

			MultiByteToWideChar(CP_UTF8, 0, pUtf8NodeName, -1, pwNodeName, len );

			len = WideCharToMultiByte(CP_ACP, 0, pwNodeName, -1, NULL, 0, NULL, NULL );

			char* pNodeName = new char[len];

			WideCharToMultiByte(CP_ACP, 0, pwNodeName, -1, pNodeName, len, NULL, NULL );



			String NodeName = String(pNodeName) + StringConverter::toString(model_count);

			bool bHas = m_pSceneManager->hasSceneNode(NodeName);

			if( bHas )

			{

				pSceneNode = m_pSceneManager->getSceneNode(NodeName);				

			}

			else

				pSceneNode = pRootNode->createChildSceneNode();



			delete[] pwNodeName;

			delete[] pNodeName;

		}

		else

			pSceneNode = pRootNode->createChildSceneNode();



		int len = MultiByteToWideChar(CP_UTF8, 0, pUtf8MeshName, -1, NULL, 0);

		wchar_t* pwMeshName = new wchar_t[len];

		MultiByteToWideChar(CP_UTF8, 0, pUtf8MeshName, -1, pwMeshName, len);

		len = WideCharToMultiByte(CP_ACP, 0, pwMeshName, -1, NULL, 0, NULL, NULL);

		char* pMeshName = new char[len];

		WideCharToMultiByte(CP_ACP, 0, pwMeshName, -1, pMeshName, len, NULL, NULL);



		Entity* pEntity = NULL;

		if( ResourceGroupManager::getSingleton().resourceExists(ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, prefix + String(pMeshName)) )

		{

			pEntity = m_pSceneManager->createEntity( prefix + String(pMeshName));

			pSceneNode->attachObject(pEntity);	

		}



		delete[] pwMeshName;

		delete[] pMeshName;



		if( pEntity != NULL )

		{

			bool bHas = pEntity->hasSkeleton();

			if( bHas )

			{

				bHas = pEntity->getSkeleton()->hasAnimation("[auto]");

				if( bHas )

				{

					AnimationState* pAnimState = pEntity->getAnimationState("[auto]");				

					pAnimState->setLoop( true );

					pAnimState->setEnabled( true );				

					m_AnimationStates.push_back( pAnimState );

				}

			}

		}



		TiXmlElement* pOffset = pEntityElem->FirstChildElement("offset");

		if( pOffset != NULL )

		{

			TiXmlElement* pTranslate = pOffset->FirstChildElement("translate");

			if( pTranslate != NULL )

			{

				const char* pX = pTranslate->Attribute("x");

				const char* pY = pTranslate->Attribute("y");

				const char* pZ = pTranslate->Attribute("z");

				float x = atof(pX);

				float y = atof(pY);

				float z = atof(pZ);



				pSceneNode->translate(x, y, z);				

			}

		}

		pEntityElem = pEntityElem->NextSiblingElement("entity");

	}

}



void CTerrainScene::Update( const FrameEvent& evt )

{

	std::list<AnimationState*>::iterator it_begin = m_AnimationStates.begin();

	std::list<AnimationState*>::iterator it_end = m_AnimationStates.end();



	while( it_begin != it_end )

	{

		(*it_begin)->addTime(evt.timeSinceLastFrame);

		++it_begin;

	}

}



void CTerrainScene::ClearScene()

{

	m_pSceneManager  = NULL;

	m_iTerrainWidth  = 0;

	m_iTerrainHeight = 0;

	m_pHeightMapData = NULL;



	for( int idx = 0; idx < 2; ++idx )

	{

		m_fTerrainScale[idx] = 1.0f;

	}



	m_AnimationStates.clear();

}