Ogre1.8地形和天空盒的建立（一块地形）

转自：http://www.cnblogs.com/WindyMax/

研究Ogre的程序笔记

编译环境 WIN7 32  VS2008   Ogre的版本 1.8

Ogre的地形算法是采用Geometry MIPMap的算法，当然贴图也是采用MIPMap的算法，这里有Ogre LOD算法的论文解释：http://www.flipcode.com/articles/article_geomipmaps.pdf

看到Ogre的Terrain，突然也想自己实现一个地形的打算，不过估计要过一段时间了，现在来说，ClipMap算法应该更适应现在的游戏，具体的内容可以查看http://www.docin.com/p-118698727.html，对于了解现在LOD的地形算法，这是一篇相当不错的论文

 

关于Ogre地形的代码解释，网上很多高手都已经给出很全面的解释了，我也就不多说了

#include <Ogre.h>
#include <OIS/OIS.h>
#include <iostream>
#include <OgreTerrain.h>
#include <OgreTerrainLayerBlendMap.h>
#include <OgreTerrainGroup.h>

class MyFrameListener : public Ogre::FrameListener
{
private:
	OIS::InputManager *m_pInputManage;
	OIS::Keyboard *m_pKeyBoard;
	OIS::Mouse *m_pMouse;
	Ogre::Camera *m_pCamera;
	Ogre::Viewport *m_pViewport;
	Ogre::Timer m_Time;

	bool m_bWirmline;

	float m_fMovementSpeed;

public:
	MyFrameListener( Ogre::RenderWindow *pWin, Ogre::Camera *pCamera, Ogre::Viewport *pViewport )
	{
		m_pCamera = pCamera;
		m_fMovementSpeed = 10;

		m_Time.reset();

		m_pViewport = pViewport;
		m_bWirmline = true;

		OIS::ParamList Params;
		size_t WindowHandle = 0;
		std::ostringstream WinHandleString;
		pWin->getCustomAttribute( "WINDOW", &WindowHandle );
		WinHandleString<<WindowHandle;

		Params.insert( std::make_pair( "WINDOW", WinHandleString.str() ) );

		m_pInputManage = OIS::InputManager::createInputSystem( Params );

		m_pKeyBoard = static_cast<OIS::Keyboard*>( m_pInputManage->createInputObject( OIS::OISKeyboard, false ) );
		m_pMouse = static_cast<OIS::Mouse*>( m_pInputManage->createInputObject( OIS::OISMouse, false ) );

	}
	~MyFrameListener()
	{
		m_pInputManage->destroyInputObject( m_pKeyBoard );
		m_pInputManage->destroyInputObject( m_pMouse );
		OIS::InputManager::destroyInputSystem( m_pInputManage );
	}


	bool frameStarted( const Ogre::FrameEvent& evt )
	{
		m_pKeyBoard->capture();
		bool bWalk = false;
		if( m_pKeyBoard->isKeyDown( OIS::KC_ESCAPE ) )
		{
			return false;
		}
		if( m_pKeyBoard->isKeyDown( OIS::KC_R ) && m_Time.getMilliseconds() > 250 )
		{
			m_Time.reset();
			if( m_bWirmline )
			{
				m_pCamera->setPolygonMode( Ogre::PolygonMode::PM_WIREFRAME );
				m_bWirmline = false;
			}
			else
			{
				m_pCamera->setPolygonMode( Ogre::PolygonMode::PM_SOLID );
				m_bWirmline = true;
			}
		}
		Ogre::Vector3 translate( 0, 0, 0 );

		if( m_pKeyBoard->isKeyDown( OIS::KC_W ) )
		{
			translate += Ogre::Vector3( 0, 0, -1 );
		}
		if( m_pKeyBoard->isKeyDown( OIS::KC_S ) )
		{
			translate += Ogre::Vector3( 0, 0, 1 );
		}
		if( m_pKeyBoard->isKeyDown( OIS::KC_D ) )
		{
			translate += Ogre::Vector3( 1, 0, 0 );
		}
		if( m_pKeyBoard->isKeyDown( OIS::KC_A ) )
		{
			translate += Ogre::Vector3( -1, 0, 0 );
		}

		m_pCamera->moveRelative( translate * m_fMovementSpeed * evt.timeSinceLastFrame * m_fMovementSpeed * 8 );

		m_pMouse->capture();

		float fDotX = m_pMouse->getMouseState().X.rel * evt.timeSinceLastFrame * -1;
		float fDotY = m_pMouse->getMouseState().Y.rel * evt.timeSinceLastFrame * -1;

		m_pCamera->yaw( Ogre::Radian( fDotX ) );
		m_pCamera->pitch( Ogre::Radian( fDotY ) );


		return true;
	}

