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

Revision 109, 27.0 KB checked in by mattausch, 19 years ago (diff)

start to add shadows to demo
Line 
1/**
2    \file
3        TestCullingTerrainApplication.cpp
4    \brief
5        Tests the visibility culling algorithm
6*/
7
8#include <OgreNoMemoryMacros.h>
9#include <CEGUI/CEGUI.h>
10#include <../CEGUIRenderer/include/OgreCEGUIRenderer.h>
11#include <../CEGUIRenderer/include/OgreCEGUIResourceProvider.h>
12#include <../CEGUIRenderer/include/OgreCEGUITexture.h>
13#include <OgreMemoryMacros.h>
14
15#include <Ogre.h>
16#include "OgreReferenceAppLayer.h"
17//#include "OgreRefAppWorld.h"
18#include "TestCullingTerrainApplication.h"
19
20#define WIN32_LEAN_AND_MEAN
21#include <windows.h>
22
23#define VIZ_VIEWPORT_Z_ORDER 10
24
25const char* frame_outfile = "frame.out";
26const char* objects_outfile = "objects.out";
27
28/*******************************************************/
29/*     TestCullingTerrainApplication implementation    */
30/*******************************************************/
31
32//-----------------------------------------------------------------------
33TestCullingTerrainApplication::~TestCullingTerrainApplication()
34{
35        if(mTerrainContentGenerator)
36                delete mTerrainContentGenerator;
37        //if(mRenderTargetListener)     delete mRenderTargetListener;
38}
39//-----------------------------------------------------------------------
40void TestCullingTerrainApplication::createCamera()
41{
42        // create the camera
43        mCamera = mSceneMgr->createCamera("PlayerCam");
44       
45        /** set a nice viewpoint
46        *       we use a camera node here and apply all transformations on it instead
47        *       of applying all transformations directly to the camera
48        *       because then the camera is displayed correctly in the visualization
49        */
50        mCamNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(
51                "CamNode1", Vector3(707, 5000, 528));
52        //mCamera->setPosition(707, 5000, 528);
53        mCamNode->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329));
54       
55        mCamNode->attachObject(mCamera);
56
57        //-- create visualization camera
58        mVizCamera = mSceneMgr->createCamera("VizCam");
59        mVizCamera->setPosition(mCamNode->getPosition());
60
61        mVizCamera->setNearClipDistance(1);
62        mCamera->setNearClipDistance(1);
63
64        // infinite far plane?
65        if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_INFINITE_FAR_PLANE))
66        {
67                mVizCamera->setFarClipDistance(0);
68                mCamera->setFarClipDistance(0);
69        }
70        else
71        {
72                 mVizCamera->setFarClipDistance(20000);
73                 mCamera->setFarClipDistance(20000);
74        }       
75}
76
77//-----------------------------------------------------------------------
78bool TestCullingTerrainApplication::setup()
79{
80        bool result = ExampleApplication::setup();
81
82        createRenderTargetListener();
83
84        return result;
85}
86//-----------------------------------------------------------------------
87void TestCullingTerrainApplication::createRenderTargetListener()
88{
89        mWindow->addListener(new VisualizationRenderTargetListener(mSceneMgr));
90}
91//-----------------------------------------------------------------------
92void TestCullingTerrainApplication::createScene()
93{
94        // Set ambient light
95        mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5));
96       
97        // Create a light
98        Light* l = mSceneMgr->createLight("MainLight");
99        // Accept default settings: point light, white diffuse, just set position
100        // NB I could attach the light to a SceneNode if I wanted it to move automatically with
101        // other objects, but I don't
102        l->setPosition(20,80,50);
103
104        // --Fog
105        // NB it's VERY important to set this before calling setWorldGeometry
106        // because the vertex program picked will be different
107        ColourValue fadeColour(0.93, 0.86, 0.76);
108        mWindow->getViewport(0)->setBackgroundColour(fadeColour);
109        //mSceneMgr->setFog( FOG_LINEAR, fadeColour, .001, 500, 1000);
110       
111        // Create a skybox
112        mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox", 5000, false);
113       
114        std::string terrain_cfg("terrain.cfg");
115#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
116        terrain_cfg = mResourcePath + terrain_cfg;
117#endif
118        mSceneMgr->setWorldGeometry(terrain_cfg);
119       
120        //-- CEGUI setup
121        setupGui();
122
123        //-- terrain content setup
124
125        // HACK: necessary to call once before the content creation for
126        // terrain initialisation
127        mSceneMgr->_renderScene(mCamera, mWindow->getViewport(0), true);
128
129        mTerrainContentGenerator = new TerrainContentGenerator(mSceneMgr);
130
131        // if no objects file generate yourself
132        //if (!mTerrainContentGenerator->LoadObjects("objects.out"))
133        //{
134                // the objects are generated on the whole terrain
135                // height is restricted to 50, so no objects appear on peaks
136                // => there is much occlusion
137                mTerrainContentGenerator->SetMaxPos(Vector3(3000.0f, 50.0f, 3000.0f));
138                mTerrainContentGenerator->GenerateScene(1500, "robot");
139                //      mTerrainContentGenerator->GenerateScene(500, "ninja");
140        //}
141
142        // no limitations needed anymore: the user can set
143        // objects also on peaks of terrain
144        mTerrainContentGenerator->SetMaxPos(Vector3(3000.0f, 5000.0f, 3000.0f));
145
146        //-- create light
147        mSunLight = mSceneMgr->createLight("SunLight");
148        mSunLight->setType(Light::LT_SPOTLIGHT);
149    mSunLight->setPosition(1000,1250,500);
150        mSunLight->setSpotlightRange(Degree(30), Degree(50));
151
152    Vector3 dir;
153    dir = -mSunLight->getPosition();
154        dir.normalise();
155        mSunLight->setDirection(dir);
156        mSunLight->setDiffuseColour(0.35, 0.35, 0.38);
157        mSunLight->setSpecularColour(0.9, 0.9, 1);
158
159         mSunLight->setCastShadows(true);
160}
161//-----------------------------------------------------------------------
162void TestCullingTerrainApplication::setupGui()
163{
164         mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow, Ogre::RENDER_QUEUE_OVERLAY,
165                 false, 3000, ST_EXTERIOR_CLOSE);
166     mGUISystem = new CEGUI::System(mGUIRenderer);
167
168         // Mouse
169     CEGUI::SchemeManager::getSingleton().loadScheme((CEGUI::utf8*)"TaharezLook.scheme");
170     CEGUI::MouseCursor::getSingleton().setImage("TaharezLook", "MouseArrow");
171         mGUISystem->setDefaultMouseCursor(
172                (CEGUI::utf8*)"TaharezLook", (CEGUI::utf8*)"MouseArrow");
173
174         CEGUI::MouseCursor::getSingleton().show();
175}
176//-----------------------------------------------------------------------
177void TestCullingTerrainApplication::createFrameListener()
178{
179        mFrameListener= new MouseQueryListener(mWindow, mCamera, mSceneMgr,
180                mGUIRenderer, mTerrainContentGenerator, mVizCamera, mCamNode);
181        mFrameListener->showDebugOverlay(true);
182        mRoot->addFrameListener(mFrameListener);
183}
184//-----------------------------------------------------------------------
185void TestCullingTerrainApplication::chooseSceneManager()
186{
187        mSceneMgr = mRoot->getSceneManager(ST_EXTERIOR_CLOSE);
188}
189/***********************************************/
190/*      MouseQueryListener implementation      */
191/***********************************************/
192//-----------------------------------------------------------------------
193MouseQueryListener::MouseQueryListener(RenderWindow* win, Camera* cam,
194                                                                           SceneManager *sceneManager,
195                                                                           CEGUI::Renderer *renderer,
196                                                                           TerrainContentGenerator *sceneGenerator,
197                                                                           Camera *vizCamera,
198                                                                           SceneNode *camNode):
199ExampleFrameListener(win, cam, false, true),
200mGUIRenderer(renderer),
201mShutdownRequested(false),
202mLMouseDown(false),
203mRMouseDown(false),
204mSceneMgr(sceneManager),
205mCurrentObject(NULL),
206mTerrainContentGenerator(sceneGenerator),
207mVisibilityThreshold(0),
208mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING),
209mShowOctree(false),
210mUseVisibilityCulling(true),
211mUseOptimization(true),
212mVizCamera(vizCamera),
213mShowVisualization(false),
214mRenderNodesForViz(false),
215mVizCameraHeight(Real(2500.0)),
216mCamNode(camNode),
217mCullCamera(false),
218mAppState(WALKTHROUGH),
219mCurrentFrame(0),
220mRecord(false),
221mTimeElapsed(0)
222{
223        // Reduce move speed
224        mMoveSpeed = 50;
225        mRotateSpeed *= 2;
226   
227        // Register this so that we get mouse events.
228        mEventProcessor->addMouseListener(this);
229        mEventProcessor->addMouseMotionListener(this);
230        mEventProcessor->addKeyListener(this);
231
232        mRayQueryExecutor = new RayQueryExecutor(mSceneMgr);
233       
234        // show overlay
235        Overlay* pOver = OverlayManager::getSingleton().getByName("Example/VisibilityDemoOverlay");
236
237        mAlgorithmInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/AlgorithmInfo");
238        mThresholdInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/ThresholdInfo");
239       
240        mFrustumCulledNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/FrustumCulledNodesInfo");
241        mQueryCulledNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/QueryCulledNodesInfo");
242    mTraversedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/TraversedNodesInfo");
243        mHierarchyNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/HierarchyNodesInfo");
244        mRenderedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/RenderedNodesInfo");
245        mObjectsInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/ObjectsInfo");
246        mUseOptimizationInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/UseOptimizationInfo");
247        mQueriesIssuedInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/QueriesIssuedInfo");
248       
249        mAlgorithmInfo->setCaption(": " + mCurrentAlgorithmCaptions[mCurrentAlgorithm]);
250        mThresholdInfo->setCaption(": 0");
251        mFrustumCulledNodesInfo->setCaption(": 0");
252        mQueryCulledNodesInfo->setCaption(": 0");
253        mTraversedNodesInfo->setCaption(": 0");
254        mHierarchyNodesInfo->setCaption(": 0");
255        mRenderedNodesInfo->setCaption(": 0");
256        mObjectsInfo->setCaption(": 0");
257        mUseOptimizationInfo->setCaption(": true");
258        mQueriesIssuedInfo->setCaption(": 0");
259
260        setAlgorithm(mCurrentAlgorithm);
261
262        mSceneMgr->setOption("UseOptimization", &mUseOptimization);
263        mSceneMgr->setOption("UseVisibilityCulling", &mUseVisibilityCulling);
264        mSceneMgr->setOption("ShowOctree", &mShowOctree);
265        mSceneMgr->setOption("CullCamera", &mCullCamera);
266        mSceneMgr->setOption("ShowVisualization", &mShowVisualization);
267        mSceneMgr->setOption("RenderNodesForViz", &mRenderNodesForViz);
268
269        pOver->show();
270}
271//-----------------------------------------------------------------------
272MouseQueryListener::~MouseQueryListener()
273{
274        delete mRayQueryExecutor;
275}
276//-----------------------------------------------------------------------
277void MouseQueryListener::mouseMoved(MouseEvent *e)
278{
279        // Update CEGUI with the mouse motion
280    CEGUI::System::getSingleton().injectMouseMove(e->getRelX() *
281                mGUIRenderer->getWidth(), e->getRelY() * mGUIRenderer->getHeight());
282}
283//-----------------------------------------------------------------------
284void MouseQueryListener::mousePressed(MouseEvent* e)
285{
286     // Left mouse button down
287     if (e->getButtonID() & InputEvent::BUTTON0_MASK)
288     {
289                 CEGUI::MouseCursor::getSingleton().hide();
290
291                 // Setup the ray scene query
292         Ray mouseRay = mCamera->getCameraToViewportRay(e->getX(), e->getY());
293   
294                 Vector3 queryResult;
295                 
296                 // Get results, create a node/entity on the position
297                 mCurrentObject = mTerrainContentGenerator->GenerateSceneObject(
298                         mouseRay.getOrigin(), Vector3(0,0,0), "robot.mesh");
299               
300         mLMouseDown = true;
301     }
302     // Right mouse button down
303     else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
304     {
305         CEGUI::MouseCursor::getSingleton().hide();
306         mRMouseDown = true;
307     }
308} // mousePressed
309//-----------------------------------------------------------------------
310void MouseQueryListener::mouseReleased(MouseEvent* e)
311{
312    // Left mouse button up
313    if (e->getButtonID() & InputEvent::BUTTON0_MASK)
314    {
315                CEGUI::MouseCursor::getSingleton().show();
316        mLMouseDown = false;
317    }
318    // Right mouse button up
319    else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
320    {
321        CEGUI::MouseCursor::getSingleton().show();
322        mRMouseDown = false;
323    }
324}
325//-----------------------------------------------------------------------
326void MouseQueryListener::mouseDragged(MouseEvent *e)
327 {
328         // If we are dragging the left mouse button.           
329         if (mLMouseDown)
330     {
331                 Vector3 queryResult;
332                 Ray mouseRay = mCamera->getCameraToViewportRay(e->getX(), e->getY());
333
334                 if (mRayQueryExecutor->executeRayQuery(&queryResult, mouseRay))
335                 {
336                         if (mCurrentObject)
337                         {
338                                 mCurrentObject->setPosition(queryResult);
339                         }
340                 }
341     }
342         // If we are dragging the right mouse button.
343         if (mRMouseDown)
344         {
345                 //mCamera->yaw(-e->getRelX() * mRotateSpeed);
346                 //mCamera->pitch(-e->getRelY() * mRotateSpeed);
347                 mCamNode->yaw(-e->getRelX() * mRotateSpeed);
348                 mCamNode->pitch(-e->getRelY() * mRotateSpeed);
349         }
350}
351//-----------------------------------------------------------------------
352bool MouseQueryListener::frameStarted(const FrameEvent &evt)
353{
354        switch (mAppState)
355        {
356        case REPLAY:
357                setCurrentFrameInfo(evt.timeSinceLastFrame);
358                break;
359        case WALKTHROUGH:
360                if (mRecord)
361                {
362                        addFrameInfo(mCamNode, evt.timeSinceLastFrame);
363                        // print recording message
364                        mWindow->setDebugText("Recording frame " +
365                                StringConverter::toString(mFrameInfo.size() - 1));
366                }       
367       
368                Clamp2Terrain();
369                break;
370        default:
371                break;
372        };     
373       
374        if (mShowVisualization)
375        {
376                // important for visualization => draw octree bounding boxes
377                mSceneMgr->setOption("ShowOctree", &mShowVisualization);
378                // also render geometry?
379                mSceneMgr->setOption("RenderNodesForViz", &mRenderNodesForViz);
380
381                // -- setup visualization camera
382                mVizCamera->setPosition(0, 0, 0);
383                mVizCamera->setOrientation(Quaternion::IDENTITY);
384
385                Vector3 camPos = mCamNode->getPosition();
386                mVizCamera->setPosition(camPos.x, mVizCameraHeight, camPos.z);
387
388                // point down -Z axis
389                mVizCamera->pitch(Radian(Degree(270.0)));
390       
391                // rotation arounnd X axis
392                mVizCamera->yaw(Math::ATan2(-mCamera->getDerivedDirection().x,
393                        -mCamera->getDerivedDirection().z));
394               
395                // move by a constant so view plane is on bottom of viewport
396                mVizCamera->moveRelative(Vector3(0, 800, 0));
397        }
398
399        return ExampleFrameListener::frameStarted(evt);
400}
401//-----------------------------------------------------------------------
402void MouseQueryListener::Clamp2Terrain()
403{
404        // clamp to terrain
405        Vector3 camPos = mCamNode->getPosition();
406        Vector3 queryResult;
407
408        if (mRayQueryExecutor->executeRayQuery(&queryResult,
409                        Vector3(camPos.x, 5000.0f, camPos.z), Vector3::NEGATIVE_UNIT_Y))
410        {
411                mCamNode->setPosition(camPos.x, queryResult.y + 10, camPos.z);
412        }
413}
414//-----------------------------------------------------------------------
415bool MouseQueryListener::frameEnded(const FrameEvent& evt)
416{
417        if (mShutdownRequested)
418                return false;
419
420    if (timeDelay >= 0)
421        timeDelay -= evt.timeSinceLastFrame;
422
423        KEY_PRESSED(KC_SPACE, 0.3, nextAlgorithm());
424
425        KEY_PRESSED(KC_O, 0.3, toggleUseOptimization());
426        KEY_PRESSED(KC_T, 0.3, toggleShowOctree());
427        KEY_PRESSED(KC_C, 0.3, toggleUseVisibilityCulling());
428        KEY_PRESSED(KC_1, 0.3, toggleShowViz());
429        KEY_PRESSED(KC_2, 0.3, toggleRenderNodesForViz());
430       
431        KEY_PRESSED(KC_SUBTRACT, 0, changeThreshold(-10));
432        KEY_PRESSED(KC_ADD, 0, changeThreshold(10));
433       
434        KEY_PRESSED(KC_3, 0, zoomVizCamera(50));
435        KEY_PRESSED(KC_4, 0, zoomVizCamera(-50));
436
437        KEY_PRESSED(KC_F1, 0.3, nextAppState());
438        KEY_PRESSED(KC_F2, 0.3, toggleRecord());
439        KEY_PRESSED(KC_F3, 0.3, mTerrainContentGenerator->WriteObjects(objects_outfile));
440        //KEY_PRESSED(KC_F3, 0.3, writeFrames());
441        //KEY_PRESSED(KC_F4, 0.3, loadFrames());
442
443        updateStats();
444
445        //return ExampleFrameListener::frameStarted(evt) && ExampleFrameListener::frameEnded(evt);
446        return ExampleFrameListener::frameEnded(evt);
447}
448//-----------------------------------------------------------------------
449void MouseQueryListener::moveCamera()
450{
451        mCamNode->yaw(mRotX);
452        mCamNode->pitch(mRotY);
453        mCamNode->translate(mCamNode->getLocalAxes(), mTranslateVector);
454}
455//-----------------------------------------------------------------------
456void MouseQueryListener::writeFrames()
457{
458        std::ofstream ofstr(frame_outfile);
459       
460        std::vector<frame_info>::const_iterator it, it_end;
461
462        it_end = mFrameInfo.end();
463        for(it = mFrameInfo.begin(); it < it_end; ++it)
464        {
465                ofstr << StringConverter::toString((*it).position) << " "
466                        << StringConverter::toString((*it).orientation) << " "
467                        << StringConverter::toString((*it).timeElapsed) << "\n";
468        }
469        ofstr.close();
470}
471//-----------------------------------------------------------------------
472void MouseQueryListener::loadFrames()
473{
474        std::ifstream ifstr(frame_outfile);
475        char line[256];
476        frame_info info;
477
478        // reset current values
479        mFrameInfo.clear();
480        mCurrentFrame = 0;
481       
482        while (!ifstr.eof())
483        {
484                ifstr.getline(line, 256);
485                sscanf(line, "%f %f %f %f %f %f %f %f", &info.position.x, &info.position.y, &info.position.z,
486                                &info.orientation.w, &info.orientation.x, &info.orientation.y, &info.orientation.z,
487                                &info.timeElapsed);
488               
489                mFrameInfo.push_back(info);
490               
491                /*
492                std::stringstream d;
493                d << StringConverter::toString(info.position) << " " << StringConverter::toString(info.orientation);
494                LogManager::getSingleton().logMessage(d.str());
495                */
496        }
497        ifstr.close();
498}
499//-----------------------------------------------------------------------
500void MouseQueryListener::setAppState(int state)
501{
502        mAppState = state;
503}
504//-----------------------------------------------------------------------
505void MouseQueryListener::nextAppState()
506{
507        mCurrentFrame = 0;
508
509        // if last state was replay state
510        if (mAppState == REPLAY)
511        {
512                // reset debug text and write frame info to file
513                mWindow->setDebugText("");
514                writeFrames();
515               
516                //-- write out stats
517                std::stringstream d;
518                d << "Algorithm: " << mCurrentAlgorithmCaptions[mCurrentAlgorithm] << "\n"
519                  << "avg. FPS: " << mWindow->getAverageFPS() << "\n"
520                  << "best FPS: " << mWindow->getBestFPS() << "\n"
521                  << "worst FPS: " << mWindow->getWorstFPS() << "\n"
522                  << "best frame time: " <<     mWindow->getBestFrameTime() << "\n"
523                  << "worst frame time: " << mWindow->getWorstFrameTime();
524               
525                LogManager::getSingleton().logMessage(d.str());
526        }
527       
528        //-- set the next státe
529        mAppState = (mAppState + 1) % STATE_NUM;
530
531        // replay recorded walkthrough
532        if (mAppState == REPLAY)
533        {
534                // no recording during replay
535                mRecord = false;
536
537                // load recorded walkthrough
538                if (mFrameInfo.size() == 0)
539                {
540                        loadFrames();
541                }
542
543                // if there are no recorded frames => set next state
544                if (mFrameInfo.size() == 0)
545                {
546                        nextAppState();
547                }
548                else
549                {
550                        mWindow->setDebugText("Replay");
551                       
552                        // reset, because we measure fps stats during walkthrough
553                        mWindow->resetStatistics();
554
555                        //-- initialise frame data
556                        mTimeElapsed = 0;
557
558                        mCamNode->setPosition(mFrameInfo[0].position);
559                        mCamNode->setOrientation(mFrameInfo[0].orientation);
560                }
561        }
562
563}
564//-----------------------------------------------------------------------
565void MouseQueryListener::toggleRecord()
566{
567        mRecord = !mRecord;
568
569        // clear previous camera path
570        if (mRecord)
571                mFrameInfo.clear();
572        else
573                mWindow->setDebugText("");
574}
575//-----------------------------------------------------------------------
576void MouseQueryListener::changeThreshold(int incr)
577{
578        mVisibilityThreshold += incr;
579        if(mVisibilityThreshold < 0) mVisibilityThreshold = 0;
580       
581        char str[100]; sprintf(str,": %d", mVisibilityThreshold);
582
583        mSceneMgr->setOption("Threshold", &mVisibilityThreshold);
584        mThresholdInfo->setCaption(str);
585}
586//-----------------------------------------------------------------------
587bool MouseQueryListener::processUnbufferedKeyInput(const FrameEvent& evt)
588{   
589        if (mInputDevice->isKeyDown(KC_RIGHT))
590        {
591                mCamNode->yaw(-mRotScale);
592                return true;
593        }
594        if (mInputDevice->isKeyDown(KC_LEFT))
595        {
596                mCamNode->yaw(mRotScale);
597                return true;
598        }
599
600        return ExampleFrameListener::processUnbufferedKeyInput(evt);
601}
602//-----------------------------------------------------------------------
603void MouseQueryListener::zoomVizCamera(int zoom)
604{
605        mVizCameraHeight += zoom;
606        if(mVizCameraHeight < 0) mVizCameraHeight = 0;
607}
608//-----------------------------------------------------------------------
609void MouseQueryListener::nextAlgorithm()
610{
611        mCurrentAlgorithm = (mCurrentAlgorithm + 1) %
612                GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS,
613
614        setAlgorithm(mCurrentAlgorithm);
615}
616//-----------------------------------------------------------------------
617void MouseQueryListener::setAlgorithm(int algorithm)
618{
619        mAlgorithmInfo->setCaption(": " + mCurrentAlgorithmCaptions[mCurrentAlgorithm]);
620        mSceneMgr->setOption("Algorithm", &mCurrentAlgorithm);
621}
622//-----------------------------------------------------------------------
623void MouseQueryListener::updateStats()
624{
625        unsigned int opt = 0;
626        char str[100];
627       
628        mSceneMgr->getOption("NumFrustumCulledNodes", &opt); sprintf(str,": %d", opt);
629        mFrustumCulledNodesInfo->setCaption(str);
630       
631        mSceneMgr->getOption("NumQueriesIssued", &opt); sprintf(str,": %d", opt);
632        mQueriesIssuedInfo->setCaption(str);
633       
634        mSceneMgr->getOption("NumQueryCulledNodes", &opt); sprintf(str,": %d", opt);
635        mQueryCulledNodesInfo->setCaption(str);
636       
637        mSceneMgr->getOption("NumTraversedNodes", &opt); sprintf(str,": %d", opt);
638        mTraversedNodesInfo->setCaption(str);
639
640        mSceneMgr->getOption("NumHierarchyNodes", &opt); sprintf(str,": %d", opt);
641        mHierarchyNodesInfo->setCaption(str);
642
643        mSceneMgr->getOption("NumRenderedNodes", &opt); sprintf(str,": %d", opt);
644        mRenderedNodesInfo->setCaption(str);
645
646        sprintf(str,": %d", mTerrainContentGenerator->GetObjectCount());
647        mObjectsInfo->setCaption(str);
648}
649//-----------------------------------------------------------------------
650void MouseQueryListener::toggleUseOptimization()
651{
652        mUseOptimization = !mUseOptimization;
653
654        mSceneMgr->setOption("UseOptimization", &mUseOptimization);
655
656        if (mUseOptimization)
657                mUseOptimizationInfo->setCaption(": true");
658        else
659                mUseOptimizationInfo->setCaption(": false");
660}
661//-----------------------------------------------------------------------
662void MouseQueryListener::toggleShowOctree()
663{
664        mShowOctree = !mShowOctree;
665
666        mSceneMgr->setOption("ShowOctree", &mShowOctree);
667}
668//-----------------------------------------------------------------------
669void MouseQueryListener::toggleUseVisibilityCulling()
670{
671        mUseVisibilityCulling = !mUseVisibilityCulling;
672
673        mSceneMgr->setOption("UseVisibilityCulling", &mUseVisibilityCulling);
674}
675//-----------------------------------------------------------------------
676void MouseQueryListener::toggleShowViz()
677{
678        mShowVisualization = !mShowVisualization;
679
680        // create viewport with priority VIZ_VIEWPORT_Z_ORDER:
681        // will be rendered over standard viewport
682        if (mShowVisualization)
683        {       
684                Viewport *vizvp = mWindow->addViewport(mVizCamera,
685                        VIZ_VIEWPORT_Z_ORDER, 0.6, 0.6, 0.4, 0.4);
686                               
687                vizvp->setBackgroundColour(ColourValue(0.0, 0.3, 0.2, 1));
688
689                vizvp->setOverlaysEnabled(false);
690                // Alter the camera aspect ratio to match the viewport
691        mVizCamera->setAspectRatio(Real(vizvp->getActualWidth()) /
692                        Real(vizvp->getActualHeight()));
693                //vizvp->setClearEveryFrame(false);
694
695                // Create a skyplane (for visualization background)
696                /*
697                Plane plane;
698                plane.d = -1000;
699                plane.normal = Vector3::UNIT_Y;
700                mSceneMgr->setSkyPlane(true, plane, "Examples/TransparentTest", 4000, 75, false);
701                */
702               
703        }
704        else
705        {
706                mWindow->removeViewport(VIZ_VIEWPORT_Z_ORDER);
707                // if octree was enabled for visualization purpose
708                mSceneMgr->setOption("ShowOctree", &mShowOctree);
709        }
710}
711//-----------------------------------------------------------------------
712void MouseQueryListener::toggleRenderNodesForViz()
713{
714        mRenderNodesForViz = !mRenderNodesForViz;
715
716        mSceneMgr->setOption("RenderNodesForViz", &mRenderNodesForViz);
717}
718//-----------------------------------------------------------------------
719void MouseQueryListener::keyPressed(KeyEvent* e)
720{
721        if(e->getKey() == KC_ESCAPE)
722    {
723                mShutdownRequested = true;
724                e->consume();
725                return;
726        }
727
728        CEGUI::System::getSingleton().injectKeyDown(e->getKey());
729        CEGUI::System::getSingleton().injectChar(e->getKeyChar());
730        e->consume();
731}
732//-----------------------------------------------------------------------
733void MouseQueryListener::keyReleased(KeyEvent* e)
734{
735        CEGUI::System::getSingleton().injectKeyUp(e->getKey());
736        e->consume();
737}
738//-----------------------------------------------------------------------
739void MouseQueryListener::keyClicked(KeyEvent* e)
740{
741        // Do nothing
742        e->consume();
743}
744//-----------------------------------------------------------------------
745void MouseQueryListener::addFrameInfo(SceneNode *camNode, Real timeElapsed)
746{
747        frame_info info;
748        info.orientation = mCamNode->getOrientation();
749        info.position = mCamNode->getPosition();
750        info.timeElapsed = timeElapsed;
751
752        mFrameInfo.push_back(info);
753}
754//-----------------------------------------------------------------------
755void MouseQueryListener::setCurrentFrameInfo(Real timeElapsed)
756{
757        //-- find current frame relative to elapsed frame time         
758        mTimeElapsed -= timeElapsed;
759
760        while ((mTimeElapsed <= 0) && (mCurrentFrame < (int)mFrameInfo.size() - 1))
761        {
762                mTimeElapsed += mFrameInfo[mCurrentFrame ++].timeElapsed;
763        }
764
765        frame_info new_frame = mFrameInfo[mCurrentFrame];
766        frame_info old_frame = mFrameInfo[mCurrentFrame - 1];
767               
768        //-- interpolate frames
769        Real factor = 1;
770
771        if (old_frame.timeElapsed > 0)
772                factor = mTimeElapsed / old_frame.timeElapsed;
773
774        Vector3 camPos = old_frame.position + factor * (new_frame.position - old_frame.position);
775        Quaternion camOrienation = Quaternion::Slerp(factor, old_frame.orientation,
776                new_frame.orientation, true);
777
778        mCamNode->setPosition(camPos);
779        mCamNode->setOrientation(camOrienation);
780       
781        // stop replay after a full walkthrough
782        if (mCurrentFrame == (int)mFrameInfo.size() - 1)
783        {
784                nextAppState();
785        }
786}
787
788/**************************************************************/
789/*      VisualizationRenderTargetListener implementation      */
790/**************************************************************/
791//-----------------------------------------------------------------------
792VisualizationRenderTargetListener::VisualizationRenderTargetListener(SceneManager *sceneMgr)
793:RenderTargetListener(), mSceneMgr(sceneMgr)
794{
795}
796//-----------------------------------------------------------------------
797void VisualizationRenderTargetListener::preViewportUpdate(const RenderTargetViewportEvent &evt)
798{
799        const bool showViz = evt.source->getZOrder() == VIZ_VIEWPORT_Z_ORDER; // visualization viewport
800        const bool nShowViz = !showViz;
801
802    mSceneMgr->setOption("ShowVisualization", &showViz);
803        mSceneMgr->setOption("SkyBoxEnabled", &nShowViz);
804        //mSceneMgr->setOption("SkyPlaneEnabled", &showViz);
805       
806        RenderTargetListener::preViewportUpdate(evt);
807}
808//-----------------------------------------------------------------------
809void VisualizationRenderTargetListener::postRenderTargetUpdate(const RenderTargetEvent &evt)
810{
811        RenderTargetListener::postRenderTargetUpdate(evt);
812}
813//-----------------------------------------------------------------------
814INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT )
815{
816    // Create application object
817    TestCullingTerrainApplication app;
818
819        try
820        {
821        app.go();
822    }
823        catch( Ogre::Exception& e )
824        {
825        MessageBox( NULL, e.getFullDescription().c_str(),
826                        "An exception has occured!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
827    }   
828
829    return 0;
830}
Note: See TracBrowser for help on using the repository browser.