WorldTexture=terrain_texture.jpg  //地形纹理
DetailTexture=terrain_detail.jpg  //地形细节纹理(相机距离地面很近时采用细节纹理)
DetailTile=3                      //细节纹理在一个地形小块中的平铺数
PageSource=Heightmap              //高度图数据源
Heightmap.image=terrain.png       //高度图名称(灰度图文件名),符合2^n+1
PageSize=513                      //高度图大小
TileSize=65                       //地形小块大小
MaxPixelError=3                   //决定使用层次细节时充许误差
PageWorldX=1500                   //地形在世界中的范围x方向
PageWorldZ=1500                   //z方向
MaxHeight=100                     //世界中地形最大映射高度
MaxMipMapLevel=5                  //层次细节上限
#VertexNormals=yes                //在缓冲中计算顶点法线，计算机光照或GPU程序用到时打开
#VertexColors=yes　　　　　　　　 //在缓冲中设置顶点颜色，假如有GPU程序需要时打开
#UseTriStrips=yes                 //对于现在的硬件，建议关掉
VertexProgramMorph=yes　　　      //使用顶点程序进行LOD融合处理
LODMorphStart=0.2                 //LOD融合开始点：高，低LOD之间距离之比

下列参数用于提供自己的着色程序时使用，这会提供自己定义的material，那么先前定义的
WorldTexture 与 DetailTexture的设置不再用到。

MorphLODFactorParamName=morphFactor　
//假设VertexProgramMorph被设为yes,定制的material中包括一个高级顶点程序。它指定了一个顶点
//程序的参数名，这个参数用于融合LOD,参数值从0－1，0表示不调整，1表示完全调整到下一级LOD
MorphLODFactorParamIndex         //用于materail中包含低级顶点程序的情况，意义同上
CustomMaterialName               //指定的materail名字

上述配置文件定义了基于高度图的地形。

这些参数定义可概括为两类：Ogre使用第一类从高度图产生地形
mesh与材质。

第二类是定制材质与GPU顶点程序，这可以代替ogre自动产生的着色程序。
另外的说明：
TerrainScenceManager会把高度图分为多个page,每个page由几个tile组成.它们都定义了在产生的mesh中一组构成正方形的顶点集。
WorldTexture定义的纹理不必与目标地形一样大。
PageWorldX，PageWorldZ可以缩放世界中的地形。
MaxHeight 在Y方向缩放地形。
DetailTexture 只使用一个纹理，如使用多层纹理，应该使用自定义materail。

从程序加载地形
setWorldGeometry()有重载形式，一种用于加载配置文件，另一种我们可在程序中使用，以
达到手工加载的功能。这里，SceneData被 typedef 为std:map,它存储了如我们在terrain.cfg
中看到那些值对。假设我们已经从某个二进制文件读入我们想要的内容到SceneData中。我们要做
的就是把读入的内容转换成setWorldGeometry()需要的类型。

一：清除地形分级索引缓冲及地形分页，根据地形信息数据流加载地形信息配置文件，

void TerrainSceneManager::loadConfig(DataStreamPtr& stream)，其先将地形配置信息从数据流中逐一读出到map中，然后通过void TerrainSceneManager::selectPageSource(const String& typeName,  TerrainPageSourceOptionList& optionList)设置地形数据源(目前只有高度图数据源)。在地形信息配置文件中可以配置多个地形数据源，然后根据一种数据源类型生成地形，参数 typeName就用来指定数据源类型，目前就是HeightMap，找到指定的数据源后，对指定的数据源进行初始化，

 void HeightmapTerrainPageSource::initialise(TerrainSceneManager* tsm,  ushort tileSize, ushort pageSize, bool asyncLoading, TerrainPageSourceOptionList& optionList)。初始化的过程主要是调用void HeightmapTerrainPageSource::loadHeightmap(void)将高度图灰度图像数据加载到内存中，如果是Raw数据，就加载到mRawData中，否则加载到mImage中。整个加载过程其实完成了两大工作，首先加载地形配置信息，然后加载高度图数据。

二：初始化分级索引缓冲，void TerrainSceneManager::initLevelIndexes()；

三：void OctreeSceneManager::resize( const AxisAlignedBox &box )

四：设置地形材质，void TerrainSceneManager::setupTerrainMaterial(void)；

五：设置地形分页， void TerrainSceneManager::setupTerrainPages(void)

首先创建一个名为Terrain的场景根节点的子节点

mTerrainRoot = getRootSceneNode() -> createChildSceneNode( "Terrain" );

然后初始化TerrainPage2D mTerrainPages；

