source: GTP/trunk/App/Demos/Vis/HillyTerrain/OGRE/TestCullingTerrainApplication.cpp @ 1003

#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 <OgreIteratorWrappers.h>
#include <Ogre.h>
#include "TestCullingTerrainApplication.h"
#include "TerrainFrameListener.h"

// #include "OgreColladaPrerequisites.h"
#include "OgreColladaDocument.h"
#include "OgreColladaScene.h"


#include "IVReader.h"

#define WIN32_LEAN_AND_MEAN
#include <windows.h>

const static bool USE_STATIC_GEOMETRY = false;
bool TestCullingTerrainApplication::msShowHillyTerrain = false;



/*************************************************************/
/*                EntityState implementation                 */
/*************************************************************/


Vector3 EntityState::msMinPos = Vector3::ZERO;
Vector3 EntityState::msMaxPos = Vector3::ZERO;

EntityState::EntityState(Entity *ent, State entityState, Real speed):
mEntity(ent), mState(entityState), mAnimationSpeed(speed)
{
        switch(entityState)
        {
        case MOVING:
                mAnimationState = mEntity->getAnimationState("Walk");
                break;
        case WAITING:
                mAnimationState = mEntity->getAnimationState("Idle");
                break;
        case STOP:
                mAnimationState = NULL;
                break;
        default:
                break;
        }
        // enable animation state
        if (mAnimationState)
        {
                mAnimationState->setLoop(true);
                mAnimationState->setEnabled(true);
        }

        mTimeElapsed = Math::RangeRandom(1, 5);
}
//-----------------------------------------------------------------------
EntityState::~EntityState()
{
        mAnimationState = NULL;
        mEntity = NULL;
}
//-----------------------------------------------------------------------
Entity *EntityState::GetEntity()
{
        return mEntity;
}
//-----------------------------------------------------------------------
EntityState::State EntityState::GetState()
{
        return mState;
}
//-----------------------------------------------------------------------
void EntityState::update(Real timeSinceLastFrame)
{
        mTimeElapsed -= timeSinceLastFrame * mAnimationSpeed;

        if (!mEntity || !mAnimationState)
                return;
        
        if (mState == MOVING) // toggle between moving (longer) and waiting (short)
        {
                SceneNode *parent = mEntity->getParentSceneNode();
                
                if (!parent)
                        return;

                if (mTimeElapsed <= 0) // toggle animation state
                {
                        if (mAnimationState->getAnimationName() == "Idle")
                        {
                                SetAnimationState("Walk", true);
                                
                                mTimeElapsed = walk_duration; // walk for mTimeElapsed units

                                // choose random rotation
                                Radian rnd = Radian(Math::UnitRandom() * Math::PI * rotate_factor);

                                //mEntity->getParentSceneNode()->rotate();
                                parent->yaw(rnd);                                               
                        }
                        else 
                        {
                                SetAnimationState("Idle", true);
                                mTimeElapsed = wait_duration; // wait for mTimeElapsed seconds
                        }
                }

                if (mAnimationState->getAnimationName() == "Walk") // move forward
                {
                        // store old position, just in case we get out of bounds
                        Vector3 oldPos = parent->getPosition();
                        parent->translate(parent->getLocalAxes(), Vector3(move_factor * mAnimationSpeed, 0, 0));

                        // HACK: if out of bounds => reset to old position and set animationstate to idle
                        if (OutOfBounds(parent)) 
                        {
                                parent->setPosition(oldPos);
                                SetAnimationState("Idle", true);
                                
                                mTimeElapsed = wait_duration;
                        }
                }
        }
                
        // add time to drive animation
        mAnimationState->addTime(timeSinceLastFrame * mAnimationSpeed);
}
//-----------------------------------------------------------------------
void EntityState::SetAnimationState(String stateStr, bool loop)
{
        if (!mEntity)
                return;

        mAnimationState = mEntity->getAnimationState(stateStr);
        mAnimationState->setLoop(loop);
        mAnimationState->setEnabled(true);
}
//-----------------------------------------------------------------------
bool EntityState::OutOfBounds(SceneNode *node)
{
        Vector3 pos = node->getPosition();

        if ((pos > msMinPos) && (pos < msMaxPos))
                return false;

        return true;
}



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


