source: branches/VUT/0.3/work/iv/IVFrameListener.cpp @ 187

Revision 187, 34.6 KB checked in by mattausch, 19 years ago (diff)

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