source: obsolete/trunk/VUT/work/iv/IVFrameListener.cpp @ 417

Revision 417, 36.4 KB checked in by mattausch, 19 years ago (diff)

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