TestCullingTerrainApplication::TestCullingTerrainApplication():
mTerrainContentGenerator(NULL), 
mRayQueryExecutor(NULL),
mIVReader(NULL),
mFilename("terrain"),
mEnvironmentFilename("generate_viewcells.env")
{
}
//-------------------------------------------------------------------------
void TestCullingTerrainApplication::loadConfig(const String& filename)
{
        // TODO matt
        // Set up the options
        ConfigFile config;
        String val;

        config.load(filename);

        std::stringstream d; d << "reading the config file from: " << filename;
        LogManager::getSingleton().logMessage(d.str());

        val = config.getSetting("Scene");

    if (!val.empty())
        {
                 mFilename = val.c_str();
                 d << "\nloading scene from file: " << mFilename;
                 LogManager::getSingleton().logMessage(d.str());
        }

        
        /*val = config.getSetting("ViewCells");
        if (!val.empty())
        {        mViewCellsFilename = val.c_str();}*/

        val = config.getSetting("VisibilityEnvironment");

        if (!val.empty())
        {
                 mEnvironmentFilename = val.c_str();
                 std::stringstream d; d << "loading environment from file: " << mEnvironmentFilename;
                 LogManager::getSingleton().logMessage(d.str());
        }

        Vector3 v = Vector3::UNIT_SCALE;

        val = config.getSetting("ViewX");

        if (!val.empty())
                v.x = atof( val.c_str() );

        val = config.getSetting("ViewY");
        
        if (!val.empty())
                v.y = atof(val.c_str());

        val = config.getSetting("ViewZ");
        
        if (!val.empty())
                v.z = atof( val.c_str());


        /////////////////////////
        // setup scene

        //-- load the scene from specified file
        if (!LoadScene(mFilename))
                LogManager::getSingleton().logMessage("error loading scene");


        GtpVisibility::VisibilityManager *mVisManager = NULL;

        //-- load the environment from file
        if (mSceneMgr->getOption("VisibilityManager", &mVisManager))
        {
                GtpVisibility::VisibilityEnvironment *visEnv = mVisManager->GetVisibilityEnvironment();
                
                if (!visEnv->LoadEnvironment(mEnvironmentFilename))
                {
                        std::stringstream d; d << "failed loading environment from " << mEnvironmentFilename;
                        LogManager::getSingleton().logMessage(d.str());
                }
                else //-- load environment options
                {
                        //-- get view cells file name, load view cells only on demand
                        mViewCellsFilename = visEnv->getViewCellsFileName();

                        std::stringstream d; d << "view cells file name: " << mViewCellsFilename;
                        LogManager::getSingleton().logMessage(d.str());
                }
        }
        else
        {
                LogManager::getSingleton().logMessage("error: no visibility scenemanager available");
        }
        // set camera position accordingly
        mCamNode->setPosition(v);
}
//-----------------------------------------------------------------------
TestCullingTerrainApplication::~TestCullingTerrainApplication()
{
        OGRE_DELETE(mTerrainContentGenerator);
        OGRE_DELETE(mRayQueryExecutor);
        OGRE_DELETE(mIVReader);

        deleteEntityStates();   
}
//-----------------------------------------------------------------------
void TestCullingTerrainApplication::deleteEntityStates()
{
        for (int i = 0; i < (int)mEntityStates.size(); ++i)
        {
                OGRE_DELETE(mEntityStates[i]);
        }

        mEntityStates.clear();
}
//-----------------------------------------------------------------------
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));
        
        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 carryOn = ExampleApplication::setup();

        if (carryOn)
                createRenderTargetListener();

        return carryOn;
}
//-----------------------------------------------------------------------
void TestCullingTerrainApplication::createRenderTargetListener()
{
        mWindow->addListener(new VisualizationRenderTargetListener(mSceneMgr));
}
//-----------------------------------------------------------------------
bool TestCullingTerrainApplication::LoadSceneCollada(const String &filename, 
                                                                                                         SceneNode *root, 
                                                                                                         const int index)
{
        // Collada
        ColladaDocument *daeDoc = new ColladaDocument(mSceneMgr);

        String daeName = filename;
        //if (daeName.empty()) 
        //      daeName = "City_1500.dae";

        // default directory
        //daeName.insert(0, "../../media/models/collada/City");
        LogManager::getSingleton().logMessage("ColladaDocument - import started");

        // full import
        if (daeDoc->doImport(daeName))
        {
                LogManager::getSingleton().logMessage("yuppi");
                /**
                 * build up scene
                 * if you only want a specific part of the scene graph, you must fetch a scene node
                 * by its unique node name and give it as parameter
                 * e.g.
                 * ColladaSceneNode *box = mScene->getNode("Box2");
                 * if (box != NULL) box->createOgreInstance(NULL);
                 */
                daeDoc->getScene()->createOgreInstance(NULL);

                // everything is loaded, we do not need the collada document anymore
                delete daeDoc;

                return true;
        }
        else
        {
                LogManager::getSingleton().logMessage("ColladaDocument - import failed");
                return false;
        }

        return true;
}
//-----------------------------------------------------------------------
bool TestCullingTerrainApplication::LoadSceneIV(const String &filename, 
                                                                                                SceneNode *root, 
                                                                                                const int index)
{



        mIVReader = new IVReader();

        Timer *timer = PlatformManager::getSingleton().createTimer();
        timer->reset();
        if (1)
        {
                std::string logFilename = "IVLog" + Ogre::StringConverter().toString(index) + ".log";
                
                Log *log = LogManager::getSingleton().createLog(logFilename);
                mIVReader->setLog(log);
        }
        
        //viennaNode->translate(Vector3(-300, -300, 0));

        if (mIVReader->loadFile(filename.c_str()))
        {
                SceneNode *node = root->createChildSceneNode("IVSceneNode" + index);

                mIVReader->buildTree(mSceneMgr, node);
                
                mIVReader->collapse();
                OGRE_DELETE(mIVReader);


                std::stringstream d; 
                d << "loaded " << filename << " in " << timer->getMilliseconds() * 1e-3 << " secs";
                LogManager::getSingleton().logMessage(d.str());
                
                PlatformManager::getSingleton().destroyTimer(timer);

                //-- bake into static geometry
                if (USE_STATIC_GEOMETRY)
                {
                        BakeSceneIntoStaticGeometry("staticVienna", "Vienna");
                }
        
                return true;
        }

        return false;
}
//--------------------------------------------------------
void TestCullingTerrainApplication::BakeSceneIntoStaticGeometry(const String &staticGeomName, 
                                                                                                                                const String &nodeName)
{
#if OGRE_103
        // note: different static geom for roofs, roads, ..., becazse they have same material
        StaticGeometry *staticGeom = mSceneMgr->createStaticGeometry(staticGeomName);

        // note: looping over entities here. why does scene node not work?
        SceneManager::EntityIterator it = mSceneMgr->getEntityIterator();
        while (it.hasMoreElements())
        {
                Entity *ent = it.getNext();
                ent->setVisible(false);
                staticGeom->addEntity(ent, ent->getParentSceneNode()->getPosition());
        }

        staticGeom->setRegionDimensions(Vector3(100,100,100));
        staticGeom->build();

        // cleanup node
        //wallsNode->detachAllObjects();
        
        //roofsNode->detachAllObjects();
        //roadsNode->detachAllObjects();
        //planeNode->detachAllObjects();
        
        //viennaNode->removeChild("Walls");
        mSceneMgr->destroySceneNode(nodeName);
#endif
}
//--------------------------------------------------------
void TestCullingTerrainApplication::createScene()
{
        //-- load scene
        loadConfig("terrainCulling.cfg");
        
        /////////////////////////////////////

        // Set ambient light
        mAmbientLight = ColourValue(0.5, 0.5, 0.5);
        mSceneMgr->setAmbientLight(mAmbientLight);
        
        //-- 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);

        // set light angle not too small over the surface, otherwise shadows textures will be broken
        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/CloudyNoonSkyBox", 5000, true);
        
        if (msShowHillyTerrain)
        {
                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();

        // occluder plane to test visibility
        if (0)
        {
                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);
        }

        // Warning: In GL since we can't go higher than the window res
        mSceneMgr->setShadowTextureSettings(1024, 2);

        mSceneMgr->setShadowColour(ColourValue(0.5, 0.5, 0.5));

        //-- terrain content setup

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

        // ray query executor: needed to clamp to terrain
        mRayQueryExecutor = new RayQueryExecutor(mSceneMgr);

        mTerrainMinPos = EntityState::msMinPos = Vector3(0, 0, 0);
        mTerrainMaxPos = EntityState::msMaxPos = Vector3(5000, 5000, 5000);

        mTerrainContentGenerator = new TerrainContentGenerator(mSceneMgr);
                
        if (!msShowHillyTerrain)
                return;

        // if no objects in file, we generate new objects
        if (!mTerrainContentGenerator->LoadObjects("objects.out"))
        {
                // the objects are generated randomly distributed over the terrain
                if (1) generateScene(1500, 0); // create robots
                if (0) generateScene(100, 1); // create trees
                if (0) generateScene(100, 2); // create ninjas
        }
}
//-----------------------------------------------------------------------
void  TestCullingTerrainApplication::generateScene(int num, int objectType)
{
        float val = TerrainFrameListener::msObjectScales[objectType];
        Vector3 scale(val, val, val); 
        const float maxHeight = 75;
        
        // In order to provide much occlusion,
        // height is restricted to maxHeight => no objects are created on peaks
        mTerrainContentGenerator->SetMinPos(Vector3(mTerrainMinPos));
        mTerrainContentGenerator->SetMaxPos(Vector3(mTerrainMaxPos.x, maxHeight, mTerrainMaxPos.z));
        
        //std::stringstream d; d << "objscale: " << scale[0];
        //Ogre::LogManager::getSingleton().logMessage(d.str());
        
        mTerrainContentGenerator->SetScale(scale);
        mTerrainContentGenerator->SetOffset(TerrainFrameListener::msObjectTerrainOffsets[objectType]);
        mTerrainContentGenerator->GenerateScene(num, TerrainFrameListener::msObjectCaptions[objectType]);

        if (objectType != 0) // from our objects, only robot has animation phases
                return;

        EntityList *entList = mTerrainContentGenerator->GetGeneratedEntities();

        //-- add animation state for new robots (located at the end of the list)
        for (int i = (int)entList->size() - num; i < (int)entList->size(); ++i)
        {
                mEntityStates.push_back(new EntityState((*entList)[i], 
                        EntityState::WAITING, Math::RangeRandom(0.5, 1.5)));
        }

        // release limitations on height => it is possible for the user to put single 
        // objects on peaks of the terrain (will be only few, not relevant for occlusion)
        mTerrainContentGenerator->SetMaxPos(mTerrainMaxPos);
}
//-----------------------------------------------------------------------
void TestCullingTerrainApplication::updateAnimations(Real timeSinceLastFrame)
{
        for (int i = 0; i < (int)mEntityStates.size(); ++i)
        {
                SceneNode *sn = mEntityStates[i]->GetEntity()->getParentSceneNode();

                mEntityStates[i]->update(timeSinceLastFrame);

                if (mEntityStates[i]->GetState() == EntityState::MOVING)
                {
                        Clamp2Terrain(sn, 0); //sn->setNodeVisible(false);
                }
        }
}
//-----------------------------------------------------------------------
EntityStates  &TestCullingTerrainApplication::getEntityStates()
{
        return mEntityStates;
}
//-----------------------------------------------------------------------
void TestCullingTerrainApplication::setupGui()
{
#if OGRE103
         mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow, Ogre::RENDER_QUEUE_OVERLAY, 
                 false, 3000, ST_EXTERIOR_CLOSE);