	bool frameRenderingQueued( const Ogre::FrameEvent& evt )
	{
		return true;
	}

	bool frameEnded( const Ogre::FrameEvent& evt)
	{
		return true;
	}
};

class MyApplication
{
private:
	Ogre::Root *m_pRoot;
	Ogre::SceneManager *m_pSceneManage;
	MyFrameListener *m_pFrameListener;
	bool m_bKeepRunning;
	Ogre::TerrainGlobalOptions *m_pTerrGloOp;
	Ogre::TerrainGroup *m_pTerrGroup;
	bool m_bLoadNewMap;

public:
	MyApplication()
		: m_pRoot( NULL ),
		m_pSceneManage( NULL ),
		m_pFrameListener( NULL ),
		m_bKeepRunning( true ),
		m_pTerrGloOp( NULL ),
		m_bLoadNewMap( false )
	{
	}

	~MyApplication()
	{
		if( m_pTerrGloOp )
		{
			delete m_pTerrGloOp;
		}
		if( m_pTerrGroup )
		{
			delete m_pTerrGroup;
		}

		if( m_pRoot )
		{
			delete m_pRoot;
			m_pRoot = NULL;
		}
	}

	void RenderOneFrame()
	{
		Ogre::WindowEventUtilities::messagePump();
		m_bKeepRunning = m_pRoot->renderOneFrame();
	}

	bool KeepRunning()
	{
		return m_bKeepRunning;
	}

	void LoadResources()
	{
		Ogre::ConfigFile cf;
		cf.load( "resources_d.cfg" );
		Ogre::ConfigFile::SectionIterator SecIter = cf.getSectionIterator();
		Ogre::String SectionName, DataName, TypeName;

		while( SecIter.hasMoreElements() )
		{
			SectionName = SecIter.peekNextKey();
			Ogre::ConfigFile::SettingsMultiMap *SetMap = SecIter.getNext();
			Ogre::ConfigFile::SettingsMultiMap::iterator SetIter;
			for( SetIter = SetMap->begin(); SetIter != SetMap->end(); ++SetIter )
			{
				TypeName = SetIter->first;
				DataName = SetIter->second;
				Ogre::ResourceGroupManager::getSingleton().addResourceLocation( DataName, TypeName, SectionName );
			}
		}

		Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
	}