最后调用 void HeightmapTerrainPageSource::requestPage(ushort x, ushort y)requestPage只支持一个Page，首先将图像数据进行缩放

然后调用 “TerrainPageSource::firePageConstructed（）”通知Listener；然后调用“TerrainPage* TerrainPageSource::buildPage(Real*heightData, const MaterialPtr& pMaterial)”创建一个新的TerrainPage对象。

buildPage()是一个比较核心的函数。它首先构造一个 TerrainPage对象，然后创建一个用于容纳该TerrainPage对象的场景节点：“page->pageSceneNode = mSceneManager->createSceneNode(name);”，然后根据对地形的分割，循环创建子SceneNode，并且创建子场景节点对应的可渲染体TerrainRenderable，将该可渲染体attach到这个子节点上。通过 “TerrainRenderable::initialise（）”来创建顶点数据、渲染方式等。

然后调用void TerrainSceneManager::attachPage(ushort pageX, ushort pageZ, TerrainPage* page)加入到mTerrainPages中；

然后在attachPage中调用“mTerrainRoot->addChild(page->pageSceneNode);”加入到SceneGraph中。

注：当前只支持一个Page，该分页被挂接到一个称谓Terrain的场景节点上，该场景节点下面又创建了很多子场景节点，每一个子场景节点对应一个tile，也就是一个独立的可渲染体TerrainRenderable

纹理好像还有些问题....

模型贴花，根据贴花所在的网格自动生成模型（一般贴图）

投影贴花，利用投影纹理的方式实现的贴花（frustum）

网格贴花，创建指定大小的网格贴花，然后自动调整网格的位置（mesh，贴图）

#include "ExampleApplication.h"

class TutorialFrameListener : public ExampleFrameListener, public OIS::MouseListener, public OIS::KeyListener
{
public:
    TutorialFrameListener(RenderWindow* win, Camera* cam, SceneManager *sceneMgr)
        : ExampleFrameListener(win, cam, true, true)
    {
        // Populate the camera and scene manager containers
        mCamNode = cam->getParentSceneNode();
        mSceneMgr = sceneMgr;

        // set the rotation and move speed
        mRotate = 0.13;
        mMove = 250;

        // continue rendering
        mContinue = true;

        mMouse->setEventCallback(this);
        mKeyboard->setEventCallback(this);

        mDirection = Vector3::ZERO;
    }

    bool frameStarted(const FrameEvent &evt)
    {
        if(mMouse)
            mMouse->capture();
        if(mKeyboard) 
            mKeyboard->capture();

        mCamNode->translate(mDirection * evt.timeSinceLastFrame, Node::TS_LOCAL);
        return mContinue;
    }

    // MouseListener
    bool mouseMoved(const OIS::MouseEvent &e)
    {
        if (e.state.buttonDown(OIS::MB_Right))
        {
            mCamNode->yaw(Degree(-mRotate * e.state.X.rel), Node::TS_WORLD);
            mCamNode->pitch(Degree(-mRotate * e.state.Y.rel), Node::TS_LOCAL);
        }
        return true;
    }

    bool mousePressed(const OIS::MouseEvent &e, OIS::MouseButtonID id)
    {
        Light *light = mSceneMgr->getLight("Light1");
        switch (id)
        {
        case OIS::MB_Left:
            light->setVisible(! light->isVisible());
            break;
        }
        return true;
    }

    bool mouseReleased(const OIS::MouseEvent &e, OIS::MouseButtonID id) { return true; }

    // KeyListener
    bool keyPressed(const OIS::KeyEvent &e)
    {
        switch (e.key)
        {
        case OIS::KC_ESCAPE: 
            mContinue = false;
            break;

        case OIS::KC_1:
            mCamera->getParentSceneNode()->detachObject(mCamera);
            mCamNode = mSceneMgr->getSceneNode("CamNode1");
            mCamNode->attachObject(mCamera);
            break;

        case OIS::KC_2:
            mCamera->getParentSceneNode()->detachObject(mCamera);
            mCamNode = mSceneMgr->getSceneNode("CamNode2");
            mCamNode->attachObject(mCamera);
            break;

        case OIS::KC_UP:
        case OIS::KC_W:
            mDirection.z -= mMove;
            break;

        case OIS::KC_DOWN:
        case OIS::KC_S:
            mDirection.z += mMove;
            break;

        case OIS::KC_LEFT:
        case OIS::KC_A:
            mDirection.x -= mMove;
            break;

        case OIS::KC_RIGHT:
        case OIS::KC_D:
            mDirection.x += mMove;
            break;

        case OIS::KC_PGDOWN:
        case OIS::KC_E:
            mDirection.y -= mMove;
            break;

        case OIS::KC_PGUP:
        case OIS::KC_Q:
            mDirection.y += mMove;
            break;
        }
        return true;
    }