#else
          mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow, Ogre::RENDER_QUEUE_OVERLAY, 
                 false, 3000, mSceneMgr);
#endif
     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().hide();
}
//-----------------------------------------------------------------------
void TestCullingTerrainApplication::createFrameListener()
{
        mTerrainFrameListener = new TerrainFrameListener(mWindow, mCamera, mSceneMgr, 
                mGUIRenderer, mTerrainContentGenerator, mVizCamera, mCamNode, mSunLight, this);
        
        mRoot->addFrameListener(mTerrainFrameListener);
}
//-----------------------------------------------------------------------
void TestCullingTerrainApplication::chooseSceneManager()
{
#ifdef OGRE_103
        if (msShowHillyTerrain)
        {
                // Terrain scene manager
                mSceneMgr = mRoot->getSceneManager(ST_EXTERIOR_CLOSE);
        }
        else
        {       // octree scene manager
                mSceneMgr = mRoot->getSceneManager(ST_GENERIC);
        }
#else
        if (msShowHillyTerrain)
        {
                //mSceneMgr = mRoot->createSceneManager("TerrainSceneManager");
                mSceneMgr = mRoot->createSceneManager("OcclusionCullingSceneManager");
                //mSceneMgr = mRoot->createSceneManager("KdTreeSceneManager");
                //mSceneMgr = mRoot->createSceneManager("OctreeSceneManager");
        }
        else
        {       
                //mSceneMgr = mRoot->createSceneManager("OctreeSceneManager");
                mSceneMgr = mRoot->createSceneManager("OcclusionCullingSceneManager");
                //mSceneMgr = mRoot->createSceneManager("KdTreeSceneManager");
                //mSceneMgr = mRoot->createSceneManager("OctreeSceneManager");
        }

#endif
}
//-----------------------------------------------------------------------
bool TestCullingTerrainApplication::Clamp2Terrain(SceneNode *node, int terrainOffs)
{
        // clamp scene node to terrain
        Vector3 pos = node->getPosition();
        Vector3 queryResult;

        if (mRayQueryExecutor->executeRayQuery(&queryResult, 
                        Vector3(pos.x, MAX_HEIGHT, pos.z), Vector3::NEGATIVE_UNIT_Y))
        {
        node->setPosition(pos.x, queryResult.y + terrainOffs, pos.z);
                return true;
        }

        return false;
}