	int StartUp()
	{
		if( !m_pRoot )
		{
			m_pRoot = new Ogre::Root( "plugins_d.cfg" );
			if( !m_pRoot->showConfigDialog() )
			{
				return -1;
			}
		}
		Ogre::RenderWindow *pWindow = m_pRoot->initialise( true );

		m_pSceneManage = m_pRoot->createSceneManager( Ogre::ST_GENERIC );
		Ogre::Camera *pCamera = m_pSceneManage->createCamera( "Camera1" );
		pCamera->setPosition( 0, 1400, 100 );
		pCamera->lookAt( 0, 0, 0 );
		pCamera->setNearClipDistance( 5 );

		Ogre::Viewport *pViewport = pWindow->addViewport( pCamera );
		pViewport->setBackgroundColour( Ogre::ColourValue( 0, 0, 0, 1 ) );
		pCamera->setAspectRatio( Ogre::Real( pViewport->getActualWidth() ) / Ogre::Real( pViewport->getActualHeight() ) );

		LoadResources();
		CreateScene();
		m_pFrameListener = new MyFrameListener( pWindow, pCamera, pViewport );
		m_pRoot->addFrameListener( m_pFrameListener );
		return 0;

	}
	void ConfigureTerrain( Ogre::Light *pLight )
	{
		m_pTerrGloOp = new Ogre::TerrainGlobalOptions();
		m_pTerrGloOp->setMaxPixelError( 8 );
		m_pTerrGloOp->setCompositeMapDistance( 3000 );
		m_pTerrGloOp->setCompositeMapAmbient( m_pSceneManage->getAmbientLight() );
		m_pTerrGloOp->setLightMapDirection( pLight->getDerivedDirection() );
		m_pTerrGloOp->setCompositeMapDiffuse( pLight->getDiffuseColour() );

		m_pTerrGroup = new Ogre::TerrainGroup( m_pSceneManage, Ogre::Terrain::ALIGN_X_Z, 513, 12000 );
		m_pTerrGroup->setFilenameConvention( Ogre::String( "SaveTerrain" ), Ogre::String( "dat" ) );
		m_pTerrGroup->setOrigin( Ogre::Vector3::ZERO );
		Ogre::Terrain::ImportData &Imp = m_pTerrGroup->getDefaultImportSettings();
		Imp.maxBatchSize = 65;  //一个tile中最多包含的顶点数
		Imp.minBatchSize = 33;  //一个tile中最少包含的顶点数
		Imp.inputScale = 600;

		Imp.layerList.resize( 3 );
		Imp.layerList[0].worldSize = 100;
		Imp.layerList[0].textureNames.push_back( "dirt_grayrocky_diffusespecular.dds" );
		Imp.layerList[0].textureNames.push_back( "dirt_grayrocky_normalheight.dds" );
		Imp.layerList[1].worldSize = 30;
		Imp.layerList[1].textureNames.push_back( "grass_green-01_diffusespecular.dds" );
		Imp.layerList[1].textureNames.push_back( "grass_green-01_normalheight.dds" );
		Imp.layerList[2].worldSize = 200;
		Imp.layerList[2].textureNames.push_back( "growth_weirdfungus-03_diffusespecular.dds" );
		Imp.layerList[2].textureNames.push_back( "growth_weirdfungus-03_normalheight.dds" );
	}

	void InitBlend( Ogre::Terrain *pTerrain )
	{
		Ogre::TerrainLayerBlendMap *pBlend1 = pTerrain->getLayerBlendMap( 1 );
		Ogre::TerrainLayerBlendMap *pBlend2 = pTerrain->getLayerBlendMap( 2 );
		Ogre::Real MinHeight1 = 70;
		Ogre::Real FadeDist1 = 40;
		Ogre::Real MinHeight2 = 70;
		Ogre::Real FadeDist2 = 15;
		float *pBlend1Point = pBlend1->getBlendPointer();
		float *pBlend2Point = pBlend2->getBlendPointer();
		for( Ogre::uint16 y = 0; y < pTerrain->getLayerBlendMapSize(); ++y )
		{
			for( Ogre::uint16 x = 0; x <pTerrain->getLayerBlendMapSize(); ++x )
			{
				Ogre::Real tx, ty;
				pBlend1->convertImageToTerrainSpace( x, y, &tx, &ty );
				Ogre::Real height = pTerrain->getHeightAtTerrainPosition( tx, ty );
				Ogre::Real val = ( height - MinHeight1 ) / FadeDist1;
				val = Ogre::Math::Clamp( val, static_cast<Ogre::Real>( 0 ), static_cast<Ogre::Real>( 1 ) );
				*pBlend1Point++ = val;

				val = ( height - MinHeight2 ) / FadeDist2;
				val = Ogre::Math::Clamp( val, static_cast<Ogre::Real>( 0 ), static_cast<Ogre::Real>( 1 ) );
				*pBlend2Point++ = val;
			}
		}

		pBlend1->dirty();
		pBlend2->dirty();
		pBlend1->update();
		pBlend2->update();
	}

