source: trunk/VUT/work/iv/IVFrameListener.cpp @ 345

Revision 345, 35.7 KB checked in by mattausch, 19 years ago (diff)

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