source: trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.cpp @ 135

#include <OgreNoMemoryMacros.h>
#include <CEGUI/CEGUI.h>
#include <../CEGUIRenderer/include/OgreCEGUIRenderer.h>
#include <../CEGUIRenderer/include/OgreCEGUIResourceProvider.h>
#include <../CEGUIRenderer/include/OgreCEGUITexture.h>
#include <OgreMemoryMacros.h>

#include <Ogre.h>
//#include "OgreReferenceAppLayer.h"
//#include "OgreRefAppWorld.h"
#include "TestCullingTerrainApplication.h"


#define WIN32_LEAN_AND_MEAN
#include <windows.h>

/*******************************************************/
/*     TestCullingTerrainApplication implementation    */
/*******************************************************/

//-----------------------------------------------------------------------
TestCullingTerrainApplication::~TestCullingTerrainApplication()
{
        if (mTerrainContentGenerator)
        {
                delete mTerrainContentGenerator;
                mTerrainContentGenerator = NULL;
        }
        //if(mRenderTargetListener)     delete mRenderTargetListener;
}
//-----------------------------------------------------------------------
void TestCullingTerrainApplication::createCamera()
{
        // create the camera
        mCamera = mSceneMgr->createCamera("PlayerCam");
        
        /** set a nice viewpoint
        *       we use a camera node here and apply all transformations on it instead
        *       of applying all transformations directly to the camera
        *       because then the camera is displayed correctly in the visualization
        */
        mCamNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(
                "CamNode1", Vector3(707, 5000, 528));
        //mCamera->setPosition(707, 5000, 528);
        mCamNode->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329));
        mCamNode->attachObject(mCamera);

        //-- create visualization camera
        mVizCamera = mSceneMgr->createCamera("VizCam");
        mVizCamera->setPosition(mCamNode->getPosition());

        mVizCamera->setNearClipDistance(1);
        mCamera->setNearClipDistance(1);

        // infinite far plane?
        if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_INFINITE_FAR_PLANE))
        {
                mVizCamera->setFarClipDistance(0);
                mCamera->setFarClipDistance(0);
        }
        else
        {
                 mVizCamera->setFarClipDistance(20000);
                 mCamera->setFarClipDistance(20000);
        }       
}

//-----------------------------------------------------------------------
bool TestCullingTerrainApplication::setup()
{
        bool result = ExampleApplication::setup();

        createRenderTargetListener();

        return result;
}
//-----------------------------------------------------------------------
void TestCullingTerrainApplication::createRenderTargetListener()
{
        mWindow->addListener(new VisualizationRenderTargetListener(mSceneMgr));
}
//-----------------------------------------------------------------------
void TestCullingTerrainApplication::createScene()
{
        // Set ambient light
        mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5));
        
        //-- create light
        mSunLight = mSceneMgr->createLight("SunLight");
        mSunLight->setType(Light::LT_DIRECTIONAL);
        //mSunLight->setType(Light::LT_SPOTLIGHT);
        //mSunLight->setSpotlightRange(Degree(30), Degree(50));

    mSunLight->setPosition(707, 2000, 500);
        mSunLight->setCastShadows(true);

        Vector3 dir(0.5, 1, 0.5);
        dir.normalise();
        mSunLight->setDirection(dir);
        //mSunLight->setDirection(Vector3::NEGATIVE_UNIT_Y);

        mSunLight->setDiffuseColour(1, 1, 1);
        mSunLight->setSpecularColour(1, 1, 1);

        // --Fog
        // NB it's VERY important to set this before calling setWorldGeometry 
        // because the vertex program picked will be different
        ColourValue fadeColour(0.93, 0.86, 0.76);
        mWindow->getViewport(0)->setBackgroundColour(fadeColour);
        //mSceneMgr->setFog( FOG_LINEAR, fadeColour, .001, 500, 1000);
        
        // Create a skybox
        mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox", 5000, false);
        
        std::string terrain_cfg("terrain.cfg");
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
        terrain_cfg = mResourcePath + terrain_cfg;