//-----------------------------------------------------------------------
bool TestCullingTerrainApplication::Clamp2FloorPlane()
{
    // clamp to floor plane
        RaySceneQuery *raySceneQuery = mSceneMgr->createRayQuery(
                Ray(mCamNode->getPosition(), Vector3::NEGATIVE_UNIT_Y));

        RaySceneQueryResult& qryResult = raySceneQuery->execute();
    
        RaySceneQueryResult::iterator rit = qryResult.begin();
 
        while (rit != qryResult.end() && rit->movable)
        {
                if (rit->movable->getName() != "PlayerCam")
                {
                        mCamNode->setPosition(mCamNode->getPosition().x,
                                rit->movable->getWorldBoundingBox().getCenter().y + 2, 
                                mCamNode->getPosition().z);
        
                        /*
                        std::stringstream d;
                        d << "World: " << it->movable->getWorldBoundingBox().getCenter().y <<
                        ", Object: " << it->movable->getBoundingBox().getCenter().y <<
                        ", Camera: " << mCamera->getDerivedPosition();

                        LogManager::getSingleton().logMessage(d.str());*/

                        return true;
                }

                ++ rit;
        }
    
        OGRE_DELETE(raySceneQuery);
        return false;
}

//-----------------------------------------------------------------------
// splits strings containing multiple file names
static int SplitFilenames(const std::string str, std::vector<std::string> &filenames)
{
        int pos = 0;

        while(1) 
        {
                int npos = (int)str.find(';', pos);
                
                if (npos < 0 || npos - pos < 1)
                        break;
                filenames.push_back(std::string(str, pos, npos - pos));
                pos = npos + 1;
        }
        
        filenames.push_back(std::string(str, pos, str.size() - pos));
        return (int)filenames.size();
}