	void GetTerrainImage( bool bFlipx, bool bFlipy, Ogre::Image &img )
	{
		img.load( "terrain.png", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );
		if( bFlipx )
		{
			img.flipAroundY();
		}
		if( bFlipy )
		{
			img.flipAroundX();
		}
	}

	void DefineTerrain( long x, long y )
	{
		Ogre::String FileName = m_pTerrGroup->generateFilename( x, y );
		if( Ogre::ResourceGroupManager::getSingleton().resourceExists( m_pTerrGroup->getResourceGroup(), FileName ) )
		{
			m_pTerrGroup->defineTerrain( x, y );
		}
		else
		{
			Ogre::Image img;
			GetTerrainImage( x % 2, y % 2, img );
			m_pTerrGroup->defineTerrain( x, y, &img );
			m_bLoadNewMap = true;
		}
	}

	void CreateScene()
	{

		Ogre::Light *pLight = m_pSceneManage->createLight( "Light1" );
		pLight->setType( Ogre::Light::LT_DIRECTIONAL );
		pLight->setDirection( Ogre::Vector3(0.55, -0.3, 0.75) );
		pLight->setSpecularColour( Ogre::ColourValue( 0.4f, 0.4f, 0.4f ) );
		pLight->setDiffuseColour( Ogre::ColourValue::White );

		m_pSceneManage->setAmbientLight( Ogre::ColourValue( 0.2f, 0.2f, 0.2f ) );

		ConfigureTerrain( pLight );

		DefineTerrain( 0, 0 );

		m_pTerrGroup->loadAllTerrains( true );

		Ogre::TerrainGroup::TerrainIterator iter = m_pTerrGroup->getTerrainIterator();
		while( iter.hasMoreElements() )
		{
			Ogre::Terrain *t = iter.getNext()->instance;
			InitBlend( t );
		}

		if( m_bLoadNewMap )
		{
			//如果要反复修改TerrainGroup的数据，就不必保存地形了
			m_pTerrGroup->saveAllTerrains( true );  //注意，保存的是地形顶点和TerrainGroup的数据，TerrainGlobalOption的数据不会被保存
			m_bLoadNewMap =false;
		}

		m_pTerrGroup->freeTemporaryResources();
		Ogre::ColourValue FadeColour( 0.9, 0.9, 0.9 );
		m_pSceneManage->setFog( Ogre::FOG_LINEAR, FadeColour, 0.0f, 15000.0f, 28000.0f );
		Ogre::Plane plane;
		plane.d = 1000;
		plane.normal = Ogre::Vector3::NEGATIVE_UNIT_Y;
		m_pSceneManage->_setSkyPlane( true, plane, "Examples/CloudySky", 500, 20, true, 0.5f, 150, 150 );
	}
};


int main()
{

	MyApplication app;
	app.StartUp();
	while( app.KeepRunning() )
	{
		app.RenderOneFrame();
	}

	return 0;
}

　　

不过在这里主要讲下Terrain::getLayerBlendMapSize()函数，这个函数返回的是Terrain的mLayerBlendMapSize。一开始没有设置的话，mLayerBlendMapSize默认是1024。也就是说将Blend Layer平铺完这个地形，然后分成1024个“区域”，然后计算高度平铺适合的纹理，混合等。可以通过Ogre::TerrainGlobalOptions::setLayerBlendMapSize( value )函数设置...= =~~一开始困扰了我很久。

总得来说，Ogre的源码很适合想了解游戏引擎的新手研究，里面的东西不会很高深，各种设计模式也很值得去学习，无论是不是专业的游戏开发人员。待续...