source: GTP/trunk/App/Demos/Vis/KdTreeDemo/OGRE/include/TestKdTreeAppListener.h @ 1165

Revision 1165, 26.9 KB checked in by szydlowski, 18 years ago (diff)

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