//-----------------------------------------------------------------------
bool TestCullingTerrainApplication::LoadScene(const String &filename)
{
        using namespace std;
        // use leaf nodes of the original spatial hierarchy as occludees
        vector<string> filenames;
        int files = SplitFilenames(filename, filenames);
        
        std::stringstream d;
        d << "number of input files: " << files << "\n";
        LogManager::getSingleton().logMessage(d.str());

        bool result = false;
        vector<string>::const_iterator fit, fit_end = filenames.end();
        int i = 0;
        // root for different files
        for (fit = filenames.begin(); fit != fit_end; ++ fit, ++ i)
        {
                const string fn = *fit;

                if (strstr(fn.c_str(), ".iv") || strstr(fn.c_str(), ".wrl"))
                {
                        // hack: set postion manually for vienna
                        //mCamNode->setPosition(Vector3(830, 300, -540));
                        //mCamNode->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329));

                        // load iv files
                        LoadSceneIV(fn, mSceneMgr->getRootSceneNode(), i);                      
                }
                else if (strstr(filename.c_str(), ".dae"))
                {
                        // load collada files
                        // load iv files
                        LoadSceneCollada(fn, mSceneMgr->getRootSceneNode(), i);         
                }
                else //if (filename == "terrain")
                {
                        // terrain hack
                        msShowHillyTerrain = true;
                        LogManager::getSingleton().logMessage("loading terrain");
                }
        
                result = true;
        }
        

        /*
        if (result) 
        {
                int intersectables, faces;

          std::stringstream d;
          d << filename << " parsed successfully.\n"
                << "#NUM_OBJECTS (Total numner of objects)\n" << intersectables << "\n"
                << "#NUM_FACES (Total numner of faces)\n" << faces << "\n";
        }
        */
        
        return result;
}
//-----------------------------------------------------------------------
bool TestCullingTerrainApplication::LoadViewCells(const String &filename)
{
        LogManager::getSingleton().logMessage("loading view cells");

        //-- the actual loading happens here
        return mSceneMgr->setOption("LoadViewCells", filename.c_str());
}


/**********************************************************************/
/*           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;

        mSavedShadowTechnique = mSceneMgr->getShadowTechnique();
        mSavedAmbientLight = mSceneMgr->getAmbientLight();

        // -- ambient light must be full for visualization, shadows disabled
    if (showViz)
        {
                mSceneMgr->setAmbientLight(ColourValue(1, 1, 1));
                mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
        }
        
    mSceneMgr->setOption("PrepareVisualization", &showViz);
        mSceneMgr->setOption("SkyBoxEnabled", &nShowViz);
        //mSceneMgr->setOption("SkyPlaneEnabled", &showViz);
        
        RenderTargetListener::preViewportUpdate(evt);
}
//-----------------------------------------------------------------------
void VisualizationRenderTargetListener::postRenderTargetUpdate(const RenderTargetEvent &evt)
{
        // reset values
        mSceneMgr->setShadowTechnique(mSavedShadowTechnique);
        mSceneMgr->setAmbientLight(mSavedAmbientLight);
        
        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;
}