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

Revision 113, 28.9 KB checked in by mattausch, 19 years ago (diff)

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