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

Revision 2183, 24.5 KB checked in by mattausch, 18 years ago (diff)
Line 
1#include <OgreNoMemoryMacros.h>
2#include <CEGUI/CEGUI.h>
3#include <../CEGUIRenderer/include/OgreCEGUIRenderer.h>
4#include <../CEGUIRenderer/include/OgreCEGUIResourceProvider.h>
5#include <../CEGUIRenderer/include/OgreCEGUITexture.h>
6#include <OgreMemoryMacros.h>
7#include <OgreIteratorWrappers.h>
8#include <Ogre.h>
9#include "TestCullingTerrainApplication.h"
10#include "TerrainFrameListener.h"
11
12#if COLLADA
13#include "OgreColladaPrerequisites.h"
14#include "OgreColladaDocument.h"
15#include "OgreColladaScene.h"
16#endif
17
18#include "IVReader.h"
19
20#define WIN32_LEAN_AND_MEAN
21#include <windows.h>
22
23const static bool USE_STATIC_GEOMETRY = false;
24bool TestCullingTerrainApplication::msShowHillyTerrain = false;
25
26
27//using namespace GtpVisibility;
28
29/*************************************************************/
30/*                EntityState implementation                 */
31/*************************************************************/
32
33
34Vector3 EntityState::msMinPos = Vector3::ZERO;
35Vector3 EntityState::msMaxPos = Vector3::ZERO;
36
37EntityState::EntityState(Entity *ent, State entityState, Real speed):
38mEntity(ent), mState(entityState), mAnimationSpeed(speed)
39{
40        switch(entityState)
41        {
42        case MOVING:
43                mAnimationState = mEntity->getAnimationState("Walk");
44                break;
45        case WAITING:
46                mAnimationState = mEntity->getAnimationState("Idle");
47                break;
48        case STOP:
49                mAnimationState = NULL;
50                break;
51        default:
52                break;
53        }
54        // enable animation state
55        if (mAnimationState)
56        {
57                mAnimationState->setLoop(true);
58                mAnimationState->setEnabled(true);
59        }
60
61        mTimeElapsed = Math::RangeRandom(1, 5);
62}
63//-----------------------------------------------------------------------
64EntityState::~EntityState()
65{
66        mAnimationState = NULL;
67        mEntity = NULL;
68}
69//-----------------------------------------------------------------------
70Entity *EntityState::GetEntity()
71{
72        return mEntity;
73}
74//-----------------------------------------------------------------------
75EntityState::State EntityState::GetState()
76{
77        return mState;
78}
79//-----------------------------------------------------------------------
80void EntityState::update(Real timeSinceLastFrame)
81{
82        mTimeElapsed -= timeSinceLastFrame * mAnimationSpeed;
83
84        if (!mEntity || !mAnimationState)
85                return;
86       
87        if (mState == MOVING) // toggle between moving (longer) and waiting (short)
88        {
89                SceneNode *parent = mEntity->getParentSceneNode();
90               
91                if (!parent)
92                        return;
93
94                if (mTimeElapsed <= 0) // toggle animation state
95                {
96                        if (mAnimationState->getAnimationName() == "Idle")
97                        {
98                                SetAnimationState("Walk", true);
99                               
100                                mTimeElapsed = walk_duration; // walk for mTimeElapsed units
101
102                                // choose random rotation
103                                Radian rnd = Radian(Math::UnitRandom() * Math::PI * rotate_factor);
104
105                                //mEntity->getParentSceneNode()->rotate();
106                                parent->yaw(rnd);                                               
107                        }
108                        else
109                        {
110                                SetAnimationState("Idle", true);
111                                mTimeElapsed = wait_duration; // wait for mTimeElapsed seconds
112                        }
113                }
114
115                if (mAnimationState->getAnimationName() == "Walk") // move forward
116                {
117                        // store old position, just in case we get out of bounds
118                        Vector3 oldPos = parent->getPosition();
119                        parent->translate(parent->getLocalAxes(), Vector3(move_factor * mAnimationSpeed, 0, 0));
120
121                        // HACK: if out of bounds => reset to old position and set animationstate to idle
122                        if (OutOfBounds(parent))
123                        {
124                                parent->setPosition(oldPos);
125                                SetAnimationState("Idle", true);
126                               
127                                mTimeElapsed = wait_duration;
128                        }
129                }
130        }
131               
132        // add time to drive animation
133        mAnimationState->addTime(timeSinceLastFrame * mAnimationSpeed);
134}
135//-----------------------------------------------------------------------
136void EntityState::SetAnimationState(String stateStr, bool loop)
137{
138        if (!mEntity)
139                return;
140
141        mAnimationState = mEntity->getAnimationState(stateStr);
142        mAnimationState->setLoop(loop);
143        mAnimationState->setEnabled(true);
144}
145//-----------------------------------------------------------------------
146bool EntityState::OutOfBounds(SceneNode *node)
147{
148        Vector3 pos = node->getPosition();
149
150        if ((pos > msMinPos) && (pos < msMaxPos))
151                return false;
152
153        return true;
154}
155
156
157
158/********************************************************************/
159/*            TestCullingTerrainApplication implementation          */
160/********************************************************************/
161
162
163TestCullingTerrainApplication::TestCullingTerrainApplication():
164mTerrainContentGenerator(NULL),
165mRayQueryExecutor(NULL),
166mIVReader(NULL),
167mFilename("terrain"),
168mViewCellsFilename(""),
169mAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING)
170{
171}
172//-------------------------------------------------------------------------
173void TestCullingTerrainApplication::loadConfig(const String& filename)
174{
175        // TODO matt
176        // Set up the options
177        ConfigFile config;
178        String val;
179
180        config.load(filename);
181
182        std::stringstream d; d << "reading the config file from: " << filename;
183        LogManager::getSingleton().logMessage(d.str());
184
185        val = config.getSetting("Scene");
186
187    if (!val.empty())
188        {
189                 mFilename = val.c_str();
190                 d << "\nloading scene from file: " << mFilename;
191                 LogManager::getSingleton().logMessage(d.str());
192        }
193
194/*      val = config.getSetting("ViewCells");
195
196        if (!val.empty())
197        {
198                 mViewCellsFilename = val.c_str();
199                 std::stringstream d; d << "view cells file name: " << mViewCellsFilename;
200                 LogManager::getSingleton().logMessage(d.str());
201        }
202
203        mInitialPosition = Vector3::UNIT_SCALE;
204
205        val = config.getSetting("ViewX");
206
207        if (!val.empty())
208                mInitialPosition.x = atof( val.c_str() );
209
210        val = config.getSetting("ViewY");
211       
212        if (!val.empty())
213                mInitialPosition.y = atof(val.c_str());
214
215        val = config.getSetting("ViewZ");
216       
217        if (!val.empty())
218                mInitialPosition.z = atof( val.c_str());
219*/
220
221/*      val = config.getSetting("OnlineCullingAlgorithm");
222
223        if (!val.empty())
224        {
225                 if (val == "CHC")
226                 {
227                         mAlgorithm =
228                                 GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING;
229                 }
230                 else if (val == "SWC")
231                 {
232                         mAlgorithm =
233                                 GtpVisibility::VisibilityEnvironment::STOP_AND_WAIT_CULLING;
234                 }
235                 else if (val == "VFC")
236                 {
237                         mAlgorithm =
238                                 GtpVisibility::VisibilityEnvironment::FRUSTUM_CULLING;
239                 }
240                 else // default rendering
241                 {
242                         mAlgorithm =
243                                 GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS;
244                 }
245        }
246
247        /////////////
248        // setup scene
249
250        // set camera position accordingly
251        mCamNode->setPosition(mInitialPosition);
252        */
253}
254//-----------------------------------------------------------------------
255TestCullingTerrainApplication::~TestCullingTerrainApplication()
256{
257        OGRE_DELETE(mTerrainContentGenerator);
258        OGRE_DELETE(mRayQueryExecutor);
259        OGRE_DELETE(mIVReader);
260
261        deleteEntityStates();   
262}
263//-----------------------------------------------------------------------
264void TestCullingTerrainApplication::deleteEntityStates()
265{
266        for (int i = 0; i < (int)mEntityStates.size(); ++i)
267        {
268                OGRE_DELETE(mEntityStates[i]);
269        }
270
271        mEntityStates.clear();
272}
273//-----------------------------------------------------------------------
274void TestCullingTerrainApplication::createCamera()
275{
276        // create the camera
277        mCamera = mSceneMgr->createCamera("PlayerCam");
278       
279        /** set a nice viewpoint
280        *       we use a camera node here and apply all transformations on it instead
281        *       of applying all transformations directly to the camera
282        *       because then the camera is displayed correctly in the visualization
283        */
284        // hack: vienna view point
285        Vector3 viewPoint(830, 300, -540);
286       
287        mCamNode = mSceneMgr->getRootSceneNode()->
288                createChildSceneNode("CamNode1", viewPoint);
289       
290        mCamNode->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329));
291        mCamNode->attachObject(mCamera);
292       
293        ///////////////////
294        //-- create visualization camera
295
296        mVizCamera = mSceneMgr->createCamera("VizCam");
297        mVizCamera->setPosition(mCamNode->getPosition());
298
299        mVizCamera->setNearClipDistance(1);
300        mCamera->setNearClipDistance(1);
301
302        // infinite far plane?
303        if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_INFINITE_FAR_PLANE))
304        {
305                mVizCamera->setFarClipDistance(0);
306                mCamera->setFarClipDistance(0);
307        }
308        else
309        {
310                 mVizCamera->setFarClipDistance(20000);
311                 mCamera->setFarClipDistance(20000);
312        }       
313}
314
315//-----------------------------------------------------------------------
316bool TestCullingTerrainApplication::setup()
317{
318        bool carryOn = ExampleApplication::setup();
319
320        if (carryOn)
321                createRenderTargetListener();
322
323        return carryOn;
324}
325//-----------------------------------------------------------------------
326void TestCullingTerrainApplication::createRenderTargetListener()
327{
328        mWindow->addListener(new VisualizationRenderTargetListener(mSceneMgr));
329}
330//-----------------------------------------------------------------------
331bool TestCullingTerrainApplication::LoadSceneCollada(const String &filename,
332                                                                                                         SceneNode *root,
333                                                                                                         const int index)
334{
335#if COLLADA
336        // Collada
337        ColladaDocument *daeDoc = new ColladaDocument(mSceneMgr);
338
339        String daeName = filename;
340        //if (daeName.empty())
341        //      daeName = "City_1500.dae";
342
343        // default directory
344        //daeName.insert(0, "../../media/models/collada/City");
345        LogManager::getSingleton().logMessage("ColladaDocument - import started");
346
347        // full import
348        if (daeDoc->doImport(daeName))
349        {
350                LogManager::getSingleton().logMessage("yuppi");
351                /**
352                 * build up scene
353                 * if you only want a specific part of the scene graph, you must fetch a scene node
354                 * by its unique node name and give it as parameter
355                 * e.g.
356                 * ColladaSceneNode *box = mScene->getNode("Box2");
357                 * if (box != NULL) box->createOgreInstance(NULL);
358                 */
359                daeDoc->getScene()->createOgreInstance(NULL);
360
361                // everything is loaded, we do not need the collada document anymore
362                delete daeDoc;
363
364                return true;
365        }
366        else
367        {
368                LogManager::getSingleton().logMessage("ColladaDocument - import failed");
369                return false;
370        }
371#endif
372        return true;
373}
374//-----------------------------------------------------------------------
375bool TestCullingTerrainApplication::LoadSceneIV(const String &filename,
376                                                                                                SceneNode *root,
377                                                                                                const int index)
378{
379        mIVReader = new IVReader();
380
381        Timer *timer = PlatformManager::getSingleton().createTimer();
382        timer->reset();
383
384        if (1)
385        {
386                std::string logFilename = "IVLog" + Ogre::StringConverter().toString(index) + ".log";
387               
388                Log *log = LogManager::getSingleton().createLog(logFilename);
389                mIVReader->setLog(log);
390        }
391       
392        //viennaNode->translate(Vector3(-300, -300, 0));
393
394        if (mIVReader->loadFile(filename.c_str()))
395        {
396                SceneNode *node = root->createChildSceneNode("IVSceneNode" + index);
397
398                mIVReader->buildTree(mSceneMgr, node);
399               
400                mIVReader->collapse();
401                OGRE_DELETE(mIVReader);
402
403                std::stringstream d;
404                d << "loaded " << filename << " in " << timer->getMilliseconds() * 1e-3 << " secs";
405                LogManager::getSingleton().logMessage(d.str());
406               
407                PlatformManager::getSingleton().destroyTimer(timer);
408
409                //-- bake into static geometry
410                if (USE_STATIC_GEOMETRY)
411                {
412                        BakeSceneIntoStaticGeometry("staticVienna", "Vienna");
413                }
414       
415                return true;
416        }
417
418        return false;
419}
420//--------------------------------------------------------
421void TestCullingTerrainApplication::BakeSceneIntoStaticGeometry(const String &staticGeomName,
422                                                                                                                                const String &nodeName)
423{
424#if OGRE_103
425        // note: different static geom for roofs, roads, ..., becazse they have same material
426        StaticGeometry *staticGeom = mSceneMgr->createStaticGeometry(staticGeomName);
427
428        // note: looping over entities here. why does scene node not work?
429        SceneManager::EntityIterator it = mSceneMgr->getEntityIterator();
430        while (it.hasMoreElements())
431        {
432                Entity *ent = it.getNext();
433                ent->setVisible(false);
434                staticGeom->addEntity(ent, ent->getParentSceneNode()->getPosition());
435        }
436
437        staticGeom->setRegionDimensions(Vector3(100,100,100));
438        staticGeom->build();
439
440        // cleanup node
441        //wallsNode->detachAllObjects();
442       
443        //roofsNode->detachAllObjects();
444        //roadsNode->detachAllObjects();
445        //planeNode->detachAllObjects();
446       
447        //viennaNode->removeChild("Walls");
448        mSceneMgr->destroySceneNode(nodeName);
449#endif
450}
451//--------------------------------------------------------
452void TestCullingTerrainApplication::createScene()
453{
454        /////////
455        //-- load parameters & scene
456        //loadConfig("terrainCulling.cfg");
457       
458        /////////////////////////////////////
459
460        // Set ambient light
461        mAmbientLight = ColourValue(0.5, 0.5, 0.5);
462        mSceneMgr->setAmbientLight(mAmbientLight);
463       
464        //-- create light
465        mSunLight = mSceneMgr->createLight("SunLight");
466        mSunLight->setType(Light::LT_DIRECTIONAL);
467        //mSunLight->setType(Light::LT_SPOTLIGHT);
468        //mSunLight->setSpotlightRange(Degree(30), Degree(50));
469
470    mSunLight->setPosition(707, 2000, 500);
471        mSunLight->setCastShadows(true);
472
473        // set light angle not too small over the surface,
474        // otherwise shadows textures will be broken
475        Vector3 dir(0.5, 1, 0.5);
476        dir.normalise();
477        mSunLight->setDirection(dir);
478        //mSunLight->setDirection(Vector3::NEGATIVE_UNIT_Y);
479        mSunLight->setDiffuseColour(1, 1, 1);
480        mSunLight->setSpecularColour(1, 1, 1);
481
482        //-- Fog
483
484        // NB it's VERY important to set this before calling setWorldGeometry
485        // because the vertex program picked will be different
486        ColourValue fadeColour(0.93, 0.86, 0.76);
487        mWindow->getViewport(0)->setBackgroundColour(fadeColour);
488        //mSceneMgr->setFog(FOG_LINEAR, fadeColour, .001, 500, 1000);
489       
490        // Create a skybox
491        mSceneMgr->setSkyBox(true, "Examples/CloudyNoonSkyBox", 50000, true);
492       
493        // terrain creation
494        if (1)//||msShowHillyTerrain)
495        {
496        std::string terrain_cfg("terrainCulling.cfg");
497                mSceneMgr->setWorldGeometry(terrain_cfg);
498
499                // was terrain loaded?
500                mSceneMgr->getOption("ShowTerrain", &msShowHillyTerrain);
501        }
502       
503        // hack view point for terrain
504        if (msShowHillyTerrain)
505        {
506                Vector3 viewPoint(707, 5000, 528);
507                mCamNode->setPosition(viewPoint);
508        }
509
510        //////
511        //-- CEGUI setup
512        setupGui();
513
514        // Warning: In GL since we can't go higher than the window res
515        mSceneMgr->setShadowTextureSettings(1024, 2);
516        mSceneMgr->setShadowColour(ColourValue(0.5, 0.5, 0.5));
517
518        //////////////
519        //-- terrain content setup
520
521        // HACK: necessary to call once here for terrain initialisation
522        mSceneMgr->_renderScene(mCamera, mWindow->getViewport(0), true);
523
524        // ray query executor: needed to clamp to terrain
525        mRayQueryExecutor = new RayQueryExecutor(mSceneMgr);
526
527        mTerrainMinPos = EntityState::msMinPos = Vector3(0, 0, 0);
528        mTerrainMaxPos = EntityState::msMaxPos = Vector3(5000, 5000, 5000);
529
530        mTerrainContentGenerator = new TerrainContentGenerator(mSceneMgr);
531               
532        // if no objects in file, we generate new objects
533        if (msShowHillyTerrain && !mTerrainContentGenerator->LoadObjects("objects.out"))
534        {
535                // the objects are generated randomly distributed over the terrain
536                if (1) generateScene(500, 0); // create robots
537                if (0) generateScene(100, 1); // create trees
538                if (1) generateScene(1000, 2); // create ninjas
539        }
540}
541//-----------------------------------------------------------------------
542void  TestCullingTerrainApplication::generateScene(int num, int objectType)
543{
544        const float val = TerrainFrameListener::msObjectScales[objectType];
545        Vector3 scale(val, val, val);
546        const float maxHeight = 75;
547       
548        // In order to provide much occlusion,
549        // height is restricted to maxHeight => no objects are created on peaks
550        mTerrainContentGenerator->SetMinPos(Vector3(mTerrainMinPos));
551        mTerrainContentGenerator->SetMaxPos(Vector3(mTerrainMaxPos.x, maxHeight, mTerrainMaxPos.z));
552       
553        mTerrainContentGenerator->SetScale(scale);
554        mTerrainContentGenerator->SetOffset(TerrainFrameListener::msObjectTerrainOffsets[objectType]);
555        mTerrainContentGenerator->GenerateScene(num, TerrainFrameListener::msObjectCaptions[objectType]);
556
557        if (objectType != 0) // from our objects, only robot has animation phases
558                return;
559
560        EntityList *entList = mTerrainContentGenerator->GetGeneratedEntities();
561
562        /////////////
563        //-- add animation state for new robots (located at the end of the list)
564       
565        for (int i = (int)entList->size() - num; i < (int)entList->size(); ++i)
566        {
567                mEntityStates.push_back(new EntityState((*entList)[i],
568                        EntityState::WAITING, Math::RangeRandom(0.5, 1.5)));
569        }
570
571        // release limitations on height => it is possible for the user to put single
572        // objects on peaks of the terrain (will be only few, not relevant for occlusion)
573        mTerrainContentGenerator->SetMaxPos(mTerrainMaxPos);
574}
575//-----------------------------------------------------------------------
576void TestCullingTerrainApplication::updateAnimations(Real timeSinceLastFrame)
577{
578        for (int i = 0; i < (int)mEntityStates.size(); ++i)
579        {
580                SceneNode *sn = mEntityStates[i]->GetEntity()->getParentSceneNode();
581
582                mEntityStates[i]->update(timeSinceLastFrame);
583
584                if (mEntityStates[i]->GetState() == EntityState::MOVING)
585                {
586                        Clamp2Terrain(sn, 0); //sn->setNodeVisible(false);
587                }
588        }
589}
590//-----------------------------------------------------------------------
591EntityStates  &TestCullingTerrainApplication::getEntityStates()
592{
593        return mEntityStates;
594}
595//-----------------------------------------------------------------------
596void TestCullingTerrainApplication::setupGui()
597{
598#if OGRE103
599         mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow, Ogre::RENDER_QUEUE_OVERLAY,
600                 false, 3000, ST_EXTERIOR_CLOSE);
601#else
602          mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow, Ogre::RENDER_QUEUE_OVERLAY,
603                 false, 3000, mSceneMgr);
604#endif
605     mGUISystem = new CEGUI::System(mGUIRenderer);
606
607         // Mouse
608     CEGUI::SchemeManager::getSingleton().loadScheme((CEGUI::utf8*)"TaharezLook.scheme");
609     CEGUI::MouseCursor::getSingleton().setImage("TaharezLook", "MouseArrow");
610         mGUISystem->setDefaultMouseCursor((CEGUI::utf8*)"TaharezLook",
611                                                                           (CEGUI::utf8*)"MouseArrow");
612
613         CEGUI::MouseCursor::getSingleton().hide();
614}
615//-----------------------------------------------------------------------
616void TestCullingTerrainApplication::createFrameListener()
617{
618        mTerrainFrameListener =
619                new TerrainFrameListener(mWindow,
620                                                                 mCamera,
621                                                                 mSceneMgr,
622                                                                 mGUIRenderer,
623                                                                 mTerrainContentGenerator,
624                                                                 mVizCamera,
625                                                                 mCamNode,
626                                                                 mSunLight,
627                                                                 this);
628       
629        mRoot->addFrameListener(mTerrainFrameListener);
630}
631//-----------------------------------------------------------------------
632void TestCullingTerrainApplication::chooseSceneManager()
633{
634#ifdef OGRE_103
635        if (msShowHillyTerrain)
636        {
637                // Terrain scene manager
638                mSceneMgr = mRoot->getSceneManager(ST_EXTERIOR_CLOSE);
639        }
640        else
641        {       // octree scene manager
642                mSceneMgr = mRoot->getSceneManager(ST_GENERIC);
643        }
644#else
645
646        mSceneMgr = mRoot->createSceneManager("OcclusionCullingSceneManager");
647       
648        //mSceneMgr = mRoot->createSceneManager("TerrainSceneManager");
649        //mSceneMgr = mRoot->createSceneManager("OctreeSceneManager");
650
651        //mSceneMgr = mRoot->createSceneManager("KdTreeSceneManager");
652       
653#endif
654}
655//-----------------------------------------------------------------------
656bool TestCullingTerrainApplication::Clamp2Terrain(SceneNode *node, int terrainOffs)
657{
658        // clamp scene node to terrain
659        Vector3 pos = node->getPosition();
660        Vector3 queryResult;
661
662        if (mRayQueryExecutor->executeRayQuery(&queryResult,
663                        Vector3(pos.x, MAX_HEIGHT, pos.z), Vector3::NEGATIVE_UNIT_Y))
664        {
665        node->setPosition(pos.x, queryResult.y + terrainOffs, pos.z);
666                return true;
667        }
668
669        return false;
670}
671
672//-----------------------------------------------------------------------
673bool TestCullingTerrainApplication::Clamp2FloorPlane(const float dist)
674{
675    // clamp to floor plane
676        RaySceneQuery *raySceneQuery = mSceneMgr->createRayQuery(
677                Ray(mCamNode->getPosition(), Vector3::NEGATIVE_UNIT_Y));
678
679        RaySceneQueryResult& qryResult = raySceneQuery->execute();
680   
681        RaySceneQueryResult::iterator rit = qryResult.begin();
682        bool success = false;
683       
684        float yVal = 0;
685        float minVal = 999999999999;
686
687        while (rit != qryResult.end() && rit->movable)
688        {
689                if (rit->movable->getName() != "PlayerCam")
690                {
691                        // place on the ground object
692                        yVal = rit->movable->getWorldBoundingBox().getCenter().y;
693                                if (yVal < minVal)
694                                        minVal = yVal;
695
696                        //std::stringstream d; d << "dist: " << dist << endl;
697                        //Ogre::LogManager()
698                        success = true;
699                }
700
701                ++ rit;
702        }
703   
704        // place on the ground object
705        if (success)
706                        mCamNode->setPosition(
707                                mCamNode->getPosition().x,
708                                minVal + dist,
709                                mCamNode->getPosition().z);
710
711        OGRE_DELETE(raySceneQuery);
712        return success;
713}
714
715//-----------------------------------------------------------------------
716// splits strings containing multiple file names
717static int SplitFilenames(const std::string str, std::vector<std::string> &filenames)
718{
719        int pos = 0;
720
721        while(1)
722        {
723                int npos = (int)str.find(';', pos);
724               
725                if (npos < 0 || npos - pos < 1)
726                        break;
727                filenames.push_back(std::string(str, pos, npos - pos));
728                pos = npos + 1;
729        }
730       
731        filenames.push_back(std::string(str, pos, str.size() - pos));
732        return (int)filenames.size();
733}
734//-----------------------------------------------------------------------
735bool TestCullingTerrainApplication::LoadScene(const String &filename)
736{
737        using namespace std;
738        // use leaf nodes of the original spatial hierarchy as occludees
739        vector<string> filenames;
740        int files = SplitFilenames(filename, filenames);
741       
742        std::stringstream d;
743        d << "number of input files: " << files << "\n";
744        LogManager::getSingleton().logMessage(d.str());
745
746        bool result = false;
747        vector<string>::const_iterator fit, fit_end = filenames.end();
748        int i = 0;
749
750        for (fit = filenames.begin(); fit != fit_end; ++ fit, ++ i)
751        {
752                const string fn = *fit;
753
754                if (strstr(fn.c_str(), ".iv") || strstr(fn.c_str(), ".wrl"))
755                {
756                        // load iv files
757                        if (!LoadSceneIV(fn, mSceneMgr->getRootSceneNode(), i))
758                        {
759                                // terrain hack
760                                //msShowHillyTerrain = true;
761                                LogManager::getSingleton().logMessage("error loading scene => load terrain");
762                        }
763                }
764                else if (strstr(filename.c_str(), ".dae"))
765                {
766                        // load collada files
767                        LoadSceneCollada(fn, mSceneMgr->getRootSceneNode(), i);         
768                }
769                else //if (filename == "terrain")
770                {
771                        // terrain hack
772                        msShowHillyTerrain = true;
773                        LogManager::getSingleton().logMessage("loading terrain");
774                }
775       
776                result = true;
777        }
778       
779        return result;
780}
781//-----------------------------------------------------------------------
782bool TestCullingTerrainApplication::LoadViewCells(const String &filename)
783{
784        // if not already loaded,
785        // the scene manager will load the view cells
786        return mSceneMgr->setOption("UseViewCells", filename.c_str());
787}
788
789
790/**********************************************************************/
791/*           VisualizationRenderTargetListener implementation         */
792/**********************************************************************/
793
794
795//-----------------------------------------------------------------------
796VisualizationRenderTargetListener::VisualizationRenderTargetListener(SceneManager *sceneMgr)
797:RenderTargetListener(), mSceneMgr(sceneMgr)
798{
799}
800//-----------------------------------------------------------------------
801void VisualizationRenderTargetListener::preViewportUpdate(const RenderTargetViewportEvent &evt)
802{
803        // visualization viewport
804        const bool showViz = evt.source->getZOrder() == VIZ_VIEWPORT_Z_ORDER;
805        const bool nShowViz = !showViz;
806
807        mSavedShadowTechnique = mSceneMgr->getShadowTechnique();
808        mSavedAmbientLight = mSceneMgr->getAmbientLight();
809
810        // -- ambient light must be full for visualization, shadows disabled
811    if (showViz)
812        {
813                mSceneMgr->setAmbientLight(ColourValue(1, 1, 1));
814                mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
815        }
816       
817    mSceneMgr->setOption("PrepareVisualization", &showViz);
818        mSceneMgr->setOption("SkyBoxEnabled", &nShowViz);
819       
820        RenderTargetListener::preViewportUpdate(evt);
821}
822//-----------------------------------------------------------------------
823void VisualizationRenderTargetListener::postRenderTargetUpdate(const RenderTargetEvent &evt)
824{
825        // reset values
826        mSceneMgr->setShadowTechnique(mSavedShadowTechnique);
827        mSceneMgr->setAmbientLight(mSavedAmbientLight);
828       
829        RenderTargetListener::postRenderTargetUpdate(evt);
830}
831//-----------------------------------------------------------------------
832INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT )
833{
834    // Create application object
835    TestCullingTerrainApplication app;
836
837        try
838        {
839        app.go();
840    }
841        catch( Ogre::Exception& e )
842        {
843        MessageBox( NULL, e.getFullDescription().c_str(),
844                        "An exception has occured!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
845    }   
846
847    return 0;
848}
Note: See TracBrowser for help on using the repository browser.