Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/main_reto/src/RunManager.cpp @ 126

Last change on this file since 126 was 126, checked in by rgrieder, 17 years ago
File size: 11.0 KB
Line 
1#include "RunManager.h"
2
3
4// Constructor takes a RenderWindow because it uses that to determine input context
5RunManager::RunManager(OgreControl * mOgre, bool bufferedKeys, bool bufferedMouse,
6                                           bool bufferedJoy ) :
7mOgre(mOgre), mWindow(mOgre->getRenderWindow()),
8mTranslateVector(Vector3::ZERO), mStatsOn(true), mNumScreenShots(0),
9mMoveScale(0.0f), mRotScale(0.0f), mTimeUntilNextToggle(0), mFiltering(TFO_BILINEAR),
10mAniso(1), mSceneDetailIndex(0), mMoveSpeed(100), mRotateSpeed(36), mDebugOverlay(0),
11mInputManager(0), mMouse(0), mKeyboard(0), mJoy(0)
12{
13        // create new SceneManger
14        mSceneMgr = mOgre->getRoot()->createSceneManager(ST_GENERIC,"mScene");
15
16
17        // create various objects
18        // background scene
19        mScene = new OrxonoxScene(mSceneMgr);
20        // create camera and viewport
21        createCamera();
22        createViewports();
23        mScene->initialise();
24
25        // create a steerable SceneNode for the spaceship to be attached to
26        /*mShipNode = new SteerableNode(mSceneMgr, "shipNode");
27        mShipNode->setPosition(Vector3(20, 20, 20));
28        mSceneMgr->getRootSceneNode()->addChild(mShipNode);*/
29
30        // spaceship
31        /*mShip = static_cast<OrxonoxShip*>(mSceneMgr->createEntity("ship", "ninja.mesh"));
32        mShipNode->attachObject(mShip);*/
33
34
35        using namespace OIS;
36
37        mDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay");
38
39        LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");
40        ParamList pl;
41        size_t windowHnd = 0;
42        std::ostringstream windowHndStr;
43
44        mWindow->getCustomAttribute("WINDOW", &windowHnd);
45        windowHndStr << windowHnd;
46        pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
47
48        mInputManager = InputManager::createInputSystem( pl );
49
50        //Create all devices (We only catch joystick exceptions here, as, most people have Key/Mouse)
51        mKeyboard = static_cast<Keyboard*>(mInputManager->createInputObject( OISKeyboard, bufferedKeys ));
52        mMouse = static_cast<Mouse*>(mInputManager->createInputObject( OISMouse, bufferedMouse ));
53        try {
54                mJoy = static_cast<JoyStick*>(mInputManager->createInputObject( OISJoyStick, bufferedJoy ));
55        }
56        catch(...) {
57                mJoy = 0;
58        }
59
60        //Set initial mouse clipping size
61        windowResized(mWindow);
62
63        showDebugOverlay(true);
64
65        //Register as a Window listener
66        WindowEventUtilities::addWindowEventListener(mWindow, this);
67}
68
69
70RunManager::~RunManager()
71{
72        //Remove ourself as a Window listener
73        WindowEventUtilities::removeWindowEventListener(mWindow, this);
74        windowClosed(mWindow);
75
76        if (mScene)
77                delete mScene;
78
79        /*if (mShipNode)
80                delete mShipNode;
81
82        if (mShip)
83                delete mShip;*/
84}
85
86
87// Override frameStarted event to process that (don't care about frameEnded)
88bool RunManager::tick(unsigned long time, float deltaTime)
89{
90        mTime = time;
91
92        updateStats();
93       
94        mScene->tick(time, deltaTime);
95
96        using namespace OIS;
97
98        if(mWindow->isClosed()) return false;
99
100        //Need to capture/update each device
101        mKeyboard->capture();
102        mMouse->capture();
103        if( mJoy ) mJoy->capture();
104
105        bool buffJ = (mJoy) ? mJoy->buffered() : true;
106
107        //Check if one of the devices is not buffered
108        if( !mMouse->buffered() || !mKeyboard->buffered() || !buffJ )
109        {
110                // one of the input modes is immediate, so setup what is needed for immediate movement
111                if (mTimeUntilNextToggle >= 0)
112                        mTimeUntilNextToggle -= deltaTime;
113
114                // If this is the first frame, pick a speed
115                if (deltaTime == 0)
116                {
117                        mMoveScale = 1;
118                        mRotScale = 0.1;
119                }
120                // Otherwise scale movement units by time passed since last frame
121                else
122                {
123                        // Move about 100 units per second,
124                        mMoveScale = mMoveSpeed * deltaTime;
125                        // Take about 10 seconds for full rotation
126                        mRotScale = mRotateSpeed * deltaTime;
127                }
128                mRotX = 0;
129                mRotY = 0;
130                mTranslateVector = Ogre::Vector3::ZERO;
131        }
132
133        //Check to see which device is not buffered, and handle it
134        if( !mKeyboard->buffered() )
135                if( processUnbufferedKeyInput() == false )
136                        return false;
137        if( !mMouse->buffered() )
138                if( processUnbufferedMouseInput() == false )
139                        return false;
140
141        if( !mMouse->buffered() || !mKeyboard->buffered() || !buffJ )
142                moveCamera();
143
144        return true;
145}
146
147
148//Adjust mouse clipping area
149void RunManager::windowResized(RenderWindow* rw)
150{
151        unsigned int width, height, depth;
152        int left, top;
153        rw->getMetrics(width, height, depth, left, top);
154
155        const OIS::MouseState &ms = mMouse->getMouseState();
156        ms.width = width;
157        ms.height = height;
158}
159
160
161//Unattach OIS before window shutdown (very important under Linux)
162void RunManager::windowClosed(RenderWindow* rw)
163{
164        //Only close for window that created OIS (the main window in these demos)
165        if( rw == mWindow )
166        {
167                if( mInputManager )
168                {
169                        mInputManager->destroyInputObject( mMouse );
170                        mInputManager->destroyInputObject( mKeyboard );
171                        mInputManager->destroyInputObject( mJoy );
172
173                        OIS::InputManager::destroyInputSystem(mInputManager);
174                        mInputManager = 0;
175                }
176        }
177}
178
179
180bool RunManager::processUnbufferedKeyInput()
181{
182        using namespace OIS;
183
184        if(mKeyboard->isKeyDown(KC_A))
185                mTranslateVector.x = -mMoveScale;       // Move camera left
186
187        if(mKeyboard->isKeyDown(KC_D))
188                mTranslateVector.x = mMoveScale;        // Move camera RIGHT
189
190        if(mKeyboard->isKeyDown(KC_UP) || mKeyboard->isKeyDown(KC_W) )
191                mTranslateVector.z = -mMoveScale;       // Move camera forward
192
193        if(mKeyboard->isKeyDown(KC_DOWN) || mKeyboard->isKeyDown(KC_S) )
194                mTranslateVector.z = mMoveScale;        // Move camera backward
195
196        if(mKeyboard->isKeyDown(KC_PGUP))
197                mTranslateVector.y = mMoveScale;        // Move camera up
198
199        if(mKeyboard->isKeyDown(KC_PGDOWN))
200                mTranslateVector.y = -mMoveScale;       // Move camera down
201
202        if(mKeyboard->isKeyDown(KC_RIGHT))
203                mCamera->yaw(-mRotScale);
204
205        if(mKeyboard->isKeyDown(KC_LEFT))
206                mCamera->yaw(mRotScale);
207
208        if( mKeyboard->isKeyDown(KC_ESCAPE) || mKeyboard->isKeyDown(KC_Q) )
209                return false;
210
211        if( mKeyboard->isKeyDown(KC_F) && mTimeUntilNextToggle <= 0 )
212        {
213                mStatsOn = !mStatsOn;
214                showDebugOverlay(mStatsOn);
215                mTimeUntilNextToggle = 1;
216        }
217
218        if( mKeyboard->isKeyDown(KC_T) && mTimeUntilNextToggle <= 0 )
219        {
220                switch(mFiltering)
221                {
222                case TFO_BILINEAR:
223                        mFiltering = TFO_TRILINEAR;
224                        mAniso = 1;
225                        break;
226                case TFO_TRILINEAR:
227                        mFiltering = TFO_ANISOTROPIC;
228                        mAniso = 8;
229                        break;
230                case TFO_ANISOTROPIC:
231                        mFiltering = TFO_BILINEAR;
232                        mAniso = 1;
233                        break;
234                default: break;
235                }
236                MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
237                MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);
238
239                showDebugOverlay(mStatsOn);
240                mTimeUntilNextToggle = 1;
241        }
242
243        if(mKeyboard->isKeyDown(KC_SYSRQ) && mTimeUntilNextToggle <= 0)
244        {
245                std::ostringstream ss;
246                ss << "screenshot_" << ++mNumScreenShots << ".png";
247                mWindow->writeContentsToFile(ss.str());
248                mTimeUntilNextToggle = 0.5;
249                mDebugText = "Saved: " + ss.str();
250        }
251
252        if(mKeyboard->isKeyDown(KC_R) && mTimeUntilNextToggle <=0)
253        {
254                mSceneDetailIndex = (mSceneDetailIndex+1)%3 ;
255                switch(mSceneDetailIndex) {
256                                case 0 : mCamera->setPolygonMode(PM_SOLID); break;
257                                case 1 : mCamera->setPolygonMode(PM_WIREFRAME); break;
258                                case 2 : mCamera->setPolygonMode(PM_POINTS); break;
259                }
260                mTimeUntilNextToggle = 0.5;
261        }
262
263        static bool displayCameraDetails = false;
264        if(mKeyboard->isKeyDown(KC_P) && mTimeUntilNextToggle <= 0)
265        {
266                displayCameraDetails = !displayCameraDetails;
267                mTimeUntilNextToggle = 0.5;
268                if (!displayCameraDetails)
269                        mDebugText = "";
270        }
271
272        // Print camera details
273        if(displayCameraDetails)
274                mDebugText = "P: " + StringConverter::toString(mCamera->getDerivedPosition()) +
275                " " + "O: " + StringConverter::toString(mCamera->getDerivedOrientation());
276
277        // Return true to continue rendering
278        return true;
279}
280
281
282bool RunManager::processUnbufferedMouseInput()
283{
284        using namespace OIS;
285
286        // Rotation factors, may not be used if the second mouse button is pressed
287        // 2nd mouse button - slide, otherwise rotate
288        const MouseState &ms = mMouse->getMouseState();
289        if( ms.buttonDown( MB_Right ) )
290        {
291                mTranslateVector.x += ms.X.rel * 0.13;
292                mTranslateVector.y -= ms.Y.rel * 0.13;
293        }
294        else
295        {
296                mRotX = Degree(-ms.X.rel * 0.13);
297                mRotY = Degree(-ms.Y.rel * 0.13);
298        }
299
300        return true;
301}
302
303
304void RunManager::moveCamera()
305{
306        // Make all the changes to the camera
307        // Note that YAW direction is around a fixed axis (freelook style) rather than a natural YAW
308        //(e.g. airplane)
309        mCamera->yaw(mRotX);
310        mCamera->pitch(mRotY);
311        mCamera->moveRelative(mTranslateVector);
312}
313
314
315void RunManager::showDebugOverlay(bool show)
316{
317        if (mDebugOverlay)
318        {
319                if (show)
320                        mDebugOverlay->show();
321                else
322                        mDebugOverlay->hide();
323        }
324}
325
326
327
328void RunManager::updateStats(void)
329{
330        static String currFps = "Current FPS: ";
331        static String avgFps = "Average FPS: ";
332        static String bestFps = "Best FPS: ";
333        static String worstFps = "Worst FPS: ";
334        static String tris = "Triangle Count: ";
335        static String batches = "Batch Count: ";
336
337        // update stats when necessary
338        try {
339                OverlayElement* guiAvg = OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");
340                OverlayElement* guiCurr = OverlayManager::getSingleton().getOverlayElement("Core/CurrFps");
341                OverlayElement* guiBest = OverlayManager::getSingleton().getOverlayElement("Core/BestFps");
342                OverlayElement* guiWorst = OverlayManager::getSingleton().getOverlayElement("Core/WorstFps");
343                //OverlayElement* asfd = OverlayManager::getSingleton().getOverlayElement(
344
345                const RenderTarget::FrameStats& stats = mWindow->getStatistics();
346                guiAvg->setCaption(avgFps + StringConverter::toString(stats.avgFPS));
347                guiCurr->setCaption(currFps + StringConverter::toString(stats.lastFPS));
348                guiBest->setCaption(bestFps + StringConverter::toString(stats.bestFPS)
349                        +" "+StringConverter::toString(stats.bestFrameTime)+" ms");
350                guiWorst->setCaption(worstFps + StringConverter::toString(stats.worstFPS)
351                        +" "+StringConverter::toString(stats.worstFrameTime)+" ms");
352
353                OverlayElement* guiTris = OverlayManager::getSingleton().getOverlayElement("Core/NumTris");
354                guiTris->setCaption(tris + StringConverter::toString(stats.triangleCount));
355
356                OverlayElement* guiBatches = OverlayManager::getSingleton().getOverlayElement("Core/NumBatches");
357                guiBatches->setCaption(batches + StringConverter::toString(stats.batchCount));
358
359                OverlayElement* guiDbg = OverlayManager::getSingleton().getOverlayElement("Core/DebugText");
360                guiDbg->setCaption(mDebugText);
361        }
362        catch(...) { /* ignore */ }
363}
364
365
366
367// create camera
368void RunManager::createCamera(void)
369{
370        mCamera = mSceneMgr->createCamera("PlayerCam");
371        mCamera->setNearClipDistance(5);
372        mCamera->setPosition(Vector3(0,10,500));
373        mCamera->lookAt(Vector3(0,0,0));
374}
375
376
377void RunManager::createViewports(void)
378{
379        // Create one viewport, entire window
380        Viewport* vp = mWindow->addViewport(mCamera);
381        vp->setBackgroundColour(ColourValue(0,0,0));
382
383        // Alter the camera aspect ratio to match the viewport
384        mCamera->setAspectRatio(
385                Real(vp->getActualWidth()) / Real(vp->getActualHeight()));
386
387        // Set default mipmap level (NB some APIs ignore this)
388        TextureManager::getSingleton().setDefaultNumMipmaps(5);
389}
390
391
Note: See TracBrowser for help on using the repository browser.