source: GTP/trunk/App/Demos/Vis/KdTreeDemo/OGRE/src/TestKdTreeAppListener.cpp @ 1192

Revision 1192, 27.1 KB checked in by szydlowski, 18 years ago (diff)

pre-major-changes-backup (TM)
fixed node vis issues for internal culling
Line 
1#include "TestKdTreeAppListener.h"
2
3void KdTreeAppListener::updateStats(void)
4{
5        static unsigned int opt = 0;
6        static char str[100];
7
8        static String currFps = "Current FPS: ";
9        static String avgFps = "Average FPS: ";
10        static String bestFps = "Best FPS: ";
11        static String worstFps = "Worst FPS: ";
12        static String tris = "Triangle Count: ";
13
14        // update stats when necessary
15        try {
16                OverlayElement* guiAvg = OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");
17                OverlayElement* guiCurr = OverlayManager::getSingleton().getOverlayElement("Core/CurrFps");
18                OverlayElement* guiBest = OverlayManager::getSingleton().getOverlayElement("Core/BestFps");
19                OverlayElement* guiWorst = OverlayManager::getSingleton().getOverlayElement("Core/WorstFps");
20
21                const RenderTarget::FrameStats& stats = mWindow->getStatistics();
22
23                guiAvg->setCaption(avgFps + StringConverter::toString(stats.avgFPS));
24                guiCurr->setCaption(currFps + StringConverter::toString((int)stats.lastFPS));
25                guiBest->setCaption(bestFps + StringConverter::toString(stats.bestFPS)
26                        +" "+StringConverter::toString(stats.bestFrameTime)+" ms");
27                guiWorst->setCaption(worstFps + StringConverter::toString(stats.worstFPS)
28                        +" "+StringConverter::toString(stats.worstFrameTime)+" ms");
29
30                OverlayElement* guiTris = OverlayManager::getSingleton().getOverlayElement("Core/NumTris");
31                guiTris->setCaption(tris + StringConverter::toString(stats.triangleCount));
32
33                OverlayElement* guiDbg = OverlayManager::getSingleton().getOverlayElement("Core/DebugText");
34                guiDbg->setCaption(mWindow->getDebugText());
35
36
37                //-- culling stats
38                mSceneMgr->getOption("NumFrustumCulledNodes", &opt); sprintf(str,": %d", opt);
39                mFrustumCulledNodesInfo->setCaption(str);
40
41                mSceneMgr->getOption("NumQueryCulledNodes", &opt); sprintf(str,": %d", opt);
42                mQueryCulledNodesInfo->setCaption(str);
43
44                mSceneMgr->getOption("NumHierarchyNodes", &opt); sprintf(str,": %d", opt);
45                mHierarchyNodesInfo->setCaption(str);
46
47                mSceneMgr->getOption("NumRenderedNodes", &opt); sprintf(str,": %d", opt);
48                mRenderedNodesInfo->setCaption(str);
49
50                // take old value into account in order to create no sudden changes
51                mSceneMgr->getOption("NumQueriesIssued", &opt);
52                mDelayedQueriesIssued = mDelayedQueriesIssued * 0.8 + (float)opt * 0.2f;
53                sprintf(str,": %d", (int)mDelayedQueriesIssued);
54                mQueriesIssuedInfo->setCaption(str);
55
56                mSceneMgr->getOption("NumTraversedNodes", &opt);
57                mDelayedTraversedNodes = mDelayedTraversedNodes * 0.8 + (float)opt * 0.2f;
58                sprintf(str,": %d", (int)mDelayedTraversedNodes);
59                mTraversedNodesInfo->setCaption(str);
60        }
61        catch(...)
62        {
63                // ignore
64        }
65}
66
67// Constructor takes a RenderWindow because it uses that to determine input context
68KdTreeAppListener::KdTreeAppListener(RenderWindow* win, SceneManager* sm, Real rs, Real ms, Real rp,
69        bool useBufferedInputKeys, bool useBufferedInputMouse)
70{
71        mDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay");
72        mKdTreeOverlay = OverlayManager::getSingleton().getByName("KdTree/DebugOverlay");
73
74
75        mUseBufferedInputKeys = useBufferedInputKeys;
76        mUseBufferedInputMouse = useBufferedInputMouse;
77        mInputTypeSwitchingOn = mUseBufferedInputKeys || mUseBufferedInputMouse;
78
79        if (mInputTypeSwitchingOn)
80        {
81                mEventProcessor = new EventProcessor();
82                mEventProcessor->initialise(win);
83                mEventProcessor->startProcessingEvents();
84                mEventProcessor->addKeyListener(this);
85                mInputDevice = mEventProcessor->getInputReader();
86
87        }
88        else
89        {
90                mInputDevice = PlatformManager::getSingleton().createInputReader();
91                mInputDevice->initialise(win,true, true);
92        }
93
94        mFreeMove = false;
95        mShowTree = false;
96        mVizCamera = false;
97        mVizCamTransVect = Vector3::ZERO;
98        mSeqNum = 0;
99
100        mDelayedQueriesIssued = 0.0;
101        mDelayedTraversedNodes = 0.0;
102
103        mCamera = sm->getCamera("PlayerCam");
104        mTopCam = sm->getCamera("TopCam");
105        mCamNode = sm->getSceneNode("PlayerCamNode");
106        mSceneMgr = sm;
107        mWindow = win;
108        mRotateSpeed = rs;
109        mMoveSpeed = ms;
110        mRotationPeriod = rp;
111        mDeathAngle = 0;
112        mStatsOn = true;
113        mNumScreenShots = 0;
114        mTimeUntilNextToggle = 0;
115        mSceneDetailIndex = 0;
116        mMoveScale = 0.0f;
117        mRotScale = 0.0f;
118        mTranslateVector = Vector3::ZERO;
119        mAniso = 8;
120        mFiltering = TFO_ANISOTROPIC;
121
122        MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
123        MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);
124
125        initKdTreeOverlay();
126        initStatsOverlay();
127
128        showDebugOverlay(true);
129}
130//-----------------------------------------------------------------------
131KdTreeAppListener::~KdTreeAppListener()
132{
133        if (mInputTypeSwitchingOn)
134        {
135                delete mEventProcessor;
136        }
137        else
138        {
139                PlatformManager::getSingleton().destroyInputReader( mInputDevice );
140        }
141}
142//-----------------------------------------------------------------------
143void KdTreeAppListener::initOverlayElement(OverlayElement **elInfo, String ext,
144        String name, int top, String caption)
145{
146        OverlayElement *el =
147                OverlayManager::getSingleton().getOverlayElement(ext + name);
148
149        (*elInfo) = OverlayManager::getSingleton().getOverlayElement(ext + name + "Info");
150        (*elInfo)->setCaption(caption);
151
152        el->setTop(top);
153        (*elInfo)->setTop(top);
154}
155//-----------------------------------------------------------------------
156void KdTreeAppListener::initStatsOverlay()
157{
158        const int border_height = 10;
159        const int vert_space = 15;
160
161        //-- visibility culling stats overlay
162        int top = border_height;
163
164        String ext = "KdTree/Visibility/";
165
166        initOverlayElement(&mFrustumCulledNodesInfo, ext, "FrustumCulledNodes", top, ": 0"); top += vert_space;
167        initOverlayElement(&mQueryCulledNodesInfo, ext, "QueryCulledNodes", top, ": 0"); top += vert_space;
168        initOverlayElement(&mTraversedNodesInfo, ext, "TraversedNodes", top, ": 0"); top += vert_space;
169        initOverlayElement(&mHierarchyNodesInfo, ext, "HierarchyNodes", top, ": 0"); top += vert_space;
170        initOverlayElement(&mRenderedNodesInfo, ext, "RenderedNodes", top, ": 0"); top += vert_space;
171        initOverlayElement(&mObjectsCountInfo, ext, "ObjectsCount", top, ": 0"); top += vert_space;
172        initOverlayElement(&mQueriesIssuedInfo, ext, "QueriesIssued", top, ": 0"); top += vert_space;
173
174        OverlayElement *visPanel = OverlayManager::getSingleton().
175                getOverlayElement("KdTree/VisibilityStatsPanel");
176
177        visPanel->setHeight(top + border_height);
178}
179//-----------------------------------------------------------------------
180void KdTreeAppListener::initKdTreeOverlay()
181{
182        const int border_height = 10;
183        const int vert_space = 15;
184        const String na = ": N/A";
185        String sMD, sKT, sKI, sHL, sBM, sRM, sFM;
186
187        int top = border_height;
188
189        String ext = "KdTree/";
190
191        int maxd;
192        if (mSceneMgr->getOption("KdTreeMaxDepth", &maxd))
193                sMD = ": " + StringConverter::toString(maxd);
194        else
195                sMD = na;
196
197        Real kt;
198        if (mSceneMgr->getOption("KT", &kt))
199                sKT = ": " + StringConverter::toString(kt);
200        else
201                sKT = na;
202
203        Real ki;
204        if (mSceneMgr->getOption("KI", &ki))
205                sKI = ": " + StringConverter::toString(ki);
206        else
207                sKI = na;
208
209        int hl;
210        if (mSceneMgr->getOption("HiLiteLevel", &hl))
211                sHL = ": " + StringConverter::toString(hl);
212        else
213                sHL = na;
214        if (!mShowTree)
215                sHL = ": off";
216
217        String bm;
218        if (mSceneMgr->getOption("BuildMethod", &bm))
219                sBM = ": " + bm;
220        else
221                sBM = na;
222
223        String rm;
224        if (mSceneMgr->getOption("RenderMethod", &rm))
225        {
226                if (rm == "INT")
227                        sRM = ": Internal Frustum Culling";
228                else if (rm == "VFC")
229                        sRM = ": View Frustum Culling";
230                else if (rm == "SWC")
231                        sRM = ": Stop and Wait Culling";
232                else if (rm == "CHC")
233                        sRM = ": Coherent Hierarchical Culling";
234                else
235                        sRM = na;
236        }
237        else
238                sRM = na;
239
240        sFM = na;
241        if (mFreeMove)
242                sFM = ": Free";
243        else
244                sFM = ": Ground";
245
246        initOverlayElement(&mRenderMethodInfo, ext, "RenderMethod", top, sRM); top += vert_space;
247        initOverlayElement(&mBuildMethodInfo, ext, "BuildMethod", top, sBM); top += vert_space;
248        initOverlayElement(&mKdTreeMaxDepthInfo, ext, "KdTreeMaxDepth", top, sMD); top += vert_space;
249        initOverlayElement(&mHighlightLevelInfo, ext, "HighlightLevel", top, sHL); top += vert_space;
250        initOverlayElement(&mKTInfo, ext, "KT", top, sKT); top += vert_space;
251        initOverlayElement(&mKIInfo, ext, "KI", top, sKI); top += vert_space;
252        initOverlayElement(&mMovementInfo, ext, "Movement", top, sFM); top += vert_space;
253
254        OverlayElement *visPanel = OverlayManager::getSingleton().
255                getOverlayElement("KdTree/OptionsPanel");
256
257        visPanel->setHeight(top + border_height);
258}
259
260void KdTreeAppListener::showDebugOverlay(bool show)
261{
262        if (mDebugOverlay)
263        {
264                if (show)
265                {
266                        mDebugOverlay->show();
267                        mKdTreeOverlay->show();
268                }
269                else
270                {
271                        mDebugOverlay->hide();
272                        mKdTreeOverlay->hide();
273                }
274        }
275}
276
277void KdTreeAppListener::toggleVizCamera()
278{
279        static nodeVizMode = 0;
280
281        nodeVizMode = (nodeVizMode + 1) % NODEVIZ_MODES_NUM;
282
283        if (nodeVizMode != 0)
284        {
285                if (!mVizCamera)
286                {
287                        Viewport* tvp = mWindow->addViewport(mTopCam,
288                                VIZ_VIEWPORT_Z_ORDER, 0.66, 0.66, 0.34, 0.34);
289                        tvp->setBackgroundColour(ColourValue(1.0, 0.0, 0.0));
290                        tvp->setOverlaysEnabled(false);
291
292                        mTopCam->setAspectRatio(
293                                Real(tvp->getActualWidth())/Real(tvp->getActualHeight()));
294                        mVizCamera = true;
295                        mSceneMgr->setOption("VisualizeCulledNodes", &mVizCamera);
296                }
297
298                bool renderNodesForViz = (nodeVizMode == NODEVIZ_RENDER_NODES) ||
299                        (nodeVizMode == NODEVIZ_RENDER_NODES_AND_CONTENT);
300                bool renderNodesContentForViz = (nodeVizMode == NODEVIZ_RENDER_NODES_AND_CONTENT);
301
302                mSceneMgr->setOption("RenderNodesForViz", &renderNodesForViz);
303                mSceneMgr->setOption("RenderNodesContentForViz", &renderNodesContentForViz);
304        }
305        else
306        {
307                mWindow->removeViewport(VIZ_VIEWPORT_Z_ORDER);
308                mVizCamera = false;
309                mSceneMgr->setOption("VisualizeCulledNodes", &mVizCamera);
310        }
311}
312
313bool KdTreeAppListener::processUnbufferedKeyInput(const FrameEvent& evt)
314{
315        // moving the cull camera
316        if (mInputDevice->isKeyDown(KC_NUMPAD2))
317        {
318                mVizCamTransVect.y = -mMoveScale;
319        }
320        if (mInputDevice->isKeyDown(KC_NUMPAD8))
321        {
322                mVizCamTransVect.y = mMoveScale;
323        }
324        if (mInputDevice->isKeyDown(KC_NUMPAD4))
325        {
326                mVizCamTransVect.x = mMoveScale;
327        }
328        if (mInputDevice->isKeyDown(KC_NUMPAD6))
329        {
330                mVizCamTransVect.x = -mMoveScale;
331        }
332        if (mInputDevice->isKeyDown(KC_SUBTRACT))
333        {
334                mVizCamTransVect.z = mMoveScale;
335        }
336        if (mInputDevice->isKeyDown(KC_ADD))
337        {
338                mVizCamTransVect.z = -mMoveScale;
339        }
340
341        // stuff for the overlay
342        static String sNA = ": N/A";
343
344        static String bmOptions[] = { "Recursive", "PriorityQueue" };
345        static String bmOptionCaptions[] = { ": Recursive", ": PriorityQueue" };
346        static int bmOptionsSize = sizeof(bmOptions) / sizeof(String);
347        static int bmCurrent = 0;
348
349        //static String rmOptions[] = { "Recursive", "Stack", "StopAndWait", "CHC" };
350        static String rmOptions[] = { "INT", "VFC", "SWC", "CHC" };
351        static String rmOptionCaptions[] =
352        {
353                ": Internal Frustum Culling",
354                        ": View Frustum Culling",
355                        ": Stop and Wait Culling",
356                        ": Coherent Hierarchical Culling"
357        };
358        static int rmOptionsSize = sizeof(rmOptions) / sizeof (String);
359        static int rmCurrent = 0;
360
361        if ((mInputDevice->isKeyDown(KC_1) || mInputDevice->isKeyDown(KC_2)) && mTimeUntilNextToggle <= 0)
362        {
363                int currdepth;
364                if (mSceneMgr->getOption("KdTreeMaxDepth", &currdepth))
365                {
366                        if (mInputDevice->isKeyDown(KC_1))
367                                currdepth--;
368                        else if (mInputDevice->isKeyDown(KC_2))
369                                currdepth++;
370
371                        if (mSceneMgr->setOption("KdTreeMaxDepth", &currdepth))
372                        {
373                                mKdTreeMaxDepthInfo->setCaption(": " + StringConverter::toString(currdepth));
374                                int hl;
375                                if (mSceneMgr->getOption("HiLiteLevel", &hl))
376                                        mHighlightLevelInfo->setCaption(": " + StringConverter::toString(hl));
377                                else
378                                        mHighlightLevelInfo->setCaption(sNA);
379                        }
380                }
381                else
382                {
383                        mKdTreeMaxDepthInfo->setCaption(sNA);
384                        mHighlightLevelInfo->setCaption(sNA);
385                }
386
387                if (!mShowTree)
388                        mHighlightLevelInfo->setCaption(": off");
389
390                mTimeUntilNextToggle = 0.2;
391        }
392
393        if ((mInputDevice->isKeyDown(KC_3) || mInputDevice->isKeyDown(KC_4)) && mTimeUntilNextToggle <= 0)
394        {
395                int hl;
396                if (mSceneMgr->getOption("HiLiteLevel", &hl))
397                {
398                        if (mInputDevice->isKeyDown(KC_3))
399                                hl--;
400                        else if (mInputDevice->isKeyDown(KC_4))
401                                hl++;
402
403                        if (mSceneMgr->setOption("HiLiteLevel", &hl))
404                                mHighlightLevelInfo->setCaption(": " + StringConverter::toString(hl));
405                }
406                else
407                {
408                        mHighlightLevelInfo->setCaption(sNA);
409                }
410
411                if (!mShowTree)
412                        mHighlightLevelInfo->setCaption(": off");
413
414                mTimeUntilNextToggle = 0.2;
415        }
416
417
418        if ((mInputDevice->isKeyDown(KC_5) ||mInputDevice->isKeyDown(KC_6)) && mTimeUntilNextToggle <= 0)
419        {
420                Real kt;
421                if (mSceneMgr->getOption("KT", &kt))
422                {
423                        if (mInputDevice->isKeyDown(KC_5))
424                                kt -= 0.1;
425                        else if (mInputDevice->isKeyDown(KC_6))
426                                kt += 0.1;
427
428                        if (kt < 0.1)
429                                kt = 0.1;
430
431                        if (mSceneMgr->setOption("KT", &kt))
432                                mKTInfo->setCaption(": " + StringConverter::toString(kt));
433                }
434                else
435                {
436                        mKTInfo->setCaption(sNA);
437                }
438
439                mTimeUntilNextToggle = 0.2;
440        }
441
442        if ((mInputDevice->isKeyDown(KC_7) || mInputDevice->isKeyDown(KC_8)) && mTimeUntilNextToggle <= 0)
443        {
444                Real ki;
445                if (mSceneMgr->getOption("KI", &ki))
446                {
447                        if (mInputDevice->isKeyDown(KC_7))
448                                ki -= 0.1;
449                        else if (mInputDevice->isKeyDown(KC_8))
450                                ki += 0.1;
451
452                        if (ki < 0.1)
453                                ki = 0.1;
454
455                        if (mSceneMgr->setOption("KI", &ki))
456                                mKIInfo->setCaption(": " + StringConverter::toString(ki));
457                }
458                else
459                {
460                        mKIInfo->setCaption(sNA);
461                }
462
463                mTimeUntilNextToggle = 0.2;
464        }
465
466        if (mInputDevice->isKeyDown(KC_X) && mTimeUntilNextToggle <= 0)
467        {
468                String bm;
469                if (mSceneMgr->getOption("BuildMethod", &bm))
470                {
471                        for (int idx = 0; idx < bmOptionsSize; idx++)
472                                if (bmOptions[idx] == bm)
473                                        bmCurrent = idx;
474                        bmCurrent = (bmCurrent + 1) % bmOptionsSize;
475                        if (mSceneMgr->setOption("BuildMethod", &bmOptions[bmCurrent]))
476                                mBuildMethodInfo->setCaption(bmOptionCaptions[bmCurrent]);
477                }
478                else
479                {
480                        mBuildMethodInfo->setCaption(sNA);
481                }
482
483                mTimeUntilNextToggle = 0.5;
484        }
485
486        if (mInputDevice->isKeyDown(KC_SPACE) && mTimeUntilNextToggle <= 0)
487        {
488                String rm;
489                if (mSceneMgr->getOption("RenderMethod", &rm))
490                {
491                        for (int idx = 0; idx < rmOptionsSize; idx++)
492                                if (rmOptions[idx] == rm)
493                                        rmCurrent = idx;
494                        rmCurrent = (rmCurrent + 1) % rmOptionsSize;
495                        if (mSceneMgr->setOption("RenderMethod", &rmOptions[rmCurrent]))
496                                mRenderMethodInfo->setCaption(rmOptionCaptions[rmCurrent]);
497                }
498                else
499                {
500                        mRenderMethodInfo->setCaption(sNA);
501                }
502
503                mTimeUntilNextToggle = 0.5;
504        }
505
506        if (mInputDevice->isKeyDown(KC_Q) && mTimeUntilNextToggle <= 0)
507        {
508                mFreeMove = !mFreeMove;
509                String move = "N/A";
510                if (mFreeMove)
511                        move = ": Free";
512                else
513                        move = ": Ground";
514
515                mMovementInfo->setCaption(move);
516
517                mTimeUntilNextToggle = 0.5;
518        }
519
520
521        if (mInputDevice->isKeyDown(KC_BACK) && mTimeUntilNextToggle <= 0)
522        {
523                mSceneMgr->setOption("RebuildKdTree", 0);
524                mTimeUntilNextToggle = 1;
525        }
526
527        if (mInputDevice->isKeyDown(KC_N) && mTimeUntilNextToggle <= 0)
528        {
529                //Entity * ent = mSceneMgr->createEntity("randominsert" + StringConverter::toString(mSeqNum), "robot.mesh");
530                Entity * ent = mSceneMgr->createEntity("randominsert" + StringConverter::toString(mSeqNum), "razor.mesh");
531                //Vector3 position(Math::RangeRandom(100, 1125), -0, Math::RangeRandom(-1125, 1125));
532                Vector3 position(Math::RangeRandom(-5000, 5000), Math::RangeRandom(-5000, 5000), Math::RangeRandom(-5000, 5000));
533                //Quaternion orientation(Radian(Math::RangeRandom(-Math::PI, Math::PI)), Vector3::UNIT_Y);
534                Vector3 axis(Math::RangeRandom(-1,1),Math::RangeRandom(-1,1),Math::RangeRandom(-1,1));
535                axis.normalise();
536                Quaternion orientation(Radian(Math::RangeRandom(-Math::PI, Math::PI)), axis);
537                Vector3 scale(Math::RangeRandom(0.5, 5),Math::RangeRandom(0.5, 5),Math::RangeRandom(0.5, 5));
538                SceneNode * anchor = mSceneMgr->getSceneNode("AnchorNode");
539                SceneNode *sn = anchor->createChildSceneNode("RandomInsertNode" + StringConverter::toString(mSeqNum), position, orientation);
540                sn->attachObject(ent);
541                sn->setScale(scale);
542                mTimeUntilNextToggle = 0.5;
543                mSeqNum++;
544        }
545
546        if (mInputDevice->isKeyDown(KC_J) && mTimeUntilNextToggle <= 0)
547        {
548                if (mSeqNum > 0)
549                {
550                        mSeqNum--;
551                        mSceneMgr->destroySceneNode("RandomInsertNode" + StringConverter::toString(mSeqNum));
552                        mSceneMgr->destroyEntity("randominsert" + StringConverter::toString(mSeqNum));
553                        mTimeUntilNextToggle = 0.5;
554                }
555        }
556
557        if (mInputDevice->isKeyDown(KC_O) && mTimeUntilNextToggle <= 0)
558        {
559                LogManager::getSingleton().logMessage("############## Camera Position:");
560                LogManager::getSingleton().logMessage("############## " + StringConverter::toString(mCamera->getPosition()));
561                LogManager::getSingleton().logMessage("############## " + StringConverter::toString(mCamera->getOrientation()));
562                LogManager::getSingleton().logMessage("############## Cull Camera Position:");
563                LogManager::getSingleton().logMessage("############## " + StringConverter::toString(mTopCam->getPosition()));
564                LogManager::getSingleton().logMessage("############## " + StringConverter::toString(mTopCam->getOrientation()));
565                mTimeUntilNextToggle = 1.0;
566        }
567
568        if (mInputDevice->isKeyDown(KC_B) && mTimeUntilNextToggle <= 0)
569        {
570                mSceneMgr->showBoundingBoxes( ! mSceneMgr->getShowBoundingBoxes() );
571                mTimeUntilNextToggle = 0.5;
572        }
573
574        if (mInputDevice->isKeyDown(KC_C) && mTimeUntilNextToggle <= 0)
575        {
576                toggleVizCamera();
577                mTimeUntilNextToggle = 0.5;
578        }
579
580        if (mInputDevice->isKeyDown(KC_V) && mTimeUntilNextToggle <= 0)
581        {
582                mShowTree = !mShowTree;
583
584                if (mSceneMgr->getTypeName() == "OctreeSceneManager")
585                {
586                        //(static_cast<OctreeSceneManager *>(mSceneMgr))->setShowBoxes(mShowTree);
587                        mSceneMgr->setOption("ShowOctree", &mShowTree);
588                }
589                else if (mSceneMgr->getTypeName() == "KdTreeSceneManager")
590                {
591                        mSceneMgr->setOption("ShowKdTree", &mShowTree);
592                        //KdTreeSceneManager *sm = static_cast<KdTreeSceneManager *>(mSceneMgr);
593                        //sm->setShowBoxes(!sm->getShowBoxes());
594                        //(static_cast<KdTreeSceneManager *>(mSceneMgr))->setShowBoxes(mShowTree);
595                }
596
597                if (!mShowTree)
598                        mHighlightLevelInfo->setCaption(": off");
599                else
600                {
601                        int hl;
602                        if (mSceneMgr->getOption("HiLiteLevel", &hl))
603                                mHighlightLevelInfo->setCaption(": " + StringConverter::toString(hl));
604                        else
605                                mHighlightLevelInfo->setCaption(sNA);
606                }
607
608                mTimeUntilNextToggle = 0.5;
609        }
610
611        if (mInputDevice->isKeyDown(KC_G) && mTimeUntilNextToggle <= 0)
612        {
613                bool toggleShowAllBoxes;
614                mSceneMgr->getOption("ShowAllBoxes", &toggleShowAllBoxes);
615                toggleShowAllBoxes = !toggleShowAllBoxes;
616                mSceneMgr->setOption("ShowAllBoxes", &toggleShowAllBoxes);
617                mTimeUntilNextToggle = 0.2;
618        }
619
620        if (mInputDevice->isKeyDown(KC_H) && mTimeUntilNextToggle <= 0)
621        {
622                bool toggleShow;
623                mSceneMgr->getOption("ShowNodes", &toggleShow);
624                toggleShow = !toggleShow;
625                mSceneMgr->setOption("ShowNodes", &toggleShow);
626                mTimeUntilNextToggle = 0.2;
627        }
628
629        if (mInputDevice->isKeyDown(KC_P))
630        {
631                mWindow->writeContentsToTimestampedFile("Screenshot",".jpg");
632        }
633
634        if (mInputDevice->isKeyDown(KC_A))
635        {
636                // Move camera left
637                mTranslateVector.x = -mMoveScale;
638        }
639
640        if (mInputDevice->isKeyDown(KC_D))
641        {
642                // Move camera RIGHT
643                mTranslateVector.x = mMoveScale;
644        }
645
646        /* Move camera forward by keypress. */
647        if (mInputDevice->isKeyDown(KC_UP) || mInputDevice->isKeyDown(KC_W) )
648        {
649                mTranslateVector.z = -mMoveScale;
650        }
651
652        /* Move camera backward by keypress. */
653        if (mInputDevice->isKeyDown(KC_DOWN) || mInputDevice->isKeyDown(KC_S) )
654        {
655                mTranslateVector.z = mMoveScale;
656        }
657
658        if (mInputDevice->isKeyDown(KC_PGUP))
659        {
660                // Move camera up
661                mTranslateVector.y = mMoveScale;
662        }
663
664        if (mInputDevice->isKeyDown(KC_PGDOWN))
665        {
666                // Move camera down
667                mTranslateVector.y = -mMoveScale;
668        }
669
670        if (mInputDevice->isKeyDown(KC_RIGHT))
671        {
672                mCamNode->yaw(-mRotScale, Ogre::Node::TS_WORLD);
673        }
674
675        if (mInputDevice->isKeyDown(KC_LEFT))
676        {
677                mCamNode->yaw(mRotScale, Ogre::Node::TS_WORLD);
678        }
679
680        if( mInputDevice->isKeyDown( KC_ESCAPE) )
681        {           
682                return false;
683        }
684
685        // see if switching is on, and you want to toggle
686        if (mInputTypeSwitchingOn && mInputDevice->isKeyDown(KC_M) && mTimeUntilNextToggle <= 0)
687        {
688                switchMouseMode();
689                mTimeUntilNextToggle = 1;
690        }
691
692        if (mInputTypeSwitchingOn && mInputDevice->isKeyDown(KC_K) && mTimeUntilNextToggle <= 0)
693        {
694                // must be going from immediate keyboard to buffered keyboard
695                switchKeyMode();
696                mTimeUntilNextToggle = 1;
697        }
698        if (mInputDevice->isKeyDown(KC_F) && mTimeUntilNextToggle <= 0)
699        {
700                mStatsOn = !mStatsOn;
701                showDebugOverlay(mStatsOn);
702
703                mTimeUntilNextToggle = 1;
704        }
705        if (mInputDevice->isKeyDown(KC_T) && mTimeUntilNextToggle <= 0)
706        {
707                switch(mFiltering)
708                {
709                case TFO_BILINEAR:
710                        mFiltering = TFO_TRILINEAR;
711                        mAniso = 1;
712                        break;
713                case TFO_TRILINEAR:
714                        mFiltering = TFO_ANISOTROPIC;
715                        mAniso = 8;
716                        break;
717                case TFO_ANISOTROPIC:
718                        mFiltering = TFO_BILINEAR;
719                        mAniso = 1;
720                        break;
721                default:
722                        break;
723                }
724                MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
725                MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);
726
727
728                showDebugOverlay(mStatsOn);
729
730                mTimeUntilNextToggle = 1;
731        }
732
733        if (mInputDevice->isKeyDown(KC_SYSRQ) && mTimeUntilNextToggle <= 0)
734        {
735                char tmp[20];
736                sprintf(tmp, "screenshot_%d.png", ++mNumScreenShots);
737                mWindow->writeContentsToFile(tmp);
738                mTimeUntilNextToggle = 0.5;
739                mWindow->setDebugText(String("Wrote ") + tmp);
740        }
741
742        if (mInputDevice->isKeyDown(KC_R) && mTimeUntilNextToggle <=0)
743        {
744                mSceneDetailIndex = (mSceneDetailIndex+1)%3 ;
745                switch(mSceneDetailIndex) {
746                        case 0 : mCamera->setPolygonMode(PM_SOLID) ; break ;
747                        case 1 : mCamera->setPolygonMode(PM_WIREFRAME) ; break ;
748                        case 2 : mCamera->setPolygonMode(PM_POINTS) ; break ;
749                }
750                mTimeUntilNextToggle = 0.5;
751        }
752
753        static bool displayCameraDetails = false;
754        if (mInputDevice->isKeyDown(KC_P) && mTimeUntilNextToggle <= 0)
755        {
756                displayCameraDetails = !displayCameraDetails;
757                mTimeUntilNextToggle = 0.5;
758                if (!displayCameraDetails)
759                        mWindow->setDebugText("");
760        }
761        if (displayCameraDetails)
762        {
763                // Print camera details
764                mWindow->setDebugText("P: " + StringConverter::toString(mCamera->getDerivedPosition()) + " " +
765                        "O: " + StringConverter::toString(mCamera->getDerivedOrientation()));
766        }
767
768        // Return true to continue rendering
769        return true;
770}
771
772bool KdTreeAppListener::processUnbufferedMouseInput(const FrameEvent& evt)
773{
774        /* Rotation factors, may not be used if the second mouse button is pressed. */
775
776        /* If the second mouse button is pressed, then the mouse movement results in
777        sliding the camera, otherwise we rotate. */
778        if( mInputDevice->getMouseButton( 1 ) )
779        {
780                mTranslateVector.x += mInputDevice->getMouseRelativeX() * 0.13;
781                mTranslateVector.y -= mInputDevice->getMouseRelativeY() * 0.13;
782        }
783        else
784        {
785                mRotX = Degree(-mInputDevice->getMouseRelativeX() * 0.13);
786                mRotY = Degree(-mInputDevice->getMouseRelativeY() * 0.13);
787        }
788
789
790        return true;
791}
792
793void KdTreeAppListener::moveCamera()
794{
795
796        // Make all the changes to the camera
797        // Note that YAW direction is around a fixed axis (freelook style) rather than a natural YAW (e.g. airplane)
798        mCamNode->yaw(mRotX, Ogre::Node::TS_WORLD);
799        mCamNode->pitch(mRotY);
800        //mCamNode->moveRelative(mTranslateVector);
801        mCamNode->translate(mCamNode->getLocalAxes(), mTranslateVector);
802        mTopCam->moveRelative(mVizCamTransVect);
803
804        if (!mFreeMove)
805        {
806                Vector3 pos = mCamNode->getPosition();
807                RaySceneQuery * rsquery = mSceneMgr->createRayQuery(Ray(pos, Vector3::NEGATIVE_UNIT_Y));
808                RaySceneQueryResult& rsresult = rsquery->execute();
809
810                RaySceneQueryResult::iterator it = rsresult.begin();
811                RaySceneQueryResult::iterator end = rsresult.end();
812
813                while (it != end && it->movable)
814                {
815                        if (it->movable->getName() != "PlayerCam")
816                        {
817                                mCamNode->setPosition(pos.x, it->movable->getWorldBoundingBox().getCenter().y + 2, pos.z);
818                                break;
819                        }
820                        it++;
821                }
822                OGRE_DELETE(rsquery);
823        }
824}
825
826// Override frameStarted event to process that (don't care about frameEnded)
827bool KdTreeAppListener::frameStarted(const FrameEvent& evt)
828{
829        if(mWindow->isClosed())
830                return false;
831
832        if (!mInputTypeSwitchingOn)
833        {
834                mInputDevice->capture();
835        }
836
837
838        if ( !mUseBufferedInputMouse || !mUseBufferedInputKeys)
839        {
840                // one of the input modes is immediate, so setup what is needed for immediate mouse/key movement
841                if (mTimeUntilNextToggle >= 0)
842                        mTimeUntilNextToggle -= evt.timeSinceLastFrame;
843
844                // If this is the first frame, pick a speed
845                if (evt.timeSinceLastFrame == 0)
846                {
847                        mMoveScale = 1;
848                        mRotScale = 0.1;
849                }
850                // Otherwise scale movement units by time passed since last frame
851                else
852                {
853                        // Move about 100 units per second,
854                        mMoveScale = mMoveSpeed * evt.timeSinceLastFrame;
855                        // Take about 10 seconds for full rotation
856                        mRotScale = mRotateSpeed * evt.timeSinceLastFrame;
857                }
858                mRotX = 0;
859                mRotY = 0;
860                mTranslateVector = Vector3::ZERO;
861                mVizCamTransVect = Vector3::ZERO;
862        }
863
864        if (mUseBufferedInputKeys)
865        {
866                // no need to do any processing here, it is handled by event processor and
867                // you get the results as KeyEvents
868        }
869        else
870        {
871                if (processUnbufferedKeyInput(evt) == false)
872                {
873                        return false;
874                }
875        }
876        if (mUseBufferedInputMouse)
877        {
878                // no need to do any processing here, it is handled by event processor and
879                // you get the results as MouseEvents
880        }
881        else
882        {
883                if (processUnbufferedMouseInput(evt) == false)
884                {
885                        return false;
886                }
887        }
888
889        if ( !mUseBufferedInputMouse || !mUseBufferedInputKeys)
890        {
891                // one of the input modes is immediate, so update the movement vector
892
893                moveCamera();
894
895        }
896
897        //Camera        *followCam = mSceneMgr->getCamera("FollowCam");
898        //if (followCam->getAutoTrackTarget() != 0)
899        //{
900        //      // Move the death thingy & update lookat camera FOV
901        //      SceneNode *deathPivotNode = mSceneMgr->getSceneNode("deathPivotNode");
902        //      SceneNode *deathNode = mSceneMgr->getSceneNode("movingNode");
903        //      SceneNode *pivotNode = mSceneMgr->getSceneNode("pivotNode");
904
905        //      Vector3 fcpos = followCam->getPosition();
906        //      Vector3 oldpos = deathNode->getWorldPosition();
907
908        //      Radian deltaAngle = Radian(evt.timeSinceLastFrame / mRotationPeriod * Math::TWO_PI);
909        //      deathPivotNode->rotate(Vector3::UNIT_Y, deltaAngle);
910        //      pivotNode->rotate(Vector3::UNIT_Y, deltaAngle * 4);
911
912        //      Vector3 pos = deathNode->getWorldPosition();
913
914        //      Real olddist = (oldpos - fcpos).length();
915        //      Real dist = (pos - fcpos).length();
916
917        //      Radian oldfov = followCam->getFOVy();
918        //      Radian fov = Radian(olddist / dist) * oldfov;
919
920        //      followCam->setFOVy(fov);
921        //}
922
923        return true;
924}
925
926bool KdTreeAppListener::frameEnded(const FrameEvent& evt)
927{
928        updateStats();
929        return true;
930}
931
932void KdTreeAppListener::switchMouseMode()
933{
934        mUseBufferedInputMouse = !mUseBufferedInputMouse;
935        mInputDevice->setBufferedInput(mUseBufferedInputKeys, mUseBufferedInputMouse);
936}
937void KdTreeAppListener::switchKeyMode()
938{
939        mUseBufferedInputKeys = !mUseBufferedInputKeys;
940        mInputDevice->setBufferedInput(mUseBufferedInputKeys, mUseBufferedInputMouse);
941}
942
943void KdTreeAppListener::keyClicked(KeyEvent* e)
944{
945        if (e->getKeyChar() == 'm')
946        {
947                switchMouseMode();
948        }
949        else if (e->getKeyChar() == 'k')
950        {
951
952                switchKeyMode();
953        }
954}
Note: See TracBrowser for help on using the repository browser.