#endif
        mSceneMgr->setWorldGeometry(terrain_cfg);
        
        //-- CEGUI setup
        setupGui();

        // Floor plane
        /*
        Plane plane;
        plane.normal = Vector3::UNIT_Y;
        plane.d = -60;
        MeshManager::getSingleton().createPlane("Myplane",
                ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane,
                5000,5000,100,100,true,1,5,5,Vector3::UNIT_Z);
        Entity* pPlaneEnt = mSceneMgr->createEntity( "plane", "Myplane" );
        pPlaneEnt->setMaterialName("Examples/Rockwall");
        pPlaneEnt->setCastShadows(true);
        mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt);
        */

        if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_HWRENDER_TO_TEXTURE))
    {
                // In D3D, use a 1024x1024 shadow texture
                mSceneMgr->setShadowTextureSettings(1024, 2);
        }
        else
        {
                // Use 512x512 texture in GL since we can't go higher than the window res
                mSceneMgr->setShadowTextureSettings(512, 2);
        }
        //mSceneMgr->setShadowColour(ColourValue(0, 0, 0));
        mSceneMgr->setShadowColour(ColourValue(0.5, 0.5, 0.5));
    // mSceneMgr->setShowDebugShadows(true);


        //-- terrain content setup

        // HACK: necessary to call once before the content creation for
        // terrain initialisation
        mSceneMgr->_renderScene(mCamera, mWindow->getViewport(0), true);

        mTerrainContentGenerator = new TerrainContentGenerator(mSceneMgr);
        
        // if no objects file generate yourself
        if (!mTerrainContentGenerator->LoadObjects("objects.out"))
        {
                // to provide much occlusion,
                // height is restricted to 50, so no objects appear on peaks
                mTerrainContentGenerator->SetMaxPos(Vector3(3000.0f, 50.0f, 3000.0f));
                mTerrainContentGenerator->SetOffset(0);

                // the objects are generated on the whole terrain
                mTerrainContentGenerator->GenerateScene(1500, "robot");
                //mTerrainContentGenerator->GenerateScene(1500, "athene");
                //mTerrainContentGenerator->GenerateScene(500, "ninja");
        }

        // no limitations needed anymore: the user can set 
        // objects also on peaks of terrain
        mTerrainContentGenerator->SetMaxPos(Vector3(3000.0f, 5000.0f, 3000.0f));
}
//-----------------------------------------------------------------------
void TestCullingTerrainApplication::setupGui()
{
         mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow, Ogre::RENDER_QUEUE_OVERLAY, 
                 false, 3000, ST_EXTERIOR_CLOSE);
     mGUISystem = new CEGUI::System(mGUIRenderer);

         // Mouse
     CEGUI::SchemeManager::getSingleton().loadScheme((CEGUI::utf8*)"TaharezLook.scheme");
     CEGUI::MouseCursor::getSingleton().setImage("TaharezLook", "MouseArrow");
         mGUISystem->setDefaultMouseCursor((CEGUI::utf8*)"TaharezLook", 
                                                                           (CEGUI::utf8*)"MouseArrow");

         CEGUI::MouseCursor::getSingleton().show();
}
//-----------------------------------------------------------------------
void TestCullingTerrainApplication::createFrameListener()
{
        mTerrainFrameListener = new TerrainFrameListener(mWindow, mCamera, mSceneMgr, 
                mGUIRenderer, mTerrainContentGenerator, mVizCamera, mCamNode, mSunLight);
        
        mRoot->addFrameListener(mTerrainFrameListener);
}
//-----------------------------------------------------------------------
void TestCullingTerrainApplication::chooseSceneManager()
{
        mSceneMgr = mRoot->getSceneManager(ST_EXTERIOR_CLOSE);
}


/**************************************************************/
/*      VisualizationRenderTargetListener implementation      */
/**************************************************************/
//-----------------------------------------------------------------------
VisualizationRenderTargetListener::VisualizationRenderTargetListener(SceneManager *sceneMgr)
:RenderTargetListener(), mSceneMgr(sceneMgr)
{
}
//-----------------------------------------------------------------------
void VisualizationRenderTargetListener::preViewportUpdate(const RenderTargetViewportEvent &evt)
{
        // visualization viewport
        const bool showViz = evt.source->getZOrder() == VIZ_VIEWPORT_Z_ORDER;
        const bool nShowViz = !showViz;

        // ambient light must be full for visualization
    if (showViz)
        {
                mSceneMgr->setAmbientLight(ColourValue(1, 1, 1));
        }
        else
        {
                mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5));
        }

    mSceneMgr->setOption("ShowVisualization", &showViz);
        mSceneMgr->setOption("SkyBoxEnabled", &nShowViz);
        //mSceneMgr->setOption("SkyPlaneEnabled", &showViz);
        
        RenderTargetListener::preViewportUpdate(evt);
}
//-----------------------------------------------------------------------
void VisualizationRenderTargetListener::postRenderTargetUpdate(const RenderTargetEvent &evt)
{
        RenderTargetListener::postRenderTargetUpdate(evt);
}
//-----------------------------------------------------------------------
INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT )
{
    // Create application object
    TestCullingTerrainApplication app;

        try 
        {
        app.go();
    } 
        catch( Ogre::Exception& e ) 
        {
        MessageBox( NULL, e.getFullDescription().c_str(), 
                        "An exception has occured!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
    }   

    return 0;
}