source: trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.cpp @ 173

Revision 173, 42.7 KB checked in by mattausch, 19 years ago (diff)

did some code cleanup
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 "TerrainFrameListener.h"
8#include "OgrePlatformQueryManager.h"
9#include "OgreVisibilityTerrainSceneManager.h"
10#include "VisibilityInfo.h"
11#include "OgreOcclusionQueriesQueryManager.h"
12#include "TestCullingTerrainApplication.h"
13
14
15//-- captions for overlays
16String TerrainFrameListener::msAlgorithmCaptions[] =
17{
18        "View Frustum Culling",
19        "Stop and Wait Culling",
20        "Coherent Hierarchical Culling"
21};
22
23String TerrainFrameListener::msQueryTypeCaptions[] =
24{
25        "from camera",
26        "from viewpoint"
27};
28
29String TerrainFrameListener::msQueryRelativeVisCaptions[] =
30{
31        "visible pixels",
32        "relative visibility"
33};
34
35String TerrainFrameListener::msQueryMethodCaptions[] =
36{
37        "occlusion queries",
38        "item buffer"
39};
40
41Real TerrainFrameListener::msObjectTerrainOffsets[] =
42{
43        0,
44        7,
45        0
46};
47
48Real TerrainFrameListener::msObjectScales[] =
49{
50        0.1,
51        0.6,
52        0.07
53};
54
55String TerrainFrameListener::msObjectCaptions[] =
56{
57        "robot",
58        "athene",
59        //"tree2",
60        //"HongKong_Tower",
61        "ninja"
62        //"ogrehead"
63};
64
65// output file for frame info
66const char* frames_out_filename = "frame.out";
67// output file for object positions / orientations
68const char* objects_out_filename = "objects.out";
69
70
71//-----------------------------------------------------------------------
72TerrainFrameListener::TerrainFrameListener(RenderWindow* win, Camera* cam,
73                                                                           SceneManager *sceneManager,
74                                                                           CEGUI::Renderer *renderer,
75                                                                           TerrainContentGenerator *sceneGenerator,
76                                                                           Camera *vizCamera,
77                                                                           SceneNode *camNode,
78                                                                           Light *sunLight,
79                                                                           TestCullingTerrainApplication *app):
80mCamera(cam),
81mWindow(win),
82mNumScreenShots(0),
83mTimeDelay(0),
84mSceneDetailIndex(0),
85mMoveScale(0.0f),
86mRotScale(0.0f),
87mTranslateVector(Vector3::ZERO),
88mAniso(1),
89mFiltering(TFO_BILINEAR),
90mGUIRenderer(renderer),
91mSceneMgr(sceneManager),
92mCurrentObject(NULL),
93mTerrainContentGenerator(sceneGenerator),
94mVisibilityThreshold(0),
95mAssumedVisibility(0),
96mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING),
97//mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::FRUSTUM_CULLING),
98mNodeVizMode(NODEVIZ_NONE),
99mVizCameraHeight(Real(2500.0)),
100mCamNode(camNode),
101mAppState(WALKTHROUGH),
102mCurrentFrame(0),
103mReplayTimeElapsed(0),
104mRotateSpeed(72),
105mMoveSpeed(50),
106mVizCamera(vizCamera),
107mStatsOn(true),
108mShutdownRequested(false),
109mLMouseDown(false),
110mRMouseDown(false),
111mShowOctree(false),
112mUseDepthPass(false),
113mTestGeometryForVisibleLeaves(true),
114mShowVisualization(false),
115mCullCamera(false),
116mRecord(false),
117mShowShadows(false),
118mShowHelp(false),
119mDisplayCameraDetails(false),
120mVisualizeCulledNodes(false),
121mSunLight(sunLight),
122mShiftPressed(false),
123mShowQueryStats(false),
124mQueryManager(NULL),
125mVisibilityManager(NULL),
126mDelayedQueriesIssued(0.0),
127mDelayedTraversedNodes(0.0),
128mUseItemBuffer(false),
129mRenderPatchesForItemBuffer(false),
130mCurrentObjectType(0),
131mApplication(app),
132mUseAnimation(false),
133mDeleteObjects(false)
134{
135        //mInputDevice = PlatformManager::getSingleton().createInputReader();
136        //mInputDevice->initialise(win, true, true);
137
138        mEventProcessor = new EventProcessor();
139       
140        mEventProcessor->initialise(win);
141        mEventProcessor->startProcessingEvents();
142        mEventProcessor->addMouseListener(this);
143        mEventProcessor->addMouseMotionListener(this);
144        mEventProcessor->addKeyListener(this);
145
146        mInputDevice = mEventProcessor->getInputReader();       
147
148        // create ray query executor, used to place objects in terrain
149        mRayQueryExecutor = new RayQueryExecutor(mSceneMgr);
150       
151        //-- overlays
152        mDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay");
153        mHelpOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/HelpOverlay");
154        mQueryOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/QueryOverlay");
155        mCullStatsOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/CullStatsOverlay");
156
157        initVisStatsOverlay(); // visibility stats overlay
158        initHelpOverlay(); // help overlay
159        initQueryOverlay(); // visibility query stats overlay
160
161        // show stats overlays
162        showStats(true);
163       
164        // set culling algorithm type
165        setAlgorithm(mCurrentAlgorithm);
166
167        // set scene manager options
168        mSceneMgr->setOption("TestGeometryForVisibleLeaves", &mTestGeometryForVisibleLeaves);
169
170        // apply delayed rendering (i.e., transparents after hierarchical culling pass)
171        // only if optimization is not used
172        bool delayRenderTransparents = !mTestGeometryForVisibleLeaves;
173
174        mSceneMgr->setOption("DelayRenderTransparents", &delayRenderTransparents);
175        mSceneMgr->setOption("UseDepthPass", &mUseDepthPass);
176       
177        mSceneMgr->setOption("ShowOctree", &mShowOctree);
178        mSceneMgr->setOption("CullCamera", &mCullCamera);
179        mSceneMgr->setOption("PrepareVisualization", &mShowVisualization);
180
181        setObjectType(mCurrentObjectType);
182
183        // reset statistics
184        resetStats();
185}
186//-----------------------------------------------------------------------
187TerrainFrameListener::~TerrainFrameListener()
188{
189        delete mRayQueryExecutor;
190        delete mEventProcessor;
191
192        if (mQueryManager)
193        {
194                delete mQueryManager;
195                mQueryManager = NULL;
196        }
197}
198//-----------------------------------------------------------------------
199void TerrainFrameListener::mouseMoved(MouseEvent *e)
200{
201        // Update CEGUI with the mouse motion
202    CEGUI::System::getSingleton().injectMouseMove(e->getRelX() *
203                mGUIRenderer->getWidth(), e->getRelY() * mGUIRenderer->getHeight());
204}
205//-----------------------------------------------------------------------
206void TerrainFrameListener::mousePressed(MouseEvent* e)
207{
208     // Left mouse button down
209     if (e->getButtonID() & InputEvent::BUTTON0_MASK)
210     {
211                 CEGUI::MouseCursor::getSingleton().hide();
212
213                 // Setup the ray scene query
214         Ray mouseRay = mCamera->getCameraToViewportRay(e->getX(), e->getY());
215                 
216                 //Vector3 queryResult; mRayQueryExecutor->executeRayQuery(&queryResult, mouseRay);
217                 
218                 Real val = Math::RangeRandom(0, 360); // random rotation
219
220                 // get results, create a node/entity on the position
221                 mCurrentObject = mTerrainContentGenerator->GenerateSceneObject(
222                         mouseRay.getOrigin()/*queryResult*/, Vector3(val, 0, 0),
223                         msObjectCaptions[mCurrentObjectType]);
224               
225         mLMouseDown = true;
226     }
227     // Right mouse button down
228     else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
229     {
230         CEGUI::MouseCursor::getSingleton().hide();
231         mRMouseDown = true;
232     }
233}
234//-----------------------------------------------------------------------
235void TerrainFrameListener::mouseDragDropped(MouseEvent* e)
236{
237        // Left mouse button up
238    if (e->getButtonID() & InputEvent::BUTTON0_MASK)
239    {
240                CEGUI::MouseCursor::getSingleton().show();
241               
242            mLMouseDown = false;
243    }
244    // Right mouse button up
245    else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
246    {
247        CEGUI::MouseCursor::getSingleton().show();
248
249                mRMouseDown = false;
250    }
251}
252//-----------------------------------------------------------------------
253void TerrainFrameListener::mouseReleased(MouseEvent* e)
254{
255    // Left mouse button up
256    if (e->getButtonID() & InputEvent::BUTTON0_MASK)
257    {
258                CEGUI::MouseCursor::getSingleton().show();
259               
260                // start animation: only robot has animation phases
261                if (mCurrentObject && (mCurrentObjectType == TestCullingTerrainApplication::ROBOT))
262                {
263                        // HACK: not neccesary the last element
264                        Entity *ent = mTerrainContentGenerator->GetGeneratedEntities()->back();
265                        EntityState *entState = new EntityState(ent, EntityState::MOVING, Math::RangeRandom(0.5, 1.5));
266                        mApplication->getEntityStates().push_back(entState);
267                }
268
269            mLMouseDown = false;
270    }
271    // Right mouse button up
272    else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
273    {
274        CEGUI::MouseCursor::getSingleton().show();
275
276        mRMouseDown = false;
277    }
278}
279//-----------------------------------------------------------------------
280void TerrainFrameListener::mouseDragged(MouseEvent *e)
281 {
282         // If we are dragging the left mouse button.           
283         if (mLMouseDown)
284     {
285                 if (!mCurrentObject)
286                         return;
287
288                 Vector3 queryResult;
289                 Ray mouseRay = mCamera->getCameraToViewportRay(e->getX(), e->getY());
290
291                 if (mRayQueryExecutor->executeRayQuery(&queryResult, mouseRay))
292                 {
293                         // apply offset so object is ON terrain
294                         queryResult.y += msObjectTerrainOffsets[mCurrentObjectType];
295                         mCurrentObject->setPosition(queryResult);
296                 }
297     }
298         // If we are dragging the right mouse button.
299         if (mRMouseDown)
300         {
301                 //mCamera->yaw(-e->getRelX() * mRotateSpeed);
302                 //mCamera->pitch(-e->getRelY() * mRotateSpeed);
303                 mCamNode->yaw(-e->getRelX() * mRotateSpeed);
304                 mCamNode->pitch(-e->getRelY() * mRotateSpeed);
305         }
306}
307//-----------------------------------------------------------------------
308bool TerrainFrameListener::frameStarted(const FrameEvent &evt)
309{
310        if (mWindow->isClosed())
311        {
312        return false;
313        }
314       
315        if (mDeleteObjects)
316        {
317                mApplication->deleteEntityStates();
318                mTerrainContentGenerator->RemoveGeneratedObjects();
319                mDeleteObjects = false;
320        }
321
322        if (mUseAnimation) // update animations
323        {
324                mApplication->updateAnimations(evt.timeSinceLastFrame);
325        }
326
327        if (mDisplayCameraDetails)  // Print camera details
328    {       
329        mWindow->setDebugText("P: " + StringConverter::toString(mCamera->getDerivedPosition()) +
330                        " " + "O: " + StringConverter::toString(mCamera->getDerivedOrientation()));
331    }
332
333        //-- setup what is needed for immediate mouse/key movement
334        if (mTimeDelay >= 0)
335        {
336                mTimeDelay -= evt.timeSinceLastFrame;
337        }
338       
339        // If this is the first frame, pick a speed
340        if (evt.timeSinceLastFrame == 0)
341        {
342                mMoveScale = 1;
343                mRotScale = 0.1;
344        }
345        // Otherwise scale movement units by time passed since last frame
346        else
347        {
348                // Move about 100 units per second,
349                mMoveScale = mMoveSpeed * evt.timeSinceLastFrame;
350                // Take about 10 seconds for full rotation
351                mRotScale = mRotateSpeed * evt.timeSinceLastFrame;
352        }
353
354        mRotX = 0;
355        mRotY = 0;
356        mTranslateVector = Vector3::ZERO;
357
358        if (!processUnbufferedKeyInput(evt))
359        {
360                return false;
361        }
362/*      if (!processUnbufferedMouseInput(evt))
363        {       return false;   }*/
364
365        // --- set parameters for visualization
366        if (mShowVisualization)
367        {
368                // important for visualization => draw octree bounding boxes
369                mSceneMgr->setOption("ShowOctree", &mShowVisualization);
370               
371                // ---- setup visualization camera
372
373                mVizCamera->setPosition(0, 0, 0);
374                mVizCamera->setOrientation(Quaternion::IDENTITY);
375
376                Vector3 camPos = mCamNode->getPosition();
377                mVizCamera->setPosition(camPos.x, mVizCameraHeight, camPos.z);
378
379                // point down -Z axis
380                mVizCamera->pitch(Radian(Degree(270.0)));
381
382                // rotation arounnd X axis
383                mVizCamera->yaw(Math::ATan2(-mCamera->getDerivedDirection().x,
384                        -mCamera->getDerivedDirection().z));
385               
386                // move by a constant so view plane is on bottom of viewport
387                mVizCamera->moveRelative(Vector3(0, 800, 0));
388        }
389
390        //-- set application state
391        switch (mAppState)
392        {
393        case REPLAY:
394                setCurrentFrameInfo(evt.timeSinceLastFrame);
395                break;
396        case WALKTHROUGH:
397                //-- if we are recording camera status per frame
398                if (mRecord)
399                {
400                        addFrameInfo(mCamNode, evt.timeSinceLastFrame);
401                        // print recording message
402                        mWindow->setDebugText("Recording frame " +
403                                StringConverter::toString(mFrameInfo.size() - 1));
404                }       
405                // move camera according to input
406                moveCamera();
407
408                // clamp camera so we always walk along the terrain
409                mApplication->Clamp2Terrain(mCamNode, 10);
410                break;
411
412        default:
413                break;
414        };     
415
416        return true;
417}
418//-----------------------------------------------------------------------
419void TerrainFrameListener::applyVisibilityQuery(bool fromPoint, bool relativeVisibility,
420                                                                                                bool useItemBuffer)
421{
422        // TODO: change this (does not work with other scene manager plugins)
423        VisibilityTerrainSceneManager *sm =
424                dynamic_cast<VisibilityTerrainSceneManager *>(mSceneMgr);
425
426        mQueryManager = new OcclusionQueriesQueryManager(sm->GetHierarchyInterface(),
427                        mWindow->getViewport(0), true, useItemBuffer);
428        //mQueryManager = new PlatformQueryManager(sm->GetHierarchyInterface(), mWindow->getViewport(0), false);
429       
430        sm->GetVisibilityManager()->SetQueryManager(mQueryManager);
431
432        InfoContainer<GtpVisibility::NodeInfo> visibleNodes;
433        InfoContainer<GtpVisibility::MeshInfo> visibleGeometry;
434        InfoContainer<GtpVisibility::PatchInfo> visiblePatches;
435
436
437        if (fromPoint)
438        {
439                mQueryManager->
440                        ComputeFromPointVisibility(mCamNode->getPosition(), &visibleNodes,
441                                                                           &visibleGeometry, &visiblePatches, relativeVisibility);
442        }
443        else
444        {
445                mQueryManager->ComputeCameraVisibility(*mCamera,
446                            &visibleNodes, &visibleGeometry, &visiblePatches, relativeVisibility);
447        }
448               
449        std::stringstream d;
450        d << msQueryTypeCaptions[fromPoint ?  1 : 0].c_str() << " "
451          << msQueryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str() << " "
452      << msQueryMethodCaptions[useItemBuffer ? 1 : 0].c_str();
453        LogManager::getSingleton().logMessage(d.str());
454
455
456        float averageNodeVis = 0, averageGeometryVis = 0, averagePatchVis = 0;
457        int geomSize = 0, nodesSize = 0, patchSize = 0;
458
459        InfoContainer<GtpVisibility::MeshInfo>::iterator geomIt, geomIt_end = visibleGeometry.end();
460
461        for (geomIt = visibleGeometry.begin(); geomIt != geomIt_end; ++geomIt)
462        {
463                // add if not 0
464                if ((*geomIt).GetVisiblePixels())
465                {
466                        float vis = relativeVisibility ?
467                                (*geomIt).ComputeRelativeVisibility() : (float)(*geomIt).GetVisiblePixels();
468       
469                        averageGeometryVis += vis;
470                        ++ geomSize;
471                       
472                        std::stringstream d;
473                        d << "Geometry " << geomSize << " id: " << (*geomIt).GetMesh()->getSubEntity(0)->getId()
474                          << " visibility: "  << (*geomIt).GetVisiblePixels() << ", " << (*geomIt).GetProjectedPixels();
475                        LogManager::getSingleton().logMessage(d.str());
476                }
477        }
478
479        InfoContainer<GtpVisibility::NodeInfo>::iterator nodesIt, nodesIt_end = visibleNodes.end();
480
481        for (nodesIt = visibleNodes.begin(); nodesIt != nodesIt_end; ++nodesIt)
482        {
483                // add if not 0
484                if ((*nodesIt).GetVisiblePixels())
485                {
486                        float vis = relativeVisibility ?
487                                (*nodesIt).ComputeRelativeVisibility() : (float)(*nodesIt).GetVisiblePixels();
488               
489                        averageNodeVis += vis;
490                        ++ nodesSize;
491
492                        std::stringstream d; d << "Node visibility: " << vis;
493                        LogManager::getSingleton().logMessage(d.str());
494                }       
495        }
496
497        InfoContainer<GtpVisibility::PatchInfo>::iterator patchIt, patchIt_end = visiblePatches.end();
498
499        for (patchIt = visiblePatches.begin(); patchIt != patchIt_end; ++ patchIt)
500        {
501                // add if not 0
502                if ((*patchIt).GetVisiblePixels())
503                {
504                        float vis = relativeVisibility ?
505                                (*patchIt).ComputeRelativeVisibility() : (float)(*patchIt).GetVisiblePixels();
506               
507                        averagePatchVis += vis;
508                        ++ patchSize;
509
510                        std::stringstream d; d << "Patch visibility: " << vis;
511                        LogManager::getSingleton().logMessage(d.str());
512                }       
513        }
514
515        if (nodesSize)
516                averageNodeVis /= (float)nodesSize;
517        if (geomSize)
518                averageGeometryVis /= (float)geomSize;
519        if (patchSize)
520                averagePatchVis /= (float)patchSize;
521
522        //-- update visibility queries stats
523    try
524        {
525                char str[100];
526               
527                sprintf(str, ": %s, %s, %s",
528                                msQueryTypeCaptions[fromPoint ?  1 : 0].c_str(),
529                                msQueryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str(),
530                                msQueryMethodCaptions[useItemBuffer ? 1 : 0].c_str());
531
532                mQueryTypeInfo->setCaption(str);
533
534                sprintf(str, ": %d", (int)nodesSize);
535                mQueryVisibleNodesInfo->setCaption(str);
536       
537                sprintf(str,": %d", (int)geomSize);
538                mQueryVisibleGeometryInfo->setCaption(str);
539               
540                sprintf(str,": %d", (int)patchSize);
541                mQueryVisiblePatchInfo->setCaption(str);
542
543                sprintf(str,": %3.3f", averageNodeVis);
544                mQueryNodeVisibilityInfo->setCaption(str);
545
546                sprintf(str,": %3.3f", averageGeometryVis);
547                mQueryGeometryVisibilityInfo->setCaption(str);
548
549                sprintf(str,": %3.3f", averagePatchVis);
550                mQueryPatchVisibilityInfo->setCaption(str);
551        }
552        catch (...)
553        {
554                // ignore
555        }
556
557        // show the results
558        if (!mShowQueryStats && !mShowHelp)
559        {
560                mQueryOverlay->show();
561                mShowQueryStats = true;
562        }
563
564        delete mQueryManager;
565}
566
567//-----------------------------------------------------------------------
568bool TerrainFrameListener::frameEnded(const FrameEvent& evt)
569{
570        if (mShutdownRequested)
571                return false;
572
573    updateStats();
574
575        //-- IMPORTANT: must be set, otherwise terrain is not rendered correctly
576        mSceneMgr->endFrame();
577
578        if (mTimeDelay <= 0) // approx. one second
579                mTimeDelay = 1.0;
580
581        return true;
582}
583//-----------------------------------------------------------------------
584void TerrainFrameListener::moveCamera()
585{
586        // move node rather than camera so orientation is right in the visualization
587        mCamNode->yaw(mRotX);
588        mCamNode->pitch(mRotY);
589        mCamNode->translate(mCamNode->getLocalAxes(), mTranslateVector);
590}
591//-----------------------------------------------------------------------
592void TerrainFrameListener::writeFrames()
593{
594        std::ofstream ofstr(frames_out_filename);
595       
596        std::vector<frame_info>::const_iterator it, it_end;
597
598        it_end = mFrameInfo.end();
599        for (it = mFrameInfo.begin(); it < it_end; ++it)
600        {
601                ofstr << StringConverter::toString((*it).position) << " "
602                          << StringConverter::toString((*it).orientation) << " "
603                          << StringConverter::toString((*it).timeElapsed) << "\n";
604        }
605        ofstr.close();
606}
607//-----------------------------------------------------------------------
608void TerrainFrameListener::loadFrames()
609{
610        std::ifstream ifstr(frames_out_filename);
611        char line[256];
612        frame_info info;
613
614        // reset current values
615        mFrameInfo.clear();
616        mCurrentFrame = 0;
617       
618        while (!ifstr.eof())
619        {
620                ifstr.getline(line, 256);
621                sscanf(line, "%f %f %f %f %f %f %f %f", &info.position.x, &info.position.y, &info.position.z,
622                           &info.orientation.w, &info.orientation.x, &info.orientation.y, &info.orientation.z,
623                           &info.timeElapsed);
624               
625                mFrameInfo.push_back(info);
626               
627                // std::stringstream d; d << StringConverter::toString(info.position) << " " << StringConverter::toString(info.orientation);
628                // LogManager::getSingleton().logMessage(d.str());
629        }
630        ifstr.close();
631}
632//-----------------------------------------------------------------------
633void TerrainFrameListener::nextAppState()
634{
635        mCurrentFrame = 0;
636
637        // if last state was replay state
638        if (mAppState == REPLAY)
639        {
640                // reset debug text and write frame info to file
641                mWindow->setDebugText("");
642                writeFrames();
643               
644                float avgFps = (float)mAvgFps / (float)mFrameCount;
645
646                //-- write out stats for recorded walkthrough
647                std::stringstream d;
648                d << "Algorithm: " << msAlgorithmCaptions[mCurrentAlgorithm] << "\n"
649                  //<< "avg. FPS: " << mWindow->getAverageFPS() << "\n"
650                  << "avg. FPS: " << avgFps << "\n"
651                  << "best FPS: " << mWindow->getBestFPS() << "\n"
652                  << "worst FPS: " << mWindow->getWorstFPS() << "\n"
653                  << "best frame time: " <<     mWindow->getBestFrameTime() << "\n"
654                  << "worst frame time: " << mWindow->getWorstFrameTime();
655               
656                LogManager::getSingleton().logMessage(d.str());
657        }
658       
659        //-- set the next státe
660        mAppState = (mAppState + 1) % STATE_NUM;
661
662        // replay recorded walkthrough
663        if (mAppState == REPLAY)
664        {
665                // no recording during replay
666                mRecord = false;
667
668                // load recorded walkthrough
669                if (mFrameInfo.size() == 0)
670                {
671                        loadFrames();
672                }
673
674                // if there are no recorded frames => set next state
675                if (mFrameInfo.size() == 0)
676                {
677                        nextAppState();
678                }
679                else
680                {
681                        mWindow->setDebugText("Replay");
682                       
683                        // reset, because we measure fps stats during walkthrough (warning: average fps broken)
684                        mWindow->resetStatistics();
685                        resetStats();
686
687                        //-- initialise frame data
688                        mReplayTimeElapsed = 0;
689
690                        mCamNode->setPosition(mFrameInfo[0].position);
691                        mCamNode->setOrientation(mFrameInfo[0].orientation);
692                }
693        }
694
695}
696//-----------------------------------------------------------------------
697void TerrainFrameListener::toggleRecord()
698{
699        mRecord = !mRecord;
700
701        // clear previous camera path
702        if (mRecord)
703                mFrameInfo.clear();
704        else
705                mWindow->setDebugText("");
706}
707//-----------------------------------------------------------------------
708void TerrainFrameListener::changeThreshold(int incr)
709{
710        mVisibilityThreshold += incr;
711        if(mVisibilityThreshold < 0) mVisibilityThreshold = 0;
712       
713        char str[100]; sprintf(str,": %d", mVisibilityThreshold);
714
715        mSceneMgr->setOption("Threshold", &mVisibilityThreshold);
716        mThresholdInfo->setCaption(str);
717}
718//-----------------------------------------------------------------------
719void TerrainFrameListener::changeAssumedVisibility(int incr)
720{
721        mAssumedVisibility += incr;
722        if(mAssumedVisibility < 0) mAssumedVisibility = 0;
723       
724        char str[100]; sprintf(str,": %d", mAssumedVisibility);
725
726        mSceneMgr->setOption("AssumedVisibility", &mAssumedVisibility);
727        mAssumedVisibilityInfo->setCaption(str);
728}
729//-----------------------------------------------------------------------
730void TerrainFrameListener::zoomVizCamera(int zoom)
731{
732        mVizCameraHeight += zoom;
733        if(mVizCameraHeight < 0) mVizCameraHeight = 0;
734}
735//-----------------------------------------------------------------------
736void TerrainFrameListener::nextAlgorithm()
737{
738        mCurrentAlgorithm = (mCurrentAlgorithm + 1) %
739                GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS,
740
741        setAlgorithm(mCurrentAlgorithm);
742}
743//-----------------------------------------------------------------------
744void TerrainFrameListener::setObjectType(int objectType)
745{
746        if (mCurrentObjectType >= 3)
747                mCurrentObjectType = 0;
748
749        // parameters for new object
750        mTerrainContentGenerator->SetOffset(msObjectTerrainOffsets[mCurrentObjectType]);
751        Real scale = msObjectScales[mCurrentObjectType];
752        mTerrainContentGenerator->SetScale(Vector3(scale, scale, scale));
753
754        mCurrentObjectTypeInfo->setCaption(": " + msObjectCaptions[mCurrentObjectType]);
755}
756//-----------------------------------------------------------------------
757void TerrainFrameListener::setAlgorithm(int algorithm)
758{
759        mAlgorithmInfo->setCaption(": " + msAlgorithmCaptions[mCurrentAlgorithm]);
760        mSceneMgr->setOption("Algorithm", &mCurrentAlgorithm);
761}
762//-----------------------------------------------------------------------
763void TerrainFrameListener::resetStats()
764{
765        mAvgFps = 0;
766        mFrameCount = 0;
767}
768//-----------------------------------------------------------------------
769void TerrainFrameListener::updateStats()
770{
771        unsigned int opt = 0;
772        char str[100];
773       
774        static String currFpsString = "Current FPS: ";
775        static String avgFpsString = "Average FPS: ";
776        static String bestFpsString = "Best FPS: ";
777        static String worstFpsString = "Worst FPS: ";
778        static String trisString = "Triangle Count: ";
779
780        // HACK: compute average fps ourselfs, because ogre avg. fps is wrong
781        // TODO: update only once per second
782        mAvgFps += mWindow->getStatistics().lastFPS;
783        ++ mFrameCount;
784       
785        float avgFps = (float)mAvgFps / (float)mFrameCount;
786   
787        // update stats when necessary
788    try
789        {
790                OverlayElement* guiAvg = OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");
791                OverlayElement* guiCurr = OverlayManager::getSingleton().getOverlayElement("Core/CurrFps");
792                OverlayElement* guiBest = OverlayManager::getSingleton().getOverlayElement("Core/BestFps");
793                OverlayElement* guiWorst = OverlayManager::getSingleton().getOverlayElement("Core/WorstFps");
794
795                const RenderTarget::FrameStats& stats = mWindow->getStatistics();
796
797                //guiAvg->setCaption(avgFps + StringConverter::toString(stats.avgFPS));
798                if (mTimeDelay < 0) // only update once per second
799                {               
800                        guiAvg->setCaption(avgFpsString + StringConverter::toString(avgFps) + " ms");
801                }
802
803                guiCurr->setCaption(currFpsString + StringConverter::toString(stats.lastFPS));
804                guiBest->setCaption(bestFpsString + StringConverter::toString(stats.bestFPS)
805                        +" "+StringConverter::toString(stats.bestFrameTime) + " ms");
806                guiWorst->setCaption(worstFpsString + StringConverter::toString(stats.worstFPS)
807                        +" "+StringConverter::toString(stats.worstFrameTime) + " ms");
808
809                OverlayElement* guiTris = OverlayManager::getSingleton().getOverlayElement("Core/NumTris");
810        guiTris->setCaption(trisString + StringConverter::toString(stats.triangleCount));
811
812                OverlayElement* guiDbg = OverlayManager::getSingleton().getOverlayElement("Core/DebugText");
813                guiDbg->setCaption(mWindow->getDebugText());
814
815                //-- culling stats
816                mSceneMgr->getOption("NumFrustumCulledNodes", &opt); sprintf(str,": %d", opt);
817                mFrustumCulledNodesInfo->setCaption(str);
818
819                mSceneMgr->getOption("NumQueryCulledNodes", &opt); sprintf(str,": %d", opt);
820                mQueryCulledNodesInfo->setCaption(str);
821       
822                mSceneMgr->getOption("NumHierarchyNodes", &opt); sprintf(str,": %d", opt);
823                mHierarchyNodesInfo->setCaption(str);
824
825                mSceneMgr->getOption("NumRenderedNodes", &opt); sprintf(str,": %d", opt);
826                mRenderedNodesInfo->setCaption(str);
827
828                sprintf(str,": %d", mTerrainContentGenerator->GetObjectCount());
829                mObjectsCountInfo->setCaption(str);
830
831                // take old value into account in order to create no sudden changes
832                mSceneMgr->getOption("NumQueriesIssued", &opt);
833                mDelayedQueriesIssued = mDelayedQueriesIssued * 0.8 + (float)opt * 0.2;
834                sprintf(str,": %d", (int)mDelayedQueriesIssued);
835                mQueriesIssuedInfo->setCaption(str);
836
837                mSceneMgr->getOption("NumTraversedNodes", &opt);
838                mDelayedTraversedNodes = mDelayedTraversedNodes * 0.8 + (float)opt * 0.2;
839                sprintf(str,": %d", (int)mDelayedTraversedNodes);
840                mTraversedNodesInfo->setCaption(str);
841
842        }
843        catch (...)
844        {
845                // ignore
846        }
847}
848//-----------------------------------------------------------------------
849void TerrainFrameListener::toggleTestGeometryForVisibleLeaves()
850{
851        mTestGeometryForVisibleLeaves = !mTestGeometryForVisibleLeaves;
852        mSceneMgr->setOption("TestGeometryForVisibleLeaves", &mTestGeometryForVisibleLeaves);
853       
854        /* disable optimization which tests geometry instead of aabb
855         * for "delayed" rendering of transparents (i.e., render transparents after all the solids)
856         * because otherwise visible transparents could be skipped
857         */
858        bool delayedRendering = !mTestGeometryForVisibleLeaves;
859
860        mSceneMgr->setOption("DelayRenderTransparents", &delayedRendering);
861
862        if (mTestGeometryForVisibleLeaves)
863        {
864                mTestGeometryForVisibleLeavesInfo->setCaption(": true");
865        }
866        else
867        {
868                mTestGeometryForVisibleLeavesInfo->setCaption(": false");
869        }
870}
871//-----------------------------------------------------------------------
872void TerrainFrameListener::toggleShowOctree()
873{
874        mShowOctree = !mShowOctree;
875
876        mSceneMgr->setOption("ShowOctree", &mShowOctree);
877}
878//-----------------------------------------------------------------------
879void TerrainFrameListener::toggleUseDepthPass()
880{
881        mUseDepthPass = !mUseDepthPass;
882
883        mSceneMgr->setOption("UseDepthPass", &mUseDepthPass);
884       
885        if (mUseDepthPass)
886        {
887                mUseDepthPassInfo->setCaption(": true");
888        }
889        else
890        {
891                mUseDepthPassInfo->setCaption(": false");
892        }
893}
894//-----------------------------------------------------------------------
895void TerrainFrameListener::toggleShowViz()
896{
897        mVisualizeCulledNodes = mShowVisualization = !mShowVisualization;
898       
899        // create viewport with priority VIZ_VIEWPORT_Z_ORDER:
900        // will be rendered over standard viewport
901        if (mShowVisualization)
902        {       
903                Viewport *vizvp = mWindow->addViewport(mVizCamera,
904                        VIZ_VIEWPORT_Z_ORDER, 0.6, 0.6, 0.4, 0.4);
905                               
906                vizvp->setBackgroundColour(ColourValue(0.0, 0.3, 0.2, 1));
907
908                vizvp->setOverlaysEnabled(false);
909                // Alter the camera aspect ratio to match the viewport
910        mVizCamera->setAspectRatio(Real(vizvp->getActualWidth()) /
911                                                                   Real(vizvp->getActualHeight()));
912               
913                mSceneMgr->setOption("VisualizeCulledNodes", &mVisualizeCulledNodes);
914                //vizvp->setClearEveryFrame(false);
915
916                // Create a skyplane (for visualization background)
917                /*
918                Plane plane;
919                plane.d = -1000;
920                plane.normal = Vector3::UNIT_Y;
921                mSceneMgr->setSkyPlane(true, plane, "Examples/TransparentTest", 4000, 75, false);
922                */
923        }
924        else
925        {
926                // remove visualization viewport
927                mWindow->removeViewport(VIZ_VIEWPORT_Z_ORDER);
928
929                // octree bounding boxes are shown for visualization purpose, reset now
930                mSceneMgr->setOption("ShowOctree", &mShowOctree);
931        }
932}
933//-----------------------------------------------------------------------
934void TerrainFrameListener::toggleShowShadows()
935{
936        mShowShadows = !mShowShadows;
937
938        mSunLight->setCastShadows(mShowShadows);
939
940        if (mShowShadows)
941        {
942                mSceneMgr->setShadowTechnique(SHADOWTYPE_TEXTURE_MODULATIVE);
943                //mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_MODULATIVE);
944                //mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_ADDITIVE);           
945        }
946        else
947        {
948                mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
949        }
950
951}
952//-----------------------------------------------------------------------
953void TerrainFrameListener::nextNodeVizMode()
954{
955        mNodeVizMode = (mNodeVizMode + 1) % NODEVIZ_MODES_NUM;
956
957        bool renderNodesForViz = (mNodeVizMode == NODEVIZ_RENDER_NODES) ||
958                (mNodeVizMode == NODEVIZ_RENDER_NODES_AND_CONTENT);
959        bool renderNodesContentForViz = (mNodeVizMode == NODEVIZ_RENDER_NODES_AND_CONTENT);
960        //bool renderNodesContentForViz = mNodeVizMode == NODEVIZ_RENDER_GEOMETRY;
961
962        mSceneMgr->setOption("RenderNodesForViz", &renderNodesForViz);
963        mSceneMgr->setOption("RenderNodesContentForViz", &renderNodesContentForViz);
964}
965//-----------------------------------------------------------------------
966void TerrainFrameListener::keyPressed(KeyEvent* e)
967{
968        // hide exact visibility query overlay
969        if (mShowQueryStats)
970        {
971                mQueryOverlay->hide();
972                mShowQueryStats = false;
973        }
974
975        switch(e->getKey())
976        {
977        case KC_ESCAPE:
978                mShutdownRequested = true;
979                e->consume();
980                return;
981
982        case KC_SPACE:
983                nextAlgorithm();
984                break;
985       
986    case KC_F:
987                nextFilter();
988                break;
989        case KC_R:
990                nextSceneDetailLevel();
991                break;
992        case KC_P:
993                toggleDisplayCameraDetails();
994                break;
995        case KC_G:
996                toggleTestGeometryForVisibleLeaves();
997                break;
998        case KC_T:
999                toggleShowOctree();
1000                break;
1001        case KC_X:
1002                toggleUseDepthPass();
1003                break;
1004        case KC_S:
1005                toggleShowShadows();
1006                break;
1007
1008        case KC_I:
1009                mUseItemBuffer = !mUseItemBuffer;
1010                break;
1011
1012        case KC_C:
1013                mRenderPatchesForItemBuffer = !mRenderPatchesForItemBuffer;
1014                break;
1015
1016        case KC_SUBTRACT:
1017                changeThreshold(-10);
1018                break;
1019        case KC_ADD:
1020                changeThreshold(10);
1021                break;
1022
1023        //-- visualization
1024        case KC_1:
1025                toggleShowViz();
1026                break;
1027        case KC_2:
1028                nextNodeVizMode();
1029                break;
1030
1031        case KC_F1:
1032                toggleShowHelp();
1033                break;
1034        case KC_F2:
1035                toggleShowStats();
1036                break;
1037        case KC_F3:
1038                nextAppState();
1039                break;
1040        case KC_F4:
1041                toggleRecord();
1042                break;
1043        case KC_F5:
1044                applyVisibilityQuery(false, mShiftPressed, mUseItemBuffer);
1045                break;
1046        case KC_F6:
1047                applyVisibilityQuery(true, mShiftPressed, mUseItemBuffer);
1048                break;
1049       
1050        case KC_F7:
1051                setObjectType(++mCurrentObjectType);
1052                break;
1053        case KC_F8:
1054                mApplication->generateScene(500, mCurrentObjectType);
1055                break;
1056        case KC_F9:
1057                mUseAnimation = !mUseAnimation;
1058                break;
1059        case KC_F11:
1060                takeScreenshot();
1061                break;
1062        case KC_F12:
1063                mTerrainContentGenerator->WriteObjects(objects_out_filename);
1064                break;
1065
1066        case KC_8:
1067                changeAssumedVisibility(-1);
1068                break;
1069        case KC_9:
1070                changeAssumedVisibility(1);
1071                break;
1072        case KC_LSHIFT:
1073                mShiftPressed = true;
1074                break;
1075        case KC_DELETE:
1076                mDeleteObjects = true;
1077                break;
1078        //KEY_PRESSED(KC_F3, 0.3, writeFrames());
1079        //KEY_PRESSED(KC_F4, 0.3, loadFrames());
1080        default:
1081                break;
1082        }
1083
1084        CEGUI::System::getSingleton().injectKeyDown(e->getKey());
1085        CEGUI::System::getSingleton().injectChar(e->getKeyChar());
1086        e->consume();
1087}
1088//-----------------------------------------------------------------------
1089void TerrainFrameListener::keyReleased(KeyEvent* e)
1090{
1091        if (e->getKey() == KC_LSHIFT)
1092        {
1093                mShiftPressed = false;
1094        }
1095       
1096        CEGUI::System::getSingleton().injectKeyUp(e->getKey());
1097        e->consume();
1098}
1099//-----------------------------------------------------------------------
1100void TerrainFrameListener::keyClicked(KeyEvent* e)
1101{
1102        // Do nothing
1103        e->consume();
1104}
1105//-----------------------------------------------------------------------
1106void TerrainFrameListener::addFrameInfo(SceneNode *camNode, Real timeElapsed)
1107{
1108        frame_info info;
1109        info.orientation = mCamNode->getOrientation();
1110        info.position = mCamNode->getPosition();
1111        info.timeElapsed = timeElapsed;
1112
1113        mFrameInfo.push_back(info);
1114}
1115//-----------------------------------------------------------------------
1116void TerrainFrameListener::setCurrentFrameInfo(Real timeElapsed)
1117{
1118        //-- find current frame relative to elapsed frame time         
1119        mReplayTimeElapsed -= timeElapsed;
1120
1121        while ((mReplayTimeElapsed <= 0) && (mCurrentFrame < (int)mFrameInfo.size() - 1))
1122        {
1123                mReplayTimeElapsed += mFrameInfo[mCurrentFrame ++].timeElapsed;
1124        }
1125
1126        frame_info new_frame = mFrameInfo[mCurrentFrame];
1127        frame_info old_frame = mFrameInfo[mCurrentFrame - 1];
1128               
1129        //-- interpolate frames
1130        Real factor = 1;
1131
1132        if (old_frame.timeElapsed > 0)
1133        {
1134                factor = mReplayTimeElapsed / old_frame.timeElapsed;
1135        }
1136
1137        Vector3 camPos = old_frame.position + factor
1138                * (new_frame.position - old_frame.position);
1139        Quaternion camOrienation = Quaternion::Slerp(factor, old_frame.orientation,
1140                new_frame.orientation, true);
1141
1142        mCamNode->setPosition(camPos);
1143        mCamNode->setOrientation(camOrienation);
1144       
1145        // stop replay after a full walkthrough
1146        if (mCurrentFrame == (int)mFrameInfo.size() - 1)
1147        {
1148                nextAppState();
1149        }
1150}
1151//-----------------------------------------------------------------------   
1152bool TerrainFrameListener::processUnbufferedKeyInput(const FrameEvent& evt)
1153{
1154        bool cursorPressed = false;
1155       
1156        /* Move camera forward by keypress. */
1157    if (mInputDevice->isKeyDown(KC_UP))
1158        {
1159                mTranslateVector.z = -mMoveScale;
1160                cursorPressed = true;
1161        }
1162    /* Move camera backward by keypress. */
1163    if (mInputDevice->isKeyDown(KC_DOWN))
1164    {
1165                mTranslateVector.z = mMoveScale;
1166                cursorPressed = true;
1167    }
1168
1169    if (mInputDevice->isKeyDown(KC_RIGHT))
1170    {
1171        mCamNode->yaw(-mRotScale);
1172                cursorPressed = true;
1173    }
1174       
1175    if (mInputDevice->isKeyDown(KC_LEFT))
1176    {
1177        mCamNode->yaw(mRotScale);
1178                cursorPressed = true;
1179    }
1180        // visualization camera
1181        if (mInputDevice->isKeyDown(KC_3))
1182        {
1183                zoomVizCamera(50);
1184        }
1185        if (mInputDevice->isKeyDown(KC_4))
1186        {
1187                zoomVizCamera(-50);
1188        }
1189
1190        // show the results
1191        if (cursorPressed && mShowQueryStats)
1192        {
1193                mQueryOverlay->hide();
1194                mShowQueryStats = false;
1195        }
1196
1197    // Return true to continue rendering
1198    return true;
1199}
1200//-----------------------------------------------------------------------
1201void TerrainFrameListener::nextFilter()
1202{
1203        switch (mFiltering)
1204        {
1205        case TFO_BILINEAR:
1206                mFiltering = TFO_TRILINEAR;
1207                mAniso = 1;
1208                break;
1209        case TFO_TRILINEAR:
1210                mFiltering = TFO_ANISOTROPIC;
1211                mAniso = 8;
1212                break;
1213        case TFO_ANISOTROPIC:
1214                mFiltering = TFO_BILINEAR;
1215                mAniso = 1;
1216                break;
1217        default:
1218                break;
1219        }
1220
1221    MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
1222    MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);
1223
1224        // reload stats
1225    showStats(mStatsOn);
1226}
1227//-----------------------------------------------------------------------
1228void TerrainFrameListener::nextSceneDetailLevel()
1229{
1230        mSceneDetailIndex = (mSceneDetailIndex + 1) % 3;
1231        switch (mSceneDetailIndex)
1232        {
1233                case 0:
1234                        mCamera->setDetailLevel(SDL_SOLID);
1235                        break;
1236                case 1:
1237                        mCamera->setDetailLevel(SDL_WIREFRAME);
1238                        break;
1239                case 2:
1240                        mCamera->setDetailLevel(SDL_POINTS);
1241                        break;
1242        }
1243}
1244//-----------------------------------------------------------------------
1245void TerrainFrameListener::takeScreenshot()
1246{
1247        char tmp[20];
1248        sprintf(tmp, "screenshot_%d.png", ++mNumScreenShots);
1249    mWindow->writeContentsToFile(tmp);
1250    mWindow->setDebugText(String("Wrote ") + tmp);
1251}
1252//-----------------------------------------------------------------------
1253void TerrainFrameListener::toggleDisplayCameraDetails()
1254{
1255        mDisplayCameraDetails = !mDisplayCameraDetails;
1256       
1257    if (!mDisplayCameraDetails)
1258        {
1259                mWindow->setDebugText("");
1260        }
1261}
1262//-----------------------------------------------------------------------
1263void TerrainFrameListener::showStats(bool show)
1264{
1265        if (mDebugOverlay && mCullStatsOverlay)
1266        {
1267                if (show)
1268                {
1269                        mDebugOverlay->show();
1270                        mCullStatsOverlay->show();
1271                }
1272                else
1273                {
1274                        mDebugOverlay->hide();
1275                        mCullStatsOverlay->hide();
1276                }
1277        }
1278}
1279//-----------------------------------------------------------------------
1280void TerrainFrameListener::toggleShowStats()
1281{
1282        mStatsOn = !mStatsOn;
1283
1284        showStats(mStatsOn);
1285}
1286//-----------------------------------------------------------------------
1287void TerrainFrameListener::toggleShowHelp()
1288{
1289        mShowHelp = !mShowHelp;
1290
1291        if (mShowHelp)
1292        {
1293                mHelpOverlay->show();
1294        }
1295        else
1296        {
1297                mHelpOverlay->hide();
1298        }
1299}
1300//-----------------------------------------------------------------------
1301void TerrainFrameListener::initOverlayElement(OverlayElement **elInfo, String ext,
1302                                                                                          String name, int top, String caption)
1303{
1304        OverlayElement *el =
1305                OverlayManager::getSingleton().getOverlayElement(ext + name);
1306
1307        (*elInfo) = OverlayManager::getSingleton().getOverlayElement(ext + name + "Info");
1308        (*elInfo)->setCaption(caption);
1309
1310        el->setTop(top);
1311        (*elInfo)->setTop(top);
1312}
1313//-----------------------------------------------------------------------
1314void TerrainFrameListener::initHelpOverlayElement(String name, int top)
1315{
1316        OverlayElement *el = OverlayManager::getSingleton().getOverlayElement(
1317                "Example/Visibility/Help/" + name);
1318
1319        el->setTop(top);
1320}
1321//-----------------------------------------------------------------------
1322void TerrainFrameListener::initHelpOverlay()
1323{
1324        const int vert_space = 15;
1325        int top = 30;
1326
1327        initHelpOverlayElement("ShowHelp", top); top += vert_space;
1328        initHelpOverlayElement("Stats", top); top += vert_space;
1329        initHelpOverlayElement("AppState", top); top += vert_space;
1330        initHelpOverlayElement("Recorded", top); top += vert_space;
1331        initHelpOverlayElement("Animation", top); top += vert_space;
1332        initHelpOverlayElement("Screenshots", top); top += vert_space;
1333        initHelpOverlayElement("WriteOut", top); top += vert_space;
1334
1335        top +=vert_space;
1336        initHelpOverlayElement("SceneDetail", top); top += vert_space;
1337        initHelpOverlayElement("DisplayCameraDetails", top); top += vert_space;
1338        initHelpOverlayElement("DisplayOctree", top); top += vert_space;
1339        initHelpOverlayElement("UseShadows", top); top += vert_space;
1340        initHelpOverlayElement("Filter", top); top += vert_space;
1341
1342        //-- visualization
1343        top += vert_space;
1344        initHelpOverlayElement("VizSection", top); top += vert_space;
1345        initHelpOverlayElement("Viz", top); top += vert_space;
1346        initHelpOverlayElement("NextVizMode", top); top += vert_space;
1347        initHelpOverlayElement("ZoomViz", top); top += vert_space;
1348
1349
1350        //-- visibility queries
1351        top += vert_space;
1352        initHelpOverlayElement("VisQuery", top); top += vert_space;
1353        initHelpOverlayElement("FromCameraQuery", top); top += vert_space;
1354        initHelpOverlayElement("FromPointQuery", top); top += vert_space;
1355        initHelpOverlayElement("QueryType", top); top += vert_space;
1356        initHelpOverlayElement("QueryTarget", top); top += vert_space;
1357
1358        //-- object generation
1359        top += vert_space;
1360        initHelpOverlayElement("SceneObjects", top); top += vert_space;
1361        initHelpOverlayElement("GenerateObjects", top); top += vert_space;
1362        initHelpOverlayElement("RemoveObjects", top); top += vert_space;
1363        initHelpOverlayElement("DropObject", top); top += vert_space;
1364
1365        OverlayElement *helpPanel = OverlayManager::getSingleton().getOverlayElement(
1366                "Example/Visibility/Help/HelpPanel");
1367
1368        helpPanel->setHeight(top + 10);
1369}
1370//-----------------------------------------------------------------------
1371void TerrainFrameListener::initVisStatsOverlay()
1372{
1373        const int border_height = 10;
1374        const int vert_space = 15;
1375
1376        //-- visibility culling stats overlay
1377        int top = border_height;
1378
1379        String ext = "Example/Visibility/";
1380       
1381        initOverlayElement(&mAlgorithmInfo, ext, "Algorithm", top,
1382                ": " + msAlgorithmCaptions[mCurrentAlgorithm]); top += vert_space;
1383
1384        initOverlayElement(&mThresholdInfo, ext, "Threshold", top, ": 0"); top += vert_space;
1385        initOverlayElement(&mTestGeometryForVisibleLeavesInfo, ext,
1386                "TestGeometryForVisibleLeaves", top, ": true"); top += vert_space;
1387        initOverlayElement(&mUseDepthPassInfo, ext, "UseDepthPass", top, ": false"); top += vert_space;
1388        initOverlayElement(&mAssumedVisibilityInfo, ext, "AssumedVisibility", top, ": 0"); top += vert_space;
1389        initOverlayElement(&mCurrentObjectTypeInfo, ext, "CurrentObjectType", top, ": "); top += vert_space;
1390        //initOverlayElement(&mHelpInfo, ext, "Help", top, ": "); top += vert_space;
1391
1392        OverlayElement *optionsPanel = OverlayManager::getSingleton().
1393                getOverlayElement("Example/Visibility/VisibilityPanel");
1394
1395        optionsPanel->setHeight(top + border_height);
1396
1397        top = border_height;
1398        //ext = "Example/Visibility/";
1399        initOverlayElement(&mFrustumCulledNodesInfo, ext, "FrustumCulledNodes", top, ": 0"); top += vert_space;
1400        initOverlayElement(&mQueryCulledNodesInfo, ext, "QueryCulledNodes", top, ": 0"); top += vert_space;
1401        initOverlayElement(&mTraversedNodesInfo, ext, "TraversedNodes", top, ": 0"); top += vert_space;
1402        initOverlayElement(&mHierarchyNodesInfo, ext, "HierarchyNodes", top, ": 0"); top += vert_space;
1403        initOverlayElement(&mRenderedNodesInfo, ext, "RenderedNodes", top, ": 0"); top += vert_space;
1404        initOverlayElement(&mObjectsCountInfo, ext, "ObjectsCount", top, ": 0"); top += vert_space;
1405        initOverlayElement(&mQueriesIssuedInfo, ext, "QueriesIssued", top, ": 0"); top += vert_space;
1406
1407        OverlayElement *visPanel = OverlayManager::getSingleton().
1408                getOverlayElement("Example/Visibility/VisibilityStatsPanel");
1409
1410        visPanel->setHeight(top + border_height);
1411}
1412//-----------------------------------------------------------------------
1413void TerrainFrameListener::initQueryOverlay()
1414{
1415        const int border_height = 10;
1416        const int vert_space = 15;
1417
1418        //-- visibility culling stats overlay
1419        int top = border_height + 25;
1420
1421        String ext = "Example/Visibility/Query/";
1422           
1423        initOverlayElement(&mQueryTypeInfo , ext, "QueryType", top,     ": 0"); top += vert_space;
1424       
1425        initOverlayElement(&mQueryVisibleNodesInfo , ext, "VisibleNodes", top,  ": 0"); top += vert_space;
1426        initOverlayElement(&mQueryVisibleGeometryInfo , ext, "VisibleGeometry", top,    ": 0"); top += vert_space;
1427        initOverlayElement(&mQueryVisiblePatchInfo , ext, "VisiblePatches", top,        ": 0"); top += vert_space;
1428       
1429        initOverlayElement(&mQueryNodeVisibilityInfo , ext, "NodeVisibility", top,      ": 0"); top += vert_space;
1430        initOverlayElement(&mQueryGeometryVisibilityInfo , ext, "GeometryVisibility", top,      ": 0"); top += vert_space;
1431        initOverlayElement(&mQueryPatchVisibilityInfo , ext, "PatchVisibility", top,    ": 0"); top += vert_space;
1432
1433
1434        OverlayElement *queryPanel = OverlayManager::getSingleton().
1435                getOverlayElement("Example/Visibility/Query/QueryPanel");
1436
1437        queryPanel->setHeight(top + border_height);
1438}
Note: See TracBrowser for help on using the repository browser.