terrscene.cc

五行MMORPG引擎系统V1.0

//-----------------------------------------------------------------------------
// 世界场景管理
// 李亦.2006.5.26
//-----------------------------------------------------------------------------

#include "terrain/terrScene.h"
#include "terrain/terrData.h"
//#include "dgl/dgl.h"
//#include "dgl/gBitmap.h"
//#include "dgl/gTexManager.h"
//#include "dgl/materialList.h"
//#include "dgl/materialPropertyMap.h"
//#include "math/mMath.h"			
//#include "math/mathIO.h"
//#include "core/fileStream.h"
//#include "core/bitStream.h"
//#include "console/consoleTypes.h"
//#include "sceneGraph/sceneGraph.h"
//#include "sceneGraph/sceneState.h"
//#include "sim/netConnection.h"


//DEFINE_FIXEDSIZE_ALLOCATOR(SceneGrid,128,128);


//--------------------------------------
TerrainScene::TerrainScene()
{
	m_pGridFlagBase = 0;
	m_pGridFlagRows = 0;
	m_pGridHashTable= 0;
}

TerrainScene::~TerrainScene()
{
	freeData();
}

void TerrainScene::freeData()
{
	if(m_pGridHashTable)
	{
		SceneGrid* it,*pDel;
		U32 nAmount = m_uHashMask+1;
		for(U32 n=0; n< nAmount; n++)
		{
			SceneGrid* pGrid = m_pGridHashTable[n];
			if(pGrid == 0)
				continue;

			for(it = m_pGridHashTable[n]; it != 0; )
			{
				pDel	= it;
				it		= it->pNext;
				delete pDel;
			}
		}
	}

	dFree(m_pGridFlagBase);
	dFree(m_pGridFlagRows);
	dFree(m_pGridHashTable);
}

void TerrainScene::initScene(TerrainBlock* pTerrain)
{
	AssertWarn(pTerrain,"地形指针不能为空...");
	m_nSceneWidth 	= pTerrain->getSquareSize() * TerrainBlock::BlockSize;
	m_nSceneHeight = m_nSceneWidth;
	m_nScenePitch	= (m_nSceneWidth + 3)& ~3; // dword对齐

	U32 nAmount = m_nScenePitch * m_nSceneHeight;
	
	//m_nHashMask = getNextPow2(nAmount >> 2) -1;	//划分4块
	m_uHashMask	= 255;
	m_pGridHashTable = (SceneGrid**)dMalloc(sizeof(SceneGrid*) * (m_uHashMask+1));
	dMemset(m_pGridHashTable, 0,sizeof(SceneGrid*) * (m_uHashMask+1));


	m_pGridFlagBase = (U8*)dMalloc(nAmount);		/// 位数/8 换算为 U8数
	dMemset(m_pGridFlagBase, 0,nAmount * sizeof(U8));
	
	m_pGridFlagRows = (U8**)dMalloc(sizeof(U8*) *m_nSceneHeight);
	for(U32 n=0; n<m_nSceneHeight; n++)
		m_pGridFlagRows[n] = m_pGridFlagBase + n * m_nScenePitch;

	//setGridAt(0,0,1); //测试
}




SceneGrid* TerrainScene::setGridAt(S32 x, S32 y,U8 cFlags)
{
	if(cFlags == 0)
		return 0;
	AssertWarn(m_pGridFlagRows && m_pGridFlagRows[y],"标志列表未分配空间");
	m_pGridFlagRows[y][x] = cFlags;
	
	SceneGrid* it;
	U32 nIndex = hashIndex(x,y);
	for(it = m_pGridHashTable[nIndex]; it != 0; it = it->pNext)
		if(it->x == x && it->y == y)
			return it;
	if(it == 0)
	{	
		it = new SceneGrid;
		it->x = x;
		it->y = y;
		it->pNext = m_pGridHashTable[nIndex];
		m_pGridHashTable[nIndex] = it;
	}
	return it;
}