    bool keyReleased(const OIS::KeyEvent &e)
    {
        switch (e.key)
        {
        case OIS::KC_UP:
        case OIS::KC_W:
            mDirection.z += mMove;
            break;

        case OIS::KC_DOWN:
        case OIS::KC_S:
            mDirection.z -= mMove;
            break;

        case OIS::KC_LEFT:
        case OIS::KC_A:
            mDirection.x += mMove;
            break;

        case OIS::KC_RIGHT:
        case OIS::KC_D:
            mDirection.x -= mMove;
            break;

        case OIS::KC_PGDOWN:
        case OIS::KC_E:
            mDirection.y += mMove;
            break;

        case OIS::KC_PGUP:
        case OIS::KC_Q:
            mDirection.y -= mMove;
            break;
        } // switch
        return true;
    }
protected:
    Real mRotate;          // The rotate constant
    Real mMove;            // The movement constant

    SceneManager *mSceneMgr;   // The current SceneManager
    SceneNode *mCamNode;   // The SceneNode the camera is currently attached to

    bool mContinue;        // Whether to continue rendering or not
    Vector3 mDirection;     // Value to move in the correct direction
};

class TutorialApplication : public ExampleApplication
{
public:
    void createCamera(void)
    {
        // create camera, but leave at default position
        mCamera = mSceneMgr->createCamera("PlayerCam"); 
        mCamera->setNearClipDistance(5);
    }

    void createScene(void)
    {
        mSceneMgr->setAmbientLight(ColourValue(0.25, 0.25, 0.25));

        // add the ninja
        Entity *ent = mSceneMgr->createEntity("Ninja", "ninja.mesh");
        SceneNode *node = mSceneMgr->getRootSceneNode()->createChildSceneNode("NinjaNode");
        node->attachObject(ent);

        // create the light
        Light *light = mSceneMgr->createLight("Light1");
        light->setType(Light::LT_POINT);
        light->setPosition(Vector3(250, 150, 250));
        light->setDiffuseColour(ColourValue::White);
        light->setSpecularColour(ColourValue::White);

        // Create the scene node
        node = mSceneMgr->getRootSceneNode()->createChildSceneNode("CamNode1", Vector3(-400, 200, 400));
        node->yaw(Degree(-45));
        node->attachObject(mCamera);

        // create the second camera node/pitch node
        node = mSceneMgr->getRootSceneNode()->createChildSceneNode("CamNode2", Vector3(0, 200, 400));
    }

    void createFrameListener(void)
    {
        // Create the FrameListener
        mFrameListener = new TutorialFrameListener(mWindow, mCamera, mSceneMgr);
        mRoot->addFrameListener(mFrameListener);

        // Show the frame stats overlay
        mFrameListener->showDebugOverlay(true);
    }
};

#if OGRE_PLATFORM == PLATFORM_WIN32 || OGRE_PLATFORM == OGRE_PLATFORM_WIN32
#define WIN32_LEAN_AND_MEAN
#include "windows.h"

INT WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT)
#else
int main(int argc, char **argv)
#endif
{
    // Create application object
    TutorialApplication app;

    try {
        app.go();
    } catch(Exception& e) {
#if OGRE_PLATFORM == PLATFORM_WIN32 || OGRE_PLATFORM == OGRE_PLATFORM_WIN32
        MessageBox(NULL, e.getFullDescription().c_str(), "An exception has occurred!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
#else
        fprintf(stderr, "An exception has occurred: %s\n",
            e.getFullDescription().c_str());
#endif
    }

    return 0;
}

按照理论来说
unbuffered：不断的响应按键信息，直到按键放开。例如，按下上下左右，使得角色持续移动。 
               一般来讲适合于3D场景漫游过程，当在每帧渲染之前，系统捕获输入设备状态，并根据这些状态对场景中的物体和摄象机进行控制。 
buffered：在一个按键放开之前，只处理一次输入信息。 
             例如呼出主菜单。适合于GUI界面的情况（如设置菜单），输入设备状态可以被发送到各GUI元素进行处理（如按钮被按下）。

这个例子试图说明缓冲输入和非缓冲输入的区别，但是让我困惑的是为什么采用了缓冲输入系统还能响应持续按键呢？编译后运行按住WSAD照样移动摄像机。