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

Revision 171, 42.6 KB checked in by mattausch, 19 years ago (diff)

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