//--------------------------------------
bool TerrainScene::save(const char *filename)
{
   FileStream writeFile;
   if (!ResourceManager->openFileForWrite(writeFile, filename))
      return false;

   // write the VERSION and HeightField
   writeFile.write((U8)FILE_VERSION);
	
	//基本标志信息
	U32 nAmount = m_nScenePitch * m_nSceneHeight;
   writeFile.write(m_nSceneWidth);
   writeFile.write(m_nSceneHeight);
   writeFile.write(nAmount * sizeof(U8), m_pGridFlagBase);
	
	//格子具体信息
	nAmount = m_uHashMask+1;
	writeFile.write(m_uHashMask);

	for(U32 n=0; n< nAmount; n++)
	{
		SceneGrid* pGrid = m_pGridHashTable[n];
		if(pGrid == 0)
		{
			writeFile.write((U32)0);
			continue;
		}

		U32 uGridNum = 0;
		SceneGrid* it;
		for(it = m_pGridHashTable[n]; it != 0; it = it->pNext)
			uGridNum++;

		writeFile.write(uGridNum);

		for(it = m_pGridHashTable[n]; it != 0; it = it->pNext)
		{
			writeFile.write(pGrid->x);
			writeFile.write(pGrid->y);
			writeFile.write(pGrid->uFlags);
			writeFile.write(pGrid->uMouse);

			if(m_pGridFlagRows[pGrid->y][pGrid->x] & GT_TRAP)
				writeFile.writeString(pGrid->unData.pScriptFuncName);

			else if(m_pGridFlagRows[pGrid->y][pGrid->x] & GT_ENTRY)
			{
				writeFile.write(pGrid->unData.sceEntry.nDestX);
				writeFile.write(pGrid->unData.sceEntry.nDestY);
				writeFile.write(pGrid->unData.sceEntry.pSceneName);
			}
		}//for

	}//for

   return (writeFile.getStatus() == FileStream::Ok);
}


bool TerrainScene::read(Stream &stream)
{
   U8 version;
   stream.read(&version);
   if (version > TerrainScene::FILE_VERSION)
      return NULL;

   if (version != TerrainScene::FILE_VERSION) {
      Con::errorf(" ****************************************************");
      Con::errorf(" ****************************************************");
      Con::errorf("           版本不一致，请检验后再行操作...");
      Con::errorf(" ****************************************************");
      Con::errorf(" ****************************************************");
   }

	freeData();


	stream.read(&m_nSceneWidth);
	stream.read(&m_nSceneHeight);
	m_nScenePitch	= (m_nSceneWidth + 3)& ~3; // dword对齐

	U32 nAmount = m_nScenePitch * m_nSceneHeight;
	m_pGridFlagBase = (U8*)dMalloc(nAmount);		/// 位数/8 换算为 U8数
	stream.read(nAmount, m_pGridFlagBase);

	m_pGridFlagRows = (U8**)dMalloc(sizeof(U8*) *m_nSceneHeight);
	for(U32 n=0; n<m_nSceneHeight; n++)
		m_pGridFlagRows[n] = m_pGridFlagBase + n * m_nScenePitch;



	char tempBuf[1024];


	stream.read(&m_uHashMask);
	nAmount = m_uHashMask + 1;
	m_pGridHashTable = (SceneGrid**)dMalloc(sizeof(SceneGrid*) * (nAmount));

	for(U32 n=0; n< nAmount; n++)
	{
		m_pGridHashTable[n] = 0;	//先清0

		U32 uGridNum = 0;
		stream.read(&uGridNum);
		if(uGridNum == 0)
			continue;


		for(U32 m=0; m < uGridNum;m++)
		{
			SceneGrid* pGrid = new SceneGrid;
			pGrid->pNext = m_pGridHashTable[n];
			m_pGridHashTable[n] = pGrid;

			stream.read(&pGrid->x);
			stream.read(&pGrid->y);
			stream.read(&pGrid->uFlags);
			stream.read(&pGrid->uMouse);

			if(m_pGridFlagRows[pGrid->y][pGrid->x] & GT_TRAP)
			{	
				stream.readString(tempBuf);
				pGrid->unData.pScriptFuncName = StringTable->insert(tempBuf);
			}

			else if(m_pGridFlagRows[pGrid->y][pGrid->x] & GT_ENTRY)
			{
				stream.read(&pGrid->unData.sceEntry.nDestX);
				stream.read(&pGrid->unData.sceEntry.nDestY);
				stream.readString(tempBuf);
				pGrid->unData.sceEntry.pSceneName =  StringTable->insert(tempBuf);
			}
		}//for
	}//for
	
   return (stream.getStatus() == FileStream::Ok);
}


//--------------------------------------
ResourceInstance *constructTerrainScene(Stream &stream)
{
   TerrainScene* ret = new TerrainScene;
	if(ret->read(stream))
		return ret;

	delete ret;
	return 0;
}