source: GTP/trunk/App/Demos/Vis/HillyTerrain/OGRE/TerrainFrameListener.cpp @ 2168

Revision 2168, 57.2 KB checked in by mattausch, 17 years ago (diff)
Line 
1#include <OgreNoMemoryMacros.h>
2#include <CEGUI/CEGUI.h>
3#include <../CEGUIRenderer/include/OgreCEGUIRenderer.h>
4#include <../CEGUIRenderer/include/OgreCEGUIResourceProvider.h>
5#include <../CEGUIRenderer/include/OgreCEGUITexture.h>
6#include <OgreMemoryMacros.h>
7#include "TerrainFrameListener.h"
8#include "OgrePlatformQueryManager.h"
9#include "VisibilityInfo.h"
10#include "OgreOcclusionQueriesQueryManager.h"
11#include "TestCullingTerrainApplication.h"
12#include <string>
13
14//-- captions for overlays
15String TerrainFrameListener::msAlgorithmCaptions[] =
16{
17        "Coherent Hierarchical Culling",
18        "View Frustum Culling",
19        "Stop and Wait Culling",
20        "Standard Rendering"
21};
22
23//-- captions for overlays
24String TerrainFrameListener::msApprevAlgorithmCaptions[] =
25{
26        "CHC",
27        "VFC",
28        "SWC",
29        "DEF"
30};
31
32
33String TerrainFrameListener::msQueryTypeCaptions[] =
34{
35        "from camera",
36        "from viewpoint"
37};
38
39String TerrainFrameListener::msQueryRelativeVisCaptions[] =
40{
41        "visible pixels",
42        "relative visibility"
43};
44
45String TerrainFrameListener::msQueryMethodCaptions[] =
46{
47        "occlusion queries",
48        "item buffer"
49};
50
51Real TerrainFrameListener::msObjectTerrainOffsets[] =
52{
53        0,
54        -0.1,
55        //7,
56        0
57};
58
59Real TerrainFrameListener::msObjectScales[] =
60{
61        0.07,
62        0.03,
63        //0.1,
64        0.03
65};
66
67String TerrainFrameListener::msObjectCaptions[] =
68{
69        "robot",
70        "athene",
71        "natFX_Tree1_LOD2",
72        //"tree2",
73        //"HongKong_Tower",
74        "ninja"
75        //"ogrehead"
76};
77
78// output file for frame info
79const char* frames_out_filename = "frame.out";
80// output file for object positions / orientations
81const char* objects_out_filename = "objects.out";
82       
83std::ofstream video_out("video.lst");
84
85// if we are recording a demo
86static const bool DEMO_HACK = false;
87
88//using namespace GtpVisibility;
89
90//-----------------------------------------------------------------------
91TerrainFrameListener::TerrainFrameListener(RenderWindow* win, Camera* cam,
92                                                                                   SceneManager *sceneManager,
93                                                                                   CEGUI::Renderer *renderer,
94                                                                                   TerrainContentGenerator *sceneGenerator,
95                                                                                   Camera *vizCamera,
96                                                                                   SceneNode *camNode,
97                                                                                   Light *sunLight,
98                                                                                   TestCullingTerrainApplication *app):
99mCamera(cam),
100mWindow(win),
101mNumScreenShots(0),
102mTimeDelay(0),
103mSceneDetailIndex(0),
104mMoveScale(0.0f),
105mRotScale(0.0f),
106mTranslateVector(Vector3::ZERO),
107mAniso(1),
108mFiltering(TFO_BILINEAR),
109mGUIRenderer(renderer),
110mSceneMgr(sceneManager),
111mCurrentObject(NULL),
112mTerrainContentGenerator(sceneGenerator),
113mVisibilityThreshold(0),
114mAssumedVisibility(0),
115mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING),
116mNodeVizMode(NODEVIZ_NONE),
117mVizCameraHeight(Real(2000.0)),
118mCamNode(camNode),
119mAppState(WALKTHROUGH),
120mCurrentFrame(0),
121mReplayTimeElapsed(0),
122mRotateSpeed(72),
123mMoveSpeed(50),
124mVizCamera(vizCamera),
125mStatsOn(true),
126mShutdownRequested(false),
127mLMouseDown(false),
128mRMouseDown(false),
129mShowOctree(false),
130mShowViewCells(false),
131mUseDepthPass(false),
132mTestGeometryForVisibleLeaves(false),
133mShowVisualization(false),
134mCullCamera(false),
135mRecordFrames(false),
136mShowShadows(false),
137mShowHelp(false),
138mDisplayCameraDetails(false),
139mVisualizeCulledNodes(false),
140mSunLight(sunLight),
141mShiftPressed(false),
142mShowQueryStats(false),
143mQueryManager(NULL),
144mVisibilityManager(NULL),
145mDelayedQueriesIssued(0.0),
146mDelayedTraversedNodes(0.0),
147mCurrentObjectType(0),
148mApplication(app),
149mUseAnimation(false),
150mDeleteObjects(false),
151mUseItemBuffer(false),
152mItemBufferMode(GtpVisibility::QueryManager::PATCH_VISIBILITY),
153mRecordVideo(false),
154mPureRenderTimeFps(0.0),
155mNumVideoFrames(0),
156mPrecomputedFps(0),
157mRecordDemo(false),
158mSavePrecomputedFps(false),
159mUseBufferedInputMouse(false),
160mVizScale(25),
161mUseViewCells(false),
162mViewCellsLoaded(false),
163mUseVisibilityFilter(false),
164mFloorDist(2),
165mFlushQueue(false)
166{
167        //mInputDevice = PlatformManager::getSingleton().createInputReader();
168        //mInputDevice->initialise(win, true, true);
169
170        mEventProcessor = new EventProcessor();
171       
172        mEventProcessor->initialise(win);
173        mEventProcessor->startProcessingEvents();
174        mEventProcessor->addMouseListener(this);
175        mEventProcessor->addMouseMotionListener(this);
176        mEventProcessor->addKeyListener(this);
177
178        mInputDevice = mEventProcessor->getInputReader();       
179
180        mInputDevice->setBufferedInput(true, mUseBufferedInputMouse);
181
182        // create ray query executor, used to place objects in terrain
183        mRayQueryExecutor = new RayQueryExecutor(mSceneMgr);
184       
185
186        //////////
187        //-- overlays
188       
189        mDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay");
190        mHelpOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/HelpOverlay");
191        mQueryOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/QueryOverlay");
192        mCullStatsOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/CullStatsOverlay");
193
194        String ext = "Example/Visibility/";
195
196        //-- overlays
197   
198        initVisStatsOverlay(); // visibility stats overlay
199        initHelpOverlay();     // help overlay
200        initQueryOverlay();    // visibility query stats overlay
201       
202        // show stats overlays
203        if (!DEMO_HACK)
204        {
205                showStats(true);
206        }
207        else
208        {
209                mMyStatsOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/MyStatsOverlay");
210                mMyStatsAlgorithmInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/MyAlgorithmInfo");
211                mMyStatsAlgorithmInfo->setCaption("");
212       
213                const int top = 10;
214                mMyStatsAlgorithmInfo->setTop(top);
215
216                char str[100]; sprintf(str,": %d", 0);
217                mMyStatsFpsInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/MyFpsInfo");
218                mMyStatsFpsInfo->setCaption(str);
219
220                mMyStatsOverlay->show();
221        }
222
223        // loading view cells overlay
224        mLoadingOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/LoadingOverlay");
225        mMyLoadingInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/Loading/MyLoadingInfo");
226        mMyLoadingInfo->setCaption("loading view cells ...");
227
228        mLoadingOverlay->hide();
229
230        // note: larger magnification for terrain to show single objects
231        if (TestCullingTerrainApplication::msShowHillyTerrain)
232                mVizScale = 25;
233        else
234                mVizScale = 1;
235
236        // the scale factor for the visualized bounding boxes
237        mSceneMgr->setOption("NodeVizScale", &mVizScale);
238       
239        /////////
240        //-- set the current culling algorithm type
241        //setAlgorithm(mApplication->mAlgorithm);
242
243        bool isNormalExecution;
244               
245        mSceneMgr->getOption("NormalExecution", &isNormalExecution);
246        if (isNormalExecution)
247        {
248                // no algorithm
249                mCurrentAlgorithm =
250                        GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS;
251        }
252        else
253        {
254                mSceneMgr->getOption("Algorithm", &mCurrentAlgorithm);
255        }
256       
257        applyCurrentAlgorithm();
258       
259        ///////////////////////////////
260
261        // set scene manager options
262        setTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves);
263
264        //mSceneMgr->setOption("UseDepthPass", &mUseDepthPass);
265        mSceneMgr->getOption("UseDepthPass", &mUseDepthPass);
266
267        if (mUseDepthPass)
268                mUseDepthPassInfo->setCaption(": true");
269        else
270                mUseDepthPassInfo->setCaption(": false");
271       
272        mSceneMgr->getOption("FlushQueue", &mFlushQueue);
273       
274        if (mFlushQueue)
275                LogManager::getSingleton().logMessage("initial setting: flushing queue");
276        else
277                LogManager::getSingleton().logMessage("initial setting: not flushing queue");
278
279        mSceneMgr->setOption("ShowOctree", &mShowOctree);
280        mSceneMgr->setOption("ShowViewCells", &mShowViewCells);
281        mSceneMgr->setOption("CullCamera", &mCullCamera);
282        mSceneMgr->setOption("PrepareVisualization", &mShowVisualization);
283       
284        applyObjectType();
285
286        // initialise timer
287        mTimer = Root::getSingleton().getTimer();
288        mTimeFrameEnded = mTimeFrameStarted = mTimer->getMilliseconds();
289       
290        if (0 && (mSceneMgr->getSceneNode("robot Entity1Node")->
291                getAttachedObject(0)->getMovableType() == "Entity"))
292                Ogre::LogManager::getSingleton().logMessage("found entity");
293
294        // init view cell parameters
295        //mSceneMgr->setOption("UseViewCells", &mUseViewCells);
296        mSceneMgr->setOption("UseVisibilityFilter", &mUseVisibilityFilter);
297
298        // reset statistics
299        mWalkthroughStats.Reset();
300
301}
302//-----------------------------------------------------------------------
303void TerrainFrameListener::switchMouseMode()
304{
305        mUseBufferedInputMouse = !mUseBufferedInputMouse;
306        mInputDevice->setBufferedInput(true, mUseBufferedInputMouse);
307
308        if (!mUseBufferedInputMouse)
309                CEGUI::MouseCursor::getSingleton().hide();
310        else
311                CEGUI::MouseCursor::getSingleton().show();
312}
313//-----------------------------------------------------------------------
314TerrainFrameListener::~TerrainFrameListener()
315{
316        OGRE_DELETE(mRayQueryExecutor);
317        OGRE_DELETE(mEventProcessor);
318        OGRE_DELETE(mQueryManager);
319}
320//-----------------------------------------------------------------------
321void TerrainFrameListener::mouseMoved(MouseEvent *e)
322{
323        // Update CEGUI with the mouse motion
324    CEGUI::System::getSingleton().injectMouseMove(e->getRelX() *
325                mGUIRenderer->getWidth(), e->getRelY() * mGUIRenderer->getHeight());
326}
327//-----------------------------------------------------------------------
328void TerrainFrameListener::mousePressed(MouseEvent* e)
329{
330        // Left mouse button down
331        if (e->getButtonID() & InputEvent::BUTTON0_MASK)
332        {
333                CEGUI::MouseCursor::getSingleton().hide();
334
335                // Setup the ray scene query
336                Ray mouseRay = mCamera->getCameraToViewportRay(e->getX(), e->getY());
337                Real val = Math::RangeRandom(0, 360); // random rotation
338
339                // get results, create a node/entity on the position
340                mCurrentObject =
341                        mTerrainContentGenerator->GenerateSceneObject(mouseRay.getOrigin(),
342                                                                                                                  Vector3(val, 0, 0),
343                                                                                                                  msObjectCaptions[mCurrentObjectType]);
344               
345                mLMouseDown = true;
346        }
347        // Right mouse button down
348        /*else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
349        {
350         CEGUI::MouseCursor::getSingleton().hide();
351         mRMouseDown = true;
352        }*/
353}
354//-----------------------------------------------------------------------
355void TerrainFrameListener::mouseDragDropped(MouseEvent* e)
356{
357        // Left mouse button up
358    if (e->getButtonID() & InputEvent::BUTTON0_MASK)
359    {
360                CEGUI::MouseCursor::getSingleton().show();
361               
362            mLMouseDown = false;
363    }
364    // Right mouse button up
365    else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
366    {
367        CEGUI::MouseCursor::getSingleton().show();
368
369                mRMouseDown = false;
370    }
371}
372//-----------------------------------------------------------------------
373void TerrainFrameListener::mouseReleased(MouseEvent* e)
374{
375    // Left mouse button up
376    if (e->getButtonID() & InputEvent::BUTTON0_MASK)
377    {
378                CEGUI::MouseCursor::getSingleton().show();
379               
380                // start animation: only robot has animation phases
381                if (mCurrentObject && (mCurrentObjectType == TestCullingTerrainApplication::ROBOT))
382                {
383                        // HACK: not neccesary the last element
384                        Entity *ent = mTerrainContentGenerator->GetGeneratedEntities()->back();
385                        EntityState *entState = new EntityState(ent, EntityState::MOVING, Math::RangeRandom(0.5, 1.5));
386                        mApplication->getEntityStates().push_back(entState);
387                }
388
389            mLMouseDown = false;
390    }
391    // Right mouse button up
392    else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
393    {
394        CEGUI::MouseCursor::getSingleton().show();
395
396        mRMouseDown = false;
397    }
398}
399//-----------------------------------------------------------------------
400void TerrainFrameListener::mouseDragged(MouseEvent *e)
401{
402        // If we are dragging the left mouse button.             
403        if (mLMouseDown)
404    {
405                if (!mCurrentObject)
406                        return;
407
408                Vector3 queryResult;
409                Ray mouseRay = mCamera->getCameraToViewportRay(e->getX(), e->getY());
410
411                if (mRayQueryExecutor->executeRayQuery(&queryResult, mouseRay))
412                {
413                        // apply offset so object is ON terrain
414                        queryResult.y += msObjectTerrainOffsets[mCurrentObjectType];
415                        mCurrentObject->setPosition(queryResult);
416                }
417        }
418}
419//-----------------------------------------------------------------------
420bool TerrainFrameListener::frameStarted(const FrameEvent &evt)
421{
422        if (mWindow->isClosed())
423        {
424        return false;
425        }
426       
427        if (mDeleteObjects)
428        {
429                mApplication->deleteEntityStates();
430                mTerrainContentGenerator->RemoveGeneratedObjects();
431                mDeleteObjects = false;
432        }
433
434        if (mUseAnimation)
435        {
436                // update animation phases
437                mApplication->updateAnimations(evt.timeSinceLastFrame);
438        }
439
440        if (mDisplayCameraDetails)  // Print camera details
441    {       
442        mWindow->setDebugText("P: " + StringConverter::toString(mCamera->getDerivedPosition()) +
443                        " " + "O: " + StringConverter::toString(mCamera->getDerivedOrientation()));
444    }
445
446        //-- setup what is needed for immediate mouse/key movement
447        if (mTimeDelay >= 0)
448        {
449                mTimeDelay -= evt.timeSinceLastFrame;
450        }
451       
452        // If this is the first frame, pick a speed
453        if (evt.timeSinceLastFrame == 0)
454        {
455                mMoveScale = 1;
456                mRotScale = 0.1;
457        }
458        // Otherwise scale movement units by time passed since last frame
459        else
460        {
461                // Move about 100 units per second,
462                mMoveScale = mMoveSpeed * evt.timeSinceLastFrame;
463                // Take about 10 seconds for full rotation
464                mRotScale = mRotateSpeed * evt.timeSinceLastFrame;
465        }
466
467        mRotX = 0;
468        mRotY = 0;
469        mTranslateVector = Vector3::ZERO;
470
471        if (!processUnbufferedKeyInput(evt))
472        {
473                return false;
474        }
475        if (!mUseBufferedInputMouse)
476        {
477                if (!processUnbufferedMouseInput(evt))
478                {       
479                        return false;   
480                }
481        }
482
483        if (mShowVisualization)
484        {
485                ////////////////
486                //-- set parameters for visualization
487
488                // important for visualization => draw octree bounding boxes
489                if (0)
490                        mSceneMgr->setOption("ShowOctree", &mShowVisualization);
491               
492                ///////////////
493                //-- setup visualization camera
494
495                mVizCamera->setPosition(0, 0, 0);
496                mVizCamera->setOrientation(Quaternion::IDENTITY);
497
498                Vector3 camPos = mCamNode->getPosition();
499                mVizCamera->setPosition(camPos.x, mVizCameraHeight, camPos.z);
500
501                // point down -Z axis
502                mVizCamera->pitch(Radian(Degree(270.0)));
503
504                // rotation arounnd X axis
505                mVizCamera->yaw(Math::ATan2(-mCamera->getDerivedDirection().x,
506                        -mCamera->getDerivedDirection().z));
507               
508                const float moveFactor = 200;
509                // move by a constant so view plane is on bottom of viewport
510                mVizCamera->moveRelative(Vector3(0, moveFactor, 0));
511        }
512        else
513        {
514                // frame start time
515                mTimeFrameStarted = mTimer->getMilliseconds();
516        }
517
518        //////////////
519        //-- set application state
520
521        switch (mAppState)
522        {
523        case REPLAY:
524                /// set the current camera data to loaded frame information
525                setCurrentFrameInfo(evt.timeSinceLastFrame);
526
527                // HACK for demo: save new frame rates for different methods on the
528                // same walkthrough
529                if (mSavePrecomputedFps)
530                {
531                        addFrameInfo(mPrecomputedFpsFrameInfo, mCamNode, evt.timeSinceLastFrame);
532                }
533
534                break;
535        case WALKTHROUGH:
536                //-- recording the camera settings per frame
537                if (mRecordFrames)
538                {
539                        addFrameInfo(mFrameInfo, mCamNode, evt.timeSinceLastFrame);
540                        // print recording message
541                        mWindow->setDebugText("Recording frame " +
542                                StringConverter::toString((int)mFrameInfo.size() - 1));
543                }       
544                // move camera according to input
545                moveCamera();
546
547                // clamp camera so we always walk along the terrain
548                if (TestCullingTerrainApplication::msShowHillyTerrain)
549                {
550                        mApplication->Clamp2Terrain(mCamNode, 5);
551                        //Ogre::LogManager::getSingleton().logMessage("clamp to terrain");
552                }
553                else
554                {
555                        mApplication->Clamp2FloorPlane(mFloorDist);
556                        //Ogre::LogManager::getSingleton().logMessage("clamp to floor");
557                }
558
559                break;
560
561        default:
562                Ogre::LogManager::getSingleton().logMessage("should not come here");
563                break;
564        };     
565
566        return true;
567}
568//-----------------------------------------------------------------------
569void TerrainFrameListener::applyVisibilityQuery(bool fromPoint,
570                                                                                                bool relativeVisibility,
571                                                                                                bool useItemBuffer)
572{Ogre::LogManager::getSingleton().logMessage("here225");
573        int itemBufferMode = useItemBuffer ? mItemBufferMode : 0;
574       
575        int queryModes = 0;
576        queryModes |= GtpVisibility::QueryManager::PATCH_VISIBILITY;
577        queryModes |= GtpVisibility::QueryManager::GEOMETRY_VISIBILITY;
578        queryModes |= GtpVisibility::QueryManager::NODE_VISIBILITY;
579
580        // no visibility manager available => no visibility scene manager, return
581        GtpVisibility::VisibilityManager *visManager = NULL;
582       
583        if (!mSceneMgr->getOption("VisibilityManager", &visManager))
584        {
585                Ogre::LogManager::getSingleton().logMessage("no vismanager found");
586                return;
587        }
588        GtpVisibility::HierarchyInterface *hierarchyInterface = NULL;
589        if (!mSceneMgr->getOption("HierarchyInterface", &hierarchyInterface))
590        {
591                Ogre::LogManager::getSingleton().logMessage("no hierarchy interface found");
592                return;
593        }
594Ogre::LogManager::getSingleton().logMessage("here663");
595        mQueryManager = new OcclusionQueriesQueryManager(hierarchyInterface,
596                        mWindow->getViewport(0), queryModes, itemBufferMode);
597Ogre::LogManager::getSingleton().logMessage("here6699");
598        //mQueryManager = new PlatformQueryManager(sm->GetHierarchyInterface(), mWindow->getViewport(0), false);
599
600
601        visManager->SetQueryManager(mQueryManager);
602
603        GtpVisibility::NodeInfoContainer visibleNodes;
604        GtpVisibility::MeshInfoContainer visibleGeometry;
605        GtpVisibility::PatchInfoContainer visiblePatches;
606Ogre::LogManager::getSingleton().logMessage("here999");
607
608        if (fromPoint)
609        {Ogre::LogManager::getSingleton().logMessage("her11e5");
610                mQueryManager->
611                        ComputeFromPointVisibility(mCamNode->getPosition(), &visibleNodes,
612                                                                           &visibleGeometry, &visiblePatches, relativeVisibility);
613        }
614        else
615        {
616                Ogre::LogManager::getSingleton().logMessage("here995");
617                mQueryManager->ComputeCameraVisibility(*mCamera,
618                            &visibleNodes, &visibleGeometry, &visiblePatches, relativeVisibility);
619        }
620               
621        std::stringstream d;
622        d << "Query mode: " << queryModes << ", "
623          << msQueryTypeCaptions[fromPoint ?  1 : 0].c_str() << " "
624          << msQueryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str() << " "
625      << msQueryMethodCaptions[useItemBuffer ? 1 : 0].c_str();
626        LogManager::getSingleton().logMessage(d.str());
627
628
629        float averageNodeVis = 0, averageGeometryVis = 0, averagePatchVis = 0;
630        int geomSize = 0, nodesSize = 0, patchSize = 0;
631
632        ///////////////////////////////////////////////////////////////////////////
633        //-- apply queries on geometry level
634
635        GtpVisibility::MeshInfoContainer::iterator geomIt, geomIt_end = visibleGeometry.end();
636
637        for (geomIt = visibleGeometry.begin(); geomIt != geomIt_end; ++geomIt)
638        {
639                // add if not 0
640                if ((*geomIt).GetVisiblePixels())
641                {
642                        float vis = relativeVisibility ?
643                                (*geomIt).ComputeRelativeVisibility() : (float)(*geomIt).GetVisiblePixels();
644       
645                        averageGeometryVis += vis;
646                        ++ geomSize;
647                       
648                        std::stringstream d;
649                        d << "Geometry " << geomSize << " id: " << (*geomIt).GetSource()->getSubEntity(0)->getId()
650                          << " visibility: "  << (*geomIt).GetVisiblePixels() << ", " << (*geomIt).GetProjectedPixels();
651                        LogManager::getSingleton().logMessage(d.str());
652                }
653        }
654
655
656
657        ///////////////////////////////////////////////////////////////////////////
658        //-- apply queries on node level
659
660
661        GtpVisibility::NodeInfoContainer::iterator nodesIt, nodesIt_end = visibleNodes.end();
662
663        for (nodesIt = visibleNodes.begin(); nodesIt != nodesIt_end; ++nodesIt)
664        {
665                // add if not 0
666                if ((*nodesIt).GetVisiblePixels())
667                {
668                        float vis = relativeVisibility ?
669                                (*nodesIt).ComputeRelativeVisibility() : (float)(*nodesIt).GetVisiblePixels();
670               
671                        averageNodeVis += vis;
672                        ++ nodesSize;
673
674                        std::stringstream d; d << "Node visibility: " << vis;
675                        LogManager::getSingleton().logMessage(d.str());
676                }       
677        }
678
679
680        ///////////////////////////////////////////////////////////////////////////
681        //-- apply queries on patch level
682
683
684        GtpVisibility::PatchInfoContainer::iterator patchIt, patchIt_end = visiblePatches.end();
685
686        for (patchIt = visiblePatches.begin(); patchIt != patchIt_end; ++ patchIt)
687        {
688                // add if not 0
689                if ((*patchIt).GetVisiblePixels())
690                {
691                        float vis = relativeVisibility ?
692                                (*patchIt).ComputeRelativeVisibility() : (float)(*patchIt).GetVisiblePixels();
693               
694                        averagePatchVis += vis;
695                        ++ patchSize;
696
697                        std::stringstream d; d << "Patch visibility: " << vis;
698                        LogManager::getSingleton().logMessage(d.str());
699                }       
700        }
701
702        ///////////////////////////////////////////////////////////////
703        //-- update visibility queries stats
704
705        if (nodesSize)
706                averageNodeVis /= (float)nodesSize;
707        if (geomSize)
708                averageGeometryVis /= (float)geomSize;
709        if (patchSize)
710                averagePatchVis /= (float)patchSize;
711
712
713    try
714        {
715                char str[100];
716               
717                sprintf(str, ": %s, %s, %s",
718                                msQueryTypeCaptions[fromPoint ?  1 : 0].c_str(),
719                                msQueryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str(),
720                                msQueryMethodCaptions[useItemBuffer ? 1 : 0].c_str());
721
722                mQueryTypeInfo->setCaption(str);
723
724                sprintf(str, ": %d", (int)nodesSize);
725                mQueryVisibleNodesInfo->setCaption(str);
726       
727                sprintf(str,": %d", (int)geomSize);
728                mQueryVisibleGeometryInfo->setCaption(str);
729               
730                sprintf(str,": %d", (int)patchSize);
731                mQueryVisiblePatchInfo->setCaption(str);
732
733                sprintf(str,": %3.3f", averageNodeVis);
734                mQueryNodeVisibilityInfo->setCaption(str);
735
736                sprintf(str,": %3.3f", averageGeometryVis);
737                mQueryGeometryVisibilityInfo->setCaption(str);
738
739                sprintf(str,": %3.3f", averagePatchVis);
740                mQueryPatchVisibilityInfo->setCaption(str);
741        }
742        catch (...)
743        {
744                // ignore
745        }
746
747        // show the results
748        if (!mShowQueryStats && !mShowHelp)
749        {
750                mQueryOverlay->show();
751                mShowQueryStats = true;
752        }
753
754        delete mQueryManager;
755}
756
757
758bool TerrainFrameListener::processUnbufferedMouseInput(const FrameEvent& evt)
759{
760        /* Rotation factors, may not be used if the second mouse button is pressed. */
761
762    /* If the second mouse button is pressed, then the mouse movement results in
763       sliding the camera, otherwise we rotate. */
764    if (mInputDevice->getMouseButton(1))
765    {
766                mTranslateVector.x += mInputDevice->getMouseRelativeX() * 0.13;
767                mTranslateVector.y -= mInputDevice->getMouseRelativeY() * 0.13;
768        }
769        else
770        {
771                mRotX = Degree(-mInputDevice->getMouseRelativeX() * 0.13);
772                mRotY = Degree(-mInputDevice->getMouseRelativeY() * 0.13);
773        }
774
775        return true;
776}
777//-----------------------------------------------------------------------
778bool TerrainFrameListener::frameEnded(const FrameEvent& evt)
779{
780        if (mShutdownRequested)
781                return false;
782
783        // timer end time
784        if (!mShowVisualization)
785        {
786                mTimeFrameEnded = mTimer->getMilliseconds();
787        }
788
789    updateStats();
790
791        if (mRecordVideo) // record current frame
792        {
793                takeVideoFrame(video_out);
794        }
795
796        //-- IMPORTANT: must be set, otherwise terrain is not rendered correctly
797        mSceneMgr->endFrame();
798
799        if (mTimeDelay <= 0) // simulates approx. one second
800                mTimeDelay = 1.0;
801
802        return true;
803}
804//-----------------------------------------------------------------------
805void TerrainFrameListener::moveCamera()
806{
807        // move node rather than camera so orientation is right in the visualization
808        mCamNode->yaw(mRotX, Ogre::Node::TS_WORLD);
809        //mCamNode->rotate(Vector3(0,1,0), mRotX, Ogre::Node::TS_WORLD);
810        mCamNode->pitch(mRotY);
811
812        mCamNode->translate(mCamNode->getLocalAxes(), mTranslateVector);
813}
814//-----------------------------------------------------------------------
815void TerrainFrameListener::writeFrames(const std::string filename,
816                                                                           const FrameInfoContainer &frameInfo) const
817{
818        std::ofstream ofstr(filename.c_str());
819        std::vector<frame_info>::const_iterator it, it_end;
820        it_end = frameInfo.end();
821
822        int i = 0;
823
824        for (it = frameInfo.begin(); it < it_end; ++ it, ++ i)
825        {
826                ofstr << StringConverter::toString((*it).position) << " "
827                          << StringConverter::toString((*it).orientation) << " "
828                          << StringConverter::toString((*it).timeElapsed) << " "
829                          << StringConverter::toString((*it).fps) << "\n";
830        }
831
832        std::stringstream d; d << "saved " << i << " frames to file " << filename;
833        Ogre::LogManager::getSingleton().logMessage(d.str());
834
835        ofstr.close();
836}
837//-----------------------------------------------------------------------
838void TerrainFrameListener::loadFrames(const std::string filename, 
839                                                                          FrameInfoContainer &frameInfo)
840{
841        std::ifstream ifstr(filename.c_str());
842        char line[256];
843        frame_info info;
844
845        // reset current values
846        frameInfo.clear();
847       
848        mCurrentFrame = 0;
849        int i = 0;
850        while (!ifstr.eof())
851        {
852                ifstr.getline(line, 256);
853                sscanf(line, "%f %f %f %f %f %f %f %f %f", &info.position.x, &info.position.y, &info.position.z,
854                           &info.orientation.w, &info.orientation.x, &info.orientation.y, &info.orientation.z,
855                           &info.timeElapsed, &info.fps);
856               
857                mFrameInfo.push_back(info);
858               
859                // std::stringstream d; d << StringConverter::toString(info.position) << " " << StringConverter::toString(info.orientation);
860                // LogManager::getSingleton().logMessage(d.str());
861                ++ i;
862        }
863       
864        std::stringstream d;
865        d << "loaded " << i << " frames from file " << filename;
866        Ogre::LogManager::getSingleton().logMessage(d.str());
867
868        ifstr.close();
869}
870//-----------------------------------------------------------------------
871void TerrainFrameListener::nextAppState()
872{
873        mCurrentFrame = 0;
874        int lastState = mAppState;
875
876        // transition to the next state
877        mAppState = (mAppState + 1) % STATE_NUM;
878
879        // if last state was replay state: post process
880        if (lastState == REPLAY)
881        {
882        // reset debug text
883                mWindow->setDebugText("");
884                               
885                // hack for producing demo:
886                // we produced precomputed fps during the last replay =>
887                // save them to file
888                if (mSavePrecomputedFps) //!mPrecomputedFpsFrameInfo.empty())
889                {
890                        std::string filename = msApprevAlgorithmCaptions[mCurrentAlgorithm] + "_frames.out";
891
892                        writeFrames(filename, mPrecomputedFpsFrameInfo);
893                        mPrecomputedFpsFrameInfo.clear();
894                }
895
896                std::stringstream d;
897                mWalkthroughStats.Print(d, msApprevAlgorithmCaptions[mCurrentAlgorithm]);
898               
899                LogManager::getSingleton().logMessage(d.str());
900        }
901       
902        //-- replay recorded walkthrough
903        if (mAppState == REPLAY)
904        {
905                // no standard recording during replay
906                mRecordFrames = false;
907
908                // no stats information
909                mWindow->setDebugText("");
910
911                // clear previous walktrough
912                mFrameInfo.clear();
913
914                std::string filename;
915               
916                // if recording demo,
917                // we use precomputed fps which corresponds to current method,
918                // e.g., for chc we load precomputed chc fps from disc.
919                if (mRecordDemo)
920                {
921                        filename = msApprevAlgorithmCaptions[mCurrentAlgorithm] + "_frames.out";
922                }
923                else // standard filename
924                {
925                        filename = frames_out_filename;
926                }
927
928                //-- load recorded walkthrough from disk
929                loadFrames(filename, mFrameInfo);
930               
931               
932                // if there are still no recorded frames,
933                // no walkthrough was recorded => set next state
934                if (mFrameInfo.empty())
935                {
936                        nextAppState();
937                }
938                else // actual replay
939                {
940                        mWindow->setDebugText("Replay");
941                       
942                        // reset, because we measure fps stats during walkthrough
943                        // (warning: average fps broken)
944                        mWindow->resetStatistics();
945                        mWalkthroughStats.Reset();
946
947                        //-- initialise frame data
948                        mReplayTimeElapsed = 0;
949
950                        mCamNode->setPosition(mFrameInfo[0].position);
951                        mCamNode->setOrientation(mFrameInfo[0].orientation);
952                }
953        }
954
955}
956//-----------------------------------------------------------------------
957void TerrainFrameListener::toggleRecord()
958{
959        mRecordFrames = !mRecordFrames;
960
961        if (mRecordFrames)
962        {
963                // starting new recording => clear old frame info
964                mFrameInfo.clear();
965        }
966        else // recording just ended => write frame info to file
967        {
968                writeFrames(frames_out_filename, mFrameInfo);
969                mWindow->setDebugText("");
970        }
971}
972//-----------------------------------------------------------------------
973void TerrainFrameListener::changeThreshold(int incr)
974{
975        mVisibilityThreshold += incr;
976
977        if (mVisibilityThreshold < 0)
978        {
979                mVisibilityThreshold = 0;
980        }
981
982        char str[100]; sprintf(str,": %d", mVisibilityThreshold);
983
984        mSceneMgr->setOption("Threshold", &mVisibilityThreshold);
985        mThresholdInfo->setCaption(str);
986}
987//-----------------------------------------------------------------------
988void TerrainFrameListener::changeAssumedVisibility(int incr)
989{
990        mAssumedVisibility += incr;
991
992        if (mAssumedVisibility < 0)
993        {       
994                mAssumedVisibility = 0;
995        }
996
997        char str[100]; sprintf(str,": %d", mAssumedVisibility);
998
999        mSceneMgr->setOption("AssumedVisibility", &mAssumedVisibility);
1000        mAssumedVisibilityInfo->setCaption(str);
1001}
1002//-----------------------------------------------------------------------
1003void TerrainFrameListener::changeVizScale(const int incr)
1004{
1005        mVizScale += incr;
1006
1007        if (mVizScale < 1)
1008        {       
1009                mVizScale = 1;
1010        }
1011
1012        mSceneMgr->setOption("NodeVizScale", &mVizScale);
1013}
1014//-----------------------------------------------------------------------
1015void TerrainFrameListener::changeFloorDist(const float incr)
1016{
1017        mFloorDist += incr;
1018
1019        if (mFloorDist < 2)
1020        {       
1021                mFloorDist = 2;
1022        }
1023}
1024//-----------------------------------------------------------------------
1025void TerrainFrameListener::zoomVizCamera(int zoom)
1026{
1027        mVizCameraHeight += zoom;
1028
1029        if(mVizCameraHeight < 0)
1030                mVizCameraHeight = 0;
1031}
1032//-----------------------------------------------------------------------
1033void TerrainFrameListener::nextAlgorithm()
1034{
1035        // possible algorithms: 3 culling algorithms + standard rendering
1036        mCurrentAlgorithm = (mCurrentAlgorithm + 1) %
1037                (GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS + 1);
1038        applyCurrentAlgorithm();
1039}
1040//-----------------------------------------------------------------------
1041void TerrainFrameListener::applyObjectType()
1042{
1043        if (mCurrentObjectType >= 3) // TODO: define a constant
1044                mCurrentObjectType = 0;
1045
1046        // parameters for new object
1047        mTerrainContentGenerator->SetOffset(msObjectTerrainOffsets[mCurrentObjectType]);
1048        Real scale = msObjectScales[mCurrentObjectType];
1049        mTerrainContentGenerator->SetScale(Vector3(scale, scale, scale));
1050
1051        mCurrentObjectTypeInfo->setCaption(": " + msObjectCaptions[mCurrentObjectType]);
1052}
1053//-----------------------------------------------------------------------
1054void TerrainFrameListener::applyCurrentAlgorithm()
1055{
1056        bool isNormalExecution;
1057       
1058        if (mCurrentAlgorithm < GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS)
1059        {
1060                isNormalExecution = false;
1061                mSceneMgr->setOption("Algorithm", &mCurrentAlgorithm);
1062        }
1063        else
1064        {       // standard rendering without changed render queue flow
1065                isNormalExecution = true;
1066        }
1067       
1068        mSceneMgr->setOption("NormalExecution", &isNormalExecution);
1069        mAlgorithmInfo->setCaption(": " + msAlgorithmCaptions[mCurrentAlgorithm]);
1070
1071        if (1)
1072        {
1073                std::stringstream d; d << "algorithm: " << msAlgorithmCaptions[mCurrentAlgorithm];
1074                Ogre::LogManager::getSingleton().logMessage(d.str());
1075        }
1076}
1077//-----------------------------------------------------------------------
1078void TerrainFrameListener::updateStats()
1079{
1080        unsigned int opt = 0;
1081        char str[100];
1082       
1083        static String currFpsString = "Current FPS: ";
1084        static String avgFpsString = "Average FPS: ";
1085        static String bestFpsString = "Best FPS: ";
1086        static String worstFpsString = "Worst FPS: ";
1087        static String trisString = "Triangle Count: ";
1088
1089        int currentFps;
1090       
1091        // HACK for demo: use precomputed FPS instead of real FPS
1092        if (mRecordDemo)
1093        {
1094                currentFps = mPrecomputedFps;
1095        }
1096        else
1097        {
1098                currentFps = mWindow->getStatistics().lastFPS;
1099        }
1100
1101#if 0
1102        // HACK: take pure rendering time, only measures the render call
1103        long pureRenderTime = mTimeFrameEnded - mTimeFrameStarted;
1104
1105        if (pureRenderTime)
1106        {
1107                mPureRenderTimeFps = 1000.0 / (float) pureRenderTime;
1108        }
1109        currentFps = mPureRenderRenderTimeFps;
1110        //std::stringstream d; d << "Pure render time fps: " << mPureRenderTimeFps << "\n";
1111        //Ogre::LogManager::getSingleton().logMessage(d.str());
1112#endif
1113       
1114        unsigned int nodeInfo[3];
1115    mSceneMgr->getOption("NumRenderedNodes", nodeInfo);
1116        mSceneMgr->getOption("NumQueryCulledNodes", nodeInfo+1);
1117        mSceneMgr->getOption("NumFrustumCulledNodes", nodeInfo+2);
1118
1119
1120        mWalkthroughStats.UpdateFrame(currentFps,
1121                                                                  mWindow->getBestFPS(),
1122                                                                  mWindow->getWorstFPS(),
1123                                                                  (int)mWindow->getTriangleCount(),
1124                                                                  nodeInfo[0],
1125                                                                  nodeInfo[1],
1126                                                                  nodeInfo[2]);
1127
1128        // HACK: compute average fps ourselfs, because ogre avg. fps is wrong
1129        // TODO: update only once per second
1130        float avgFps = (float)mWalkthroughStats.mAccFps / (float)(mWalkthroughStats.mFrameCount);
1131       
1132
1133        // update stats when necessary
1134    try
1135        {
1136                OverlayElement* guiAvg = OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");
1137                OverlayElement* guiCurr = OverlayManager::getSingleton().getOverlayElement("Core/CurrFps");
1138                OverlayElement* guiBest = OverlayManager::getSingleton().getOverlayElement("Core/BestFps");
1139                OverlayElement* guiWorst = OverlayManager::getSingleton().getOverlayElement("Core/WorstFps");
1140
1141                const RenderTarget::FrameStats& stats = mWindow->getStatistics();
1142
1143                // HACK: take newly computed avg. fps instead of Ogre avg fps and update only once per second
1144                if (mTimeDelay < 0)
1145                {               
1146                        guiAvg->setCaption(avgFpsString + StringConverter::toString(avgFps) + " ms");
1147                        //guiCurr->setCaption(currFpsString + StringConverter::toString(currentFps));
1148                }
1149
1150                if (0)
1151                {
1152                        std::stringstream d;
1153                        d << "fps: " << StringConverter::toString(currentFps) << ", "
1154                          << "avg fps: " << StringConverter::toString(avgFps);
1155                        LogManager::getSingleton().logMessage(d.str());
1156                }
1157
1158                //guiAvg->setCaption(avgFps + StringConverter::toString(stats.avgFPS));
1159                guiCurr->setCaption(currFpsString + StringConverter::toString(currentFps));
1160               
1161                //std::stringstream d; d << "frame rate :" << stats.lastFPS;
1162                //Ogre::LogManager::getSingleton().logMessage(d.str());
1163
1164                guiBest->setCaption(bestFpsString + StringConverter::toString(stats.bestFPS)
1165                                                        + " " + StringConverter::toString(stats.bestFrameTime) + " ms");
1166                guiWorst->setCaption(worstFpsString + StringConverter::toString(stats.worstFPS)
1167                                                         + " " + StringConverter::toString(stats.worstFrameTime) + " ms");
1168
1169                OverlayElement* guiTris = OverlayManager::getSingleton().getOverlayElement("Core/NumTris");
1170        guiTris->setCaption(trisString + StringConverter::toString(stats.triangleCount));
1171               
1172                //LogManager::getSingleton().logMessage(StringConverter::toString(stats.triangleCount));
1173
1174                OverlayElement* guiDbg = OverlayManager::getSingleton().getOverlayElement("Core/DebugText");
1175                guiDbg->setCaption(mWindow->getDebugText());
1176
1177
1178                //-- culling stats
1179
1180                mSceneMgr->getOption("NumFrustumCulledNodes", &opt); sprintf(str,": %d", opt);
1181                mFrustumCulledNodesInfo->setCaption(str);
1182
1183                mSceneMgr->getOption("NumQueryCulledNodes", &opt); sprintf(str,": %d", opt);
1184                mQueryCulledNodesInfo->setCaption(str);
1185       
1186                mSceneMgr->getOption("NumHierarchyNodes", &opt); sprintf(str,": %d", opt);
1187                mHierarchyNodesInfo->setCaption(str);
1188
1189                mSceneMgr->getOption("NumRenderedNodes", &opt); sprintf(str,": %d", opt);
1190                mRenderedNodesInfo->setCaption(str);
1191
1192                sprintf(str,": %d", mTerrainContentGenerator->GetObjectCount());
1193                mObjectsCountInfo->setCaption(str);
1194
1195                // take old value into account in order to create no sudden changes
1196                mSceneMgr->getOption("NumQueriesIssued", &opt);
1197                mDelayedQueriesIssued = mDelayedQueriesIssued * 0.8 + (float)opt * 0.2f;
1198                sprintf(str,": %d", (int)mDelayedQueriesIssued);
1199                mQueriesIssuedInfo->setCaption(str);
1200
1201                mSceneMgr->getOption("NumTraversedNodes", &opt);
1202                mDelayedTraversedNodes = mDelayedTraversedNodes * 0.8 + (float)opt * 0.2f;
1203                sprintf(str,": %d", (int)mDelayedTraversedNodes);
1204                mTraversedNodesInfo->setCaption(str);
1205
1206                if (mRecordVideo)
1207                {
1208                        // update stats for demo
1209                        mMyStatsAlgorithmInfo->setCaption(msApprevAlgorithmCaptions[mCurrentAlgorithm]);
1210                        sprintf(str,": %d", (int)currentFps);
1211                        mMyStatsFpsInfo->setCaption(str);
1212                }
1213
1214        }
1215        catch (...)
1216        {
1217                // ignore
1218        }
1219}
1220//-----------------------------------------------------------------------
1221void TerrainFrameListener::setTestGeometryForVisibleLeaves(bool testGeometryForVisibleLeaves)
1222{
1223        mSceneMgr->setOption("TestGeometryForVisibleLeaves", &mTestGeometryForVisibleLeaves);
1224       
1225        /* disable optimization which tests geometry instead of aabb
1226         * for "delayed" rendering of transparents (i.e., render transparents after all the solids)
1227         * because otherwise visible transparents could be skipped
1228         */
1229        bool delayedRendering = !mTestGeometryForVisibleLeaves;
1230
1231        mSceneMgr->setOption("DelayRenderTransparents", &delayedRendering);
1232
1233        if (mTestGeometryForVisibleLeaves)
1234        {
1235                mTestGeometryForVisibleLeavesInfo->setCaption(": true");
1236        }
1237        else
1238        {
1239                mTestGeometryForVisibleLeavesInfo->setCaption(": false");
1240        }
1241}
1242//-----------------------------------------------------------------------
1243void TerrainFrameListener::toggleShowOctree()
1244{
1245        mShowOctree = !mShowOctree;
1246        mSceneMgr->setOption("ShowOctree", &mShowOctree);
1247}
1248//-----------------------------------------------------------------------
1249void TerrainFrameListener::toggleShowViewCells()
1250{
1251        mShowViewCells = !mShowViewCells;
1252        mSceneMgr->setOption("ShowViewCells", &mShowViewCells);
1253}
1254//-----------------------------------------------------------------------
1255void TerrainFrameListener::toggleUseViewCells()
1256{
1257        // HACK: no view cells for hilly terrain
1258        if (mApplication->msShowHillyTerrain)
1259                return;
1260
1261        mUseViewCells = !mUseViewCells;
1262
1263        // load on demand
1264        if (mUseViewCells)// && !mViewCellsLoaded)
1265        {
1266                LogManager::getSingleton().logMessage("using view cells");
1267                mLoadingOverlay->show();
1268
1269                // call once to load view cell loading overlay
1270                mWindow->update();
1271                mViewCellsLoaded = mApplication->LoadViewCells(mApplication->mViewCellsFilename);
1272               
1273                if (!mViewCellsLoaded)
1274                        LogManager::getSingleton().logMessage("loading view cells failed");
1275                else
1276                        LogManager::getSingleton().logMessage("view cells successfully loaded");
1277       
1278                mLoadingOverlay->hide();
1279        }
1280
1281        if (mUseViewCells)
1282                mViewCellsInfo->setCaption(": on");
1283        else
1284                mViewCellsInfo->setCaption(": off");
1285
1286        mSceneMgr->setOption("UseViewCells", &mUseViewCells);
1287}
1288//-----------------------------------------------------------------------
1289void TerrainFrameListener::toggleUseVisibilityFilter()
1290{
1291        mUseVisibilityFilter = !mUseVisibilityFilter;
1292        mSceneMgr->setOption("UseVisibilityFilter", &mUseVisibilityFilter);
1293}
1294//-----------------------------------------------------------------------
1295void TerrainFrameListener::toggleUseDepthPass()
1296{
1297        mUseDepthPass = !mUseDepthPass;
1298
1299        mSceneMgr->setOption("UseDepthPass", &mUseDepthPass);
1300       
1301        if (mUseDepthPass)
1302        {
1303                mUseDepthPassInfo->setCaption(": true");
1304        }
1305        else
1306        {
1307                mUseDepthPassInfo->setCaption(": false");
1308        }
1309}
1310//-----------------------------------------------------------------------
1311void TerrainFrameListener::toggleFlushQueue()
1312{
1313        mFlushQueue = !mFlushQueue;
1314
1315        mSceneMgr->setOption("FlushQueue", &mFlushQueue);
1316       
1317        if (mFlushQueue)
1318        {
1319                LogManager::getSingleton().logMessage("flushing queue");
1320                //mFlushQueueInfo->setCaption(": true");
1321        }
1322        else
1323        {
1324                LogManager::getSingleton().logMessage("not flushing queue");
1325                //mFlushQueueInfo->setCaption(": false");
1326        }
1327}
1328
1329//-----------------------------------------------------------------------
1330void TerrainFrameListener::toggleShowViz()
1331{
1332        mVisualizeCulledNodes = mShowVisualization = !mShowVisualization;
1333       
1334        // create viewport with priority VIZ_VIEWPORT_Z_ORDER:
1335        // will be rendered over standard viewport
1336        if (mShowVisualization)
1337        {       
1338                Viewport *vizvp = mWindow->addViewport(mVizCamera,
1339                        VIZ_VIEWPORT_Z_ORDER, 0.6, 0.6, 0.4, 0.4);
1340                               
1341                vizvp->setBackgroundColour(ColourValue(0.0, 0.3, 0.2, 1));
1342
1343                vizvp->setOverlaysEnabled(false);
1344                // Alter the camera aspect ratio to match the viewport
1345        mVizCamera->setAspectRatio(Real(vizvp->getActualWidth()) /
1346                                                                   Real(vizvp->getActualHeight()));
1347               
1348                mSceneMgr->setOption("VisualizeCulledNodes", &mVisualizeCulledNodes);
1349       
1350        }
1351        else
1352        {
1353                // remove visualization viewport
1354                mWindow->removeViewport(VIZ_VIEWPORT_Z_ORDER);
1355
1356                // octree bounding boxes are shown for visualization purpose, reset now
1357                mSceneMgr->setOption("ShowOctree", &mShowOctree);
1358        }
1359}
1360//-----------------------------------------------------------------------
1361void TerrainFrameListener::toggleShowShadows()
1362{
1363        mShowShadows = !mShowShadows;
1364
1365        mSunLight->setCastShadows(mShowShadows);
1366
1367        if (mShowShadows)
1368        {
1369                mSceneMgr->setShadowTechnique(SHADOWTYPE_TEXTURE_MODULATIVE);
1370                //mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_MODULATIVE);
1371                //mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_ADDITIVE);           
1372        }
1373        else
1374        {
1375                mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
1376        }
1377
1378}
1379//-----------------------------------------------------------------------
1380void TerrainFrameListener::nextNodeVizMode()
1381{
1382        mNodeVizMode = (mNodeVizMode + 1) % NODEVIZ_MODES_NUM;
1383
1384        bool renderNodesForViz = (mNodeVizMode == NODEVIZ_RENDER_NODES) ||
1385                (mNodeVizMode == NODEVIZ_RENDER_NODES_AND_CONTENT);
1386        bool renderNodesContentForViz = (mNodeVizMode == NODEVIZ_RENDER_NODES_AND_CONTENT);
1387        //bool renderNodesContentForViz = mNodeVizMode == NODEVIZ_RENDER_GEOMETRY;
1388
1389        mSceneMgr->setOption("RenderNodesForViz", &renderNodesForViz);
1390        mSceneMgr->setOption("RenderNodesContentForViz", &renderNodesContentForViz);
1391}
1392//-----------------------------------------------------------------------
1393void TerrainFrameListener::keyPressed(KeyEvent* e)
1394{
1395        // hide exact visibility query overlay
1396        if (mShowQueryStats)
1397        {
1398                mQueryOverlay->hide();
1399                mShowQueryStats = false;
1400        }
1401
1402        switch(e->getKey())
1403        {
1404       
1405        case KC_SUBTRACT:
1406                changeThreshold(-10);
1407                break;
1408        case KC_ADD:
1409                changeThreshold(10);
1410                break;
1411
1412        case KC_ESCAPE:
1413                mShutdownRequested = true;
1414                e->consume();
1415                return;
1416
1417        case KC_SPACE:
1418                nextAlgorithm();
1419                break;
1420
1421        case KC_LSHIFT:
1422                mShiftPressed = true;
1423                break;
1424        case KC_DELETE:
1425                mDeleteObjects = true;
1426                break;
1427
1428        case KC_C:
1429                if (mItemBufferMode != GtpVisibility::QueryManager::GEOMETRY_VISIBILITY)
1430                {
1431                        mItemBufferMode = GtpVisibility::QueryManager::GEOMETRY_VISIBILITY;
1432                }
1433                else
1434                {
1435                        mItemBufferMode = GtpVisibility::QueryManager::PATCH_VISIBILITY;
1436                }
1437                break;
1438         case KC_E: // hack for recording demo using precomputed fps
1439                mSavePrecomputedFps = !mSavePrecomputedFps;
1440                break;
1441
1442    case KC_F:
1443                nextFilter();
1444                break;
1445        case KC_G:
1446                mTestGeometryForVisibleLeaves = !mTestGeometryForVisibleLeaves;
1447                setTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves);
1448                break;
1449        case KC_H:
1450                toggleShowShadows();
1451                break;
1452        case KC_L:
1453                toggleShowViewCells();
1454                break;
1455        case KC_M: // hack for recording demo using precomputed fps
1456                mRecordDemo = !mRecordDemo;
1457                break;
1458        case KC_O:
1459                switchMouseMode();
1460                break;
1461        case KC_P:
1462                toggleDisplayCameraDetails();
1463                break;
1464        case KC_V:
1465                toggleUseViewCells();
1466                break;
1467        case KC_Q:
1468                toggleUseVisibilityFilter();
1469                break;
1470        case KC_R:
1471                nextSceneDetailLevel();
1472                break;
1473        case KC_T:
1474                toggleShowOctree();
1475                break;
1476        case KC_U:
1477                mCamNode->resetOrientation();
1478                mCamNode->setPosition(mApplication->mInitialPosition);
1479                break;
1480        case KC_X:
1481                toggleUseDepthPass();
1482                break;
1483        case KC_I:
1484                toggleFlushQueue();
1485                break;
1486        case KC_Z:
1487                mCamNode->resetOrientation();
1488                break;
1489
1490
1491        ///////////////
1492        //-- visualization
1493
1494        case KC_1:
1495                toggleShowViz();
1496                break;
1497        case KC_2:
1498                nextNodeVizMode();
1499                break;
1500        case KC_7:
1501                mTerrainContentGenerator->WriteObjects(objects_out_filename);
1502                break;
1503        case KC_8:
1504                changeAssumedVisibility(-5);
1505                // changeAssumedVisibility(-500);
1506                break;
1507        case KC_9:
1508                changeAssumedVisibility(5);
1509                // changeAssumedVisibility(500);
1510                break;
1511
1512//#if USE_PERFHUD
1513        case KC_F1:
1514                toggleShowHelp();
1515                break;
1516        case KC_F2:
1517                mStatsOn = !mStatsOn;
1518                showStats(mStatsOn);
1519                break;
1520        case KC_F3:
1521                nextAppState();
1522                break;
1523        case KC_F4:
1524                toggleRecord();
1525                break;
1526
1527        case KC_F5:
1528                {
1529                        const bool fromPoint = false;
1530                        applyVisibilityQuery(fromPoint, mShiftPressed, mUseItemBuffer);
1531                        break;
1532                }
1533
1534        case KC_F6:
1535                {
1536                        const bool fromPoint = true;
1537                        applyVisibilityQuery(fromPoint, mShiftPressed, mUseItemBuffer);
1538                        break;
1539                }       
1540        case KC_F7:
1541                ++ mCurrentObjectType;
1542                applyObjectType();
1543                break;
1544//#endif
1545
1546        case KC_F8:
1547                {       
1548                        // generate new objects
1549                        const int objNum = 500;
1550                        mApplication->generateScene(objNum, mCurrentObjectType);
1551                }
1552                break;
1553        case KC_F9:
1554                mUseAnimation = !mUseAnimation;
1555                break;
1556
1557        case KC_F10:
1558                mRecordVideo = !mRecordVideo;
1559                       
1560        case KC_F11:
1561                takeScreenshot();
1562                break;
1563       
1564        case KC_F12:
1565                break;
1566        //KEY_PRESSED(KC_F3, 0.3, writeFrames());
1567        //KEY_PRESSED(KC_F4, 0.3, loadFrames());
1568        default:
1569                break;
1570        }
1571
1572        CEGUI::System::getSingleton().injectKeyDown(e->getKey());
1573        CEGUI::System::getSingleton().injectChar(e->getKeyChar());
1574        e->consume();
1575}
1576//-----------------------------------------------------------------------
1577void TerrainFrameListener::keyReleased(KeyEvent* e)
1578{
1579        if (e->getKey() == KC_LSHIFT)
1580        {
1581                mShiftPressed = false;
1582        }
1583       
1584        CEGUI::System::getSingleton().injectKeyUp(e->getKey());
1585        e->consume();
1586}
1587//-----------------------------------------------------------------------
1588void TerrainFrameListener::keyClicked(KeyEvent* e)
1589{
1590        // Do nothing
1591        e->consume();
1592}
1593//-----------------------------------------------------------------------
1594void TerrainFrameListener::addFrameInfo(FrameInfoContainer &frameInfos,
1595                                                                                SceneNode *camNode,
1596                                                                                Real timeElapsed)
1597{
1598        frame_info info;
1599
1600        info.orientation = mCamNode->getOrientation();
1601        info.position = mCamNode->getPosition();
1602        info.timeElapsed = timeElapsed;
1603        info.fps = mWindow->getStatistics().lastFPS;
1604
1605        frameInfos.push_back(info);
1606}
1607//-----------------------------------------------------------------------
1608void TerrainFrameListener::setCurrentFrameInfo(const Real timeElapsed)
1609{
1610        //-- find current frame relative to elapsed frame time         
1611        mReplayTimeElapsed -= timeElapsed;
1612       
1613        while ((mReplayTimeElapsed <= 0) && (mCurrentFrame < (int)mFrameInfo.size() - 1))
1614        {
1615                mReplayTimeElapsed += mFrameInfo[mCurrentFrame ++].timeElapsed;
1616        }
1617
1618
1619        // TODO: crashes here if recording / replaying on the same time!!
1620        const frame_info new_frame = mFrameInfo[mCurrentFrame];
1621        const frame_info old_frame = mFrameInfo[mCurrentFrame - 1];
1622               
1623        /////////////
1624        //-- interpolate frames
1625        Real factor = 1;
1626
1627        if (old_frame.timeElapsed > 0)
1628        {
1629                factor = mReplayTimeElapsed / old_frame.timeElapsed;
1630        }
1631
1632        const Vector3 camPos = old_frame.position + factor
1633                * (new_frame.position - old_frame.position);
1634
1635        // interpolate the orientation
1636        const Quaternion camOrienation =
1637                Quaternion::Slerp(factor, old_frame.orientation, new_frame.orientation, true);
1638
1639        // HACK for demo: interpolate precomputed fps
1640        mPrecomputedFps = old_frame.fps + factor * (new_frame.fps - old_frame.fps);
1641
1642        mCamNode->setPosition(camPos);
1643        mCamNode->setOrientation(camOrienation);
1644       
1645        // stop replaying after one full walkthrough
1646        if (mCurrentFrame == (int)mFrameInfo.size() - 1)
1647        {
1648                nextAppState();
1649        }
1650}
1651//-----------------------------------------------------------------------   
1652bool TerrainFrameListener::processUnbufferedKeyInput(const FrameEvent& evt)
1653{
1654        bool cursorPressed = false;
1655       
1656        /* Move camera forward by keypress. */
1657    if (mInputDevice->isKeyDown(KC_UP) || mInputDevice->isKeyDown(KC_W))
1658        {
1659                mTranslateVector.z = -mMoveScale;
1660                cursorPressed = true;
1661        }
1662    /* Move camera backward by keypress. */
1663    if (mInputDevice->isKeyDown(KC_DOWN) || mInputDevice->isKeyDown(KC_S))
1664    {
1665                mTranslateVector.z = mMoveScale;
1666                cursorPressed = true;
1667    }
1668
1669        if (mInputDevice->isKeyDown(KC_A))
1670        {
1671                mTranslateVector.x -= mMoveScale;
1672                mTranslateVector.y += mMoveScale;
1673
1674                cursorPressed = true;
1675        }
1676
1677        if (mInputDevice->isKeyDown(KC_D))
1678        {
1679                mTranslateVector.x += mMoveScale;
1680                mTranslateVector.y -= mMoveScale;
1681
1682                cursorPressed = true;
1683        }
1684
1685    if (mInputDevice->isKeyDown(KC_RIGHT))
1686    {
1687        mCamNode->yaw(-mRotScale, Ogre::Node::TS_WORLD);
1688                cursorPressed = true;
1689    }
1690
1691    if (mInputDevice->isKeyDown(KC_LEFT))
1692    {
1693        mCamNode->yaw(mRotScale, Ogre::Node::TS_WORLD);
1694                cursorPressed = true;
1695    }
1696        // visualization camera
1697        if (mInputDevice->isKeyDown(KC_3))
1698        {
1699                zoomVizCamera(50);
1700        }
1701        if (mInputDevice->isKeyDown(KC_4))
1702        {
1703                zoomVizCamera(-50);
1704        }
1705
1706        if (mInputDevice->isKeyDown(KC_5))
1707        {
1708                changeVizScale(-1);
1709        }
1710
1711        if (mInputDevice->isKeyDown(KC_6))
1712        {
1713                changeVizScale(1);
1714        }
1715       
1716        if (mInputDevice->isKeyDown(KC_7))
1717        {
1718                changeFloorDist(-1);
1719        }
1720       
1721        if (mInputDevice->isKeyDown(KC_8))
1722        {
1723                changeFloorDist(1);
1724        }
1725
1726
1727        // show the results
1728        if (cursorPressed && mShowQueryStats)
1729        {
1730                mQueryOverlay->hide();
1731                mShowQueryStats = false;
1732        }
1733
1734    // Return true to continue rendering
1735    return true;
1736}
1737//-----------------------------------------------------------------------
1738void TerrainFrameListener::nextFilter()
1739{
1740        switch (mFiltering)
1741        {
1742        case TFO_BILINEAR:
1743                mFiltering = TFO_TRILINEAR;
1744                mAniso = 1;
1745                break;
1746        case TFO_TRILINEAR:
1747                mFiltering = TFO_ANISOTROPIC;
1748                mAniso = 8;
1749                break;
1750        case TFO_ANISOTROPIC:
1751                mFiltering = TFO_BILINEAR;
1752                mAniso = 1;
1753                break;
1754        default:
1755                break;
1756        }
1757
1758    MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
1759    MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);
1760
1761        // reload stats
1762    showStats(mStatsOn);
1763}
1764//-----------------------------------------------------------------------
1765void TerrainFrameListener::nextSceneDetailLevel()
1766{
1767#if OGRE_103
1768        mSceneDetailIndex = (mSceneDetailIndex + 1) % 3;
1769        switch (mSceneDetailIndex)
1770        {
1771                case 0:
1772                        mCamera->setDetailLevel(SDL_SOLID);
1773                        break;
1774                case 1:
1775                        mCamera->setDetailLevel(SDL_WIREFRAME);
1776                        break;
1777                case 2:
1778                        mCamera->setDetailLevel(SDL_POINTS);
1779                        break;
1780        }
1781#endif
1782}
1783//-----------------------------------------------------------------------
1784void TerrainFrameListener::takeVideoFrame(std::ofstream &ofstr)
1785{
1786        char name[50];
1787
1788        sprintf(name, "frame_%05d.tga", ++mNumVideoFrames);
1789    mWindow->writeContentsToFile(name);
1790    //mWindow->setDebugText(String("Wrote ") + name);
1791
1792        ofstr << name << "\n";
1793}
1794//-----------------------------------------------------------------------
1795void TerrainFrameListener::takeScreenshot()
1796{
1797        char name[50];
1798
1799        sprintf(name, "screenshot_%05d.png", ++mNumScreenShots);
1800    mWindow->writeContentsToFile(name);
1801    //mWindow->setDebugText(String("Wrote ") + name);
1802}
1803//-----------------------------------------------------------------------
1804void TerrainFrameListener::toggleDisplayCameraDetails()
1805{
1806        mDisplayCameraDetails = !mDisplayCameraDetails;
1807       
1808    if (!mDisplayCameraDetails)
1809        {
1810                mWindow->setDebugText("");
1811        }
1812}
1813//-----------------------------------------------------------------------
1814void TerrainFrameListener::showStats(bool show)
1815{
1816        if (mDebugOverlay && mCullStatsOverlay)
1817        {
1818                if (show)
1819                {
1820                        mDebugOverlay->show();
1821                        mCullStatsOverlay->show();
1822                }
1823                else
1824                {
1825                        mDebugOverlay->hide();
1826                        mCullStatsOverlay->hide();
1827                }
1828        }
1829}
1830
1831//-----------------------------------------------------------------------
1832void TerrainFrameListener::toggleShowHelp()
1833{
1834        mShowHelp = !mShowHelp;
1835
1836        if (mShowHelp)
1837        {
1838                mHelpOverlay->show();
1839        }
1840        else
1841        {
1842                mHelpOverlay->hide();
1843        }
1844}
1845//-----------------------------------------------------------------------
1846void TerrainFrameListener::initOverlayElement(OverlayElement **elInfo, String ext,
1847                                                                                          String name, int top, String caption)
1848{
1849        OverlayElement *el =
1850                OverlayManager::getSingleton().getOverlayElement(ext + name);
1851
1852        (*elInfo) = OverlayManager::getSingleton().getOverlayElement(ext + name + "Info");
1853        (*elInfo)->setCaption(caption);
1854
1855        el->setTop(top);
1856        (*elInfo)->setTop(top);
1857}
1858//-----------------------------------------------------------------------
1859void TerrainFrameListener::initHelpOverlayElement(String name, int top)
1860{
1861        OverlayElement *el = OverlayManager::getSingleton().getOverlayElement(
1862                "Example/Visibility/Help/" + name);
1863
1864        el->setTop(top);
1865}
1866//-----------------------------------------------------------------------
1867void TerrainFrameListener::initHelpOverlay()
1868{
1869        const int vert_space = 15;
1870        int top = 30;
1871
1872        initHelpOverlayElement("ShowHelp", top); top += vert_space;
1873        initHelpOverlayElement("Stats", top); top += vert_space;
1874        initHelpOverlayElement("AppState", top); top += vert_space;
1875        initHelpOverlayElement("Recorded", top); top += vert_space;
1876        initHelpOverlayElement("Animation", top); top += vert_space;
1877        initHelpOverlayElement("Video", top); top += vert_space;
1878        initHelpOverlayElement("Screenshots", top); top += vert_space;
1879        initHelpOverlayElement("WriteOut", top); top += vert_space;
1880
1881
1882        top +=vert_space;
1883        initHelpOverlayElement("SceneDetail", top); top += vert_space;
1884        initHelpOverlayElement("DisplayCameraDetails", top); top += vert_space;
1885        initHelpOverlayElement("DisplayOctree", top); top += vert_space;
1886        initHelpOverlayElement("UseShadows", top); top += vert_space;
1887        initHelpOverlayElement("Filter", top); top += vert_space;
1888
1889        //-- visualization
1890        top += vert_space;
1891        initHelpOverlayElement("VizSection", top); top += vert_space;
1892        initHelpOverlayElement("Viz", top); top += vert_space;
1893        initHelpOverlayElement("NextVizMode", top); top += vert_space;
1894        initHelpOverlayElement("ZoomViz", top); top += vert_space;
1895
1896
1897        //-- visibility queries
1898        top += vert_space;
1899        initHelpOverlayElement("VisQuery", top); top += vert_space;
1900        initHelpOverlayElement("FromCameraQuery", top); top += vert_space;
1901        initHelpOverlayElement("FromPointQuery", top); top += vert_space;
1902        initHelpOverlayElement("QueryType", top); top += vert_space;
1903        initHelpOverlayElement("QueryTarget", top); top += vert_space;
1904
1905        //-- object generation
1906        top += vert_space;
1907        initHelpOverlayElement("SceneObjects", top); top += vert_space;
1908        initHelpOverlayElement("PlaceObjects", top); top += vert_space;
1909        initHelpOverlayElement("GenerateObjects", top); top += vert_space;
1910        initHelpOverlayElement("RemoveObjects", top); top += vert_space;
1911        initHelpOverlayElement("DropObject", top); top += vert_space;
1912
1913        OverlayElement *helpPanel = OverlayManager::getSingleton().getOverlayElement(
1914                "Example/Visibility/Help/HelpPanel");
1915
1916        helpPanel->setHeight(top + 10);
1917}
1918//-----------------------------------------------------------------------
1919void TerrainFrameListener::initVisStatsOverlay()
1920{
1921        const int border_height = 10;
1922        const int vert_space = 15;
1923
1924        //-- visibility culling stats overlay
1925        int top = border_height;
1926
1927        String ext = "Example/Visibility/";
1928       
1929        initOverlayElement(&mAlgorithmInfo, ext, "Algorithm", top,
1930                ": " + msAlgorithmCaptions[mCurrentAlgorithm]); top += vert_space;
1931
1932        initOverlayElement(&mThresholdInfo, ext, "Threshold", top, ": 0"); top += vert_space;
1933        initOverlayElement(&mTestGeometryForVisibleLeavesInfo, ext,
1934                                           "TestGeometryForVisibleLeaves", top, ": true"); top += vert_space;
1935        initOverlayElement(&mUseDepthPassInfo, ext, "UseDepthPass", top, ": false"); top += vert_space;
1936        initOverlayElement(&mAssumedVisibilityInfo, ext, "AssumedVisibility", top, ": 0"); top += vert_space;
1937        initOverlayElement(&mCurrentObjectTypeInfo, ext, "CurrentObjectType", top, ": "); top += vert_space;
1938        initOverlayElement(&mViewCellsInfo, ext, "ViewCells", top, ": "); top += vert_space;
1939        //initOverlayElement(&mHelpInfo, ext, "Help", top, ": "); top += vert_space;
1940
1941        OverlayElement *optionsPanel = OverlayManager::getSingleton().
1942                getOverlayElement("Example/Visibility/VisibilityPanel");
1943
1944        optionsPanel->setHeight(top + border_height);
1945
1946        top = border_height;
1947        //ext = "Example/Visibility/";
1948        initOverlayElement(&mFrustumCulledNodesInfo, ext, "FrustumCulledNodes", top, ": 0"); top += vert_space;
1949        initOverlayElement(&mQueryCulledNodesInfo, ext, "QueryCulledNodes", top, ": 0"); top += vert_space;
1950        initOverlayElement(&mTraversedNodesInfo, ext, "TraversedNodes", top, ": 0"); top += vert_space;
1951        initOverlayElement(&mHierarchyNodesInfo, ext, "HierarchyNodes", top, ": 0"); top += vert_space;
1952        initOverlayElement(&mRenderedNodesInfo, ext, "RenderedNodes", top, ": 0"); top += vert_space;
1953        initOverlayElement(&mObjectsCountInfo, ext, "ObjectsCount", top, ": 0"); top += vert_space;
1954        initOverlayElement(&mQueriesIssuedInfo, ext, "QueriesIssued", top, ": 0"); top += vert_space;
1955
1956        OverlayElement *visPanel = OverlayManager::getSingleton().
1957                getOverlayElement("Example/Visibility/VisibilityStatsPanel");
1958
1959        visPanel->setHeight(top + border_height);
1960}
1961//-----------------------------------------------------------------------
1962void TerrainFrameListener::initQueryOverlay()
1963{
1964        const int border_height = 10;
1965        const int vert_space = 15;
1966
1967        //-- visibility culling stats overlay
1968        int top = border_height + 25;
1969
1970        const String ext = "Example/Visibility/Query/";
1971           
1972        initOverlayElement(&mQueryTypeInfo , ext, "QueryType", top,     ": 0"); top += vert_space;
1973       
1974        initOverlayElement(&mQueryVisibleNodesInfo , ext, "VisibleNodes", top,  ": 0"); top += vert_space;
1975        initOverlayElement(&mQueryVisibleGeometryInfo , ext, "VisibleGeometry", top,    ": 0"); top += vert_space;
1976        initOverlayElement(&mQueryVisiblePatchInfo , ext, "VisiblePatches", top,        ": 0"); top += vert_space;
1977       
1978        initOverlayElement(&mQueryNodeVisibilityInfo , ext, "NodeVisibility", top,      ": 0"); top += vert_space;
1979        initOverlayElement(&mQueryGeometryVisibilityInfo , ext, "GeometryVisibility", top,      ": 0"); top += vert_space;
1980        initOverlayElement(&mQueryPatchVisibilityInfo , ext, "PatchVisibility", top,    ": 0"); top += vert_space;
1981
1982        OverlayElement *queryPanel =
1983                OverlayManager::getSingleton().getOverlayElement("Example/Visibility/Query/QueryPanel");
1984
1985        queryPanel->setHeight(top + border_height);
1986}
1987//-----------------------------------------------------------------------
1988void TerrainFrameListener::setAlgorithm(const int algorithm)
1989{
1990        mCurrentAlgorithm = algorithm;
1991        applyCurrentAlgorithm();
1992}
Note: See TracBrowser for help on using the repository browser.