etsample.cpp

etm2.2是基于Ogre引擎开发的地形库

     case OIS::KC_O:
       saveTerrain();
       return true;

     case OIS::KC_P:
       loadTerrain();
       return true;

     case OIS::KC_ESCAPE:
       mContinue = false;
       return true;

     default:
       return false;
     }
   }

   virtual bool keyReleased(const OIS::KeyEvent& arg)
   {
     // not interested in this
     switch (arg.key)
     {
     case OIS::KC_W:
       mDirection.z -= -1;
       return true;
     case OIS::KC_S:
       mDirection.z -= 1;
       return true;
     case OIS::KC_A:
       mDirection.x -= -1;
       return true;
     case OIS::KC_D:
       mDirection.x -= 1;
       return true;

     default:
       return false;
     }
   }


   void saveTerrain()
   {
     // just for demonstration, we'll save anything we can
     // start with the terrain
     Image image;
     ET::saveHeightmapToImage(*mTerrainInfo, image);
     image.save("../../Media/ET/ETterrain.png");

     // now save the splatting maps
     for (uint i = 0; i < mSplatMgr->getNumMaps(); ++i)
     {
       mSplatMgr->saveMapToImage(i, image);
       image.save("../../Media/ET/ETcoverage."+StringConverter::toString(i)+".png");
     }

     // now the lightmap
     Image lightmap;
     ET::createTerrainLightmap(*mTerrainInfo, lightmap, 512, 512, Vector3(1, -1, 1), ColourValue(1,1,1),
       ColourValue(0.3, 0.3,  0.3));
     lightmap.save("../../Media/ET/ETlightmap.png");

     // generate a base texture for this terrain (could be used for older hardware instead of splatting)
     // create an ImageList of our splatting textures.
     ET::ImageList textures (6);
     for (int i = 0; i < 6; ++i)
       textures[i].load("splatting"+StringConverter::toString(i)+".png", "ET");
     // create the base texture
     Image baseTexture;
     mSplatMgr->createBaseTexture(baseTexture, 512, 512, textures, 20, 20);
     baseTexture.save("../../Media/ET/ETbase.png");

     // finally create a minimap using the lightmap and the generated base texture
     Image minimap = ET::createMinimap(baseTexture, lightmap);
     minimap.save("../../Media/ET/ETminimap.png");
   }


   void loadTerrain()
   {
     // now we revert the process and load the data back from disk
     // recreate terrain...
     mTerrainMgr->destroyTerrain();
     Image image;
     image.load("ETterrain.png", "ET");
     ET::TerrainInfo info;
     ET::loadHeightmapFromImage(info, image);
     info.setExtents(AxisAlignedBox(0, 0, 0, 1500, 300, 1500));
     mTerrainMgr->createTerrain(info);
     mTerrainInfo = & mTerrainMgr->getTerrainInfo();

     // now load the splatting maps
     for (uint i = 0; i < mSplatMgr->getNumMaps(); ++i)
     {
       image.load("ETcoverage."+StringConverter::toString(i)+".png", "ET");
       mSplatMgr->loadMapFromImage(i, image);
     }

     // update the lightmap
     updateLightmap();
   }


   void updateLightmap()
   {
     Image lightmap;
     ET::createTerrainLightmap(*mTerrainInfo, lightmap, 128, 128, Vector3(1, -1, 1), ColourValue(1,1,1),
       ColourValue(0.3, 0.3,  0.3));

     // get our dynamic texture and update its contents
     TexturePtr tex = TextureManager::getSingleton().getByName("ETLightmap");
     tex->getBuffer(0,0)->blitFromMemory(lightmap.getPixelBox(0, 0));
   }


protected:
    RaySceneQuery *mRaySceneQuery;     // The ray scene query pointer
    bool mLMouseDown, mRMouseDown;     // True if the mouse buttons are down
    bool mMMouseDown;
    SceneManager *mSceneMgr;           // A pointer to the scene manager
    SceneNode *mPointer;               // Our "pointer" on the terrain
    CEGUI::Renderer *mGUIRenderer;     // cegui renderer
    ET::Brush mEditBrush;              // Brush for terrain editing
    bool mDeform;                      // stores which mode we are in (deform or paint)
    uint mChosenTexture;                // which of the four splatting textures is to be used?

    // movement
    Vector3 mDirection;
    bool mMove;

    SceneNode* mCamNode;

    bool mContinue;

    ET::TerrainManager* mTerrainMgr;
    const ET::TerrainInfo* mTerrainInfo;
    ET::SplattingManager* mSplatMgr;
};


class DemoETSM : public ExampleApplication
{
private:
    ET::TerrainManager* mTerrainMgr;
    ET::SplattingManager* mSplatMgr;
protected:
    CEGUI::OgreCEGUIRenderer *mGUIRenderer;
    CEGUI::System *mGUISystem;         // cegui system
public:
    DemoETSM()
    {
      mTerrainMgr = 0;
      mSplatMgr = 0;
    }

    ~DemoETSM()
    {
      delete mTerrainMgr;
      delete mSplatMgr;
    }
protected:
    void chooseSceneManager(void)
    {
      // Create instance of the Editable Terrain Scene Manager
      mSceneMgr = mRoot->createSceneManager("OctreeSceneManager", "ETInstance");
    }

    void createScene(void)
    {
      mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5));
      //mSceneMgr->setSkyDome(true, "Examples/CloudySky", 5, 8);

      // create terrain manager
      mTerrainMgr = new ET::TerrainManager(mSceneMgr);
      mTerrainMgr->setLODErrorMargin(2, mCamera->getViewport()->getActualHeight());
      mTerrainMgr->setUseLODMorphing(true, 0.2, "morphFactor");

      // create a fresh, mid-high terrain for editing
      ET::TerrainInfo terrainInfo (129, 129, vector<float>(129*129, 0.5f));
      // set position and size of the terrain
      terrainInfo.setExtents(AxisAlignedBox(0, 0, 0, 1500, 300, 1500));
      // now render it
      mTerrainMgr->createTerrain(terrainInfo);

      // create the splatting manager
      mSplatMgr = new ET::SplattingManager("ETSplatting", "ET", 128, 128, 3);
      // specify number of splatting textures we need to handle
      mSplatMgr->setNumTextures(6);

      // create a manual lightmap texture
      TexturePtr lightmapTex = TextureManager::getSingleton().createManual(
        "ETLightmap", "ET", TEX_TYPE_2D, 128, 128, 1, PF_BYTE_RGB);
      Image lightmap;
      ET::createTerrainLightmap(terrainInfo, lightmap, 128, 128, Vector3(1, -1, 1), ColourValue::White,
        ColourValue(0.3, 0.3, 0.3));
      lightmapTex->getBuffer(0, 0)->blitFromMemory(lightmap.getPixelBox(0, 0));

      // load the terrain material and assign it
      MaterialPtr material (MaterialManager::getSingleton().getByName("ETTerrainMaterial"));
      mTerrainMgr->setMaterial(material);

      // Set camera look point
      SceneNode* camNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
      camNode->setPosition( 40, 300, 580 );
      camNode->attachObject(mCamera);
      mCamera->pitch( Degree(-30) );
      mCamera->yaw( Degree(-45) );

      // CEGUI setup
      mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow, Ogre::RENDER_QUEUE_OVERLAY, false, 3000, mSceneMgr);
      mGUISystem = new CEGUI::System(mGUIRenderer);
      CEGUI::SchemeManager::getSingleton().loadScheme((CEGUI::utf8*)"TaharezLookSkin.scheme");
      CEGUI::MouseCursor::getSingleton().setImage("TaharezLook", "MouseArrow");
    }

    void createFrameListener(void)
    {
      mFrameListener= new DemoListener(mWindow, mCamera, mSceneMgr, mGUIRenderer, mTerrainMgr, mSplatMgr);
      mFrameListener->showDebugOverlay(true);
      mRoot->addFrameListener(mFrameListener);
    }

};


#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
    DemoETSM app;

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

    return 0;
}