OgreBullet: Demos/include/exampleframelistener.h Source File

00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004     (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://www.ogre3d.org/
00006 
00007 Copyright (c) 2000-2006 Torus Knot Software Ltd
00008 Also see acknowledgements in Readme.html
00009 
00010 You may use this sample code for anything you like, it is not covered by the
00011 LGPL like the rest of the engine.
00012 -----------------------------------------------------------------------------
00013 */
00014 /*
00015 -----------------------------------------------------------------------------
00016 Filename:    ExampleFrameListener.h
00017 Description: Defines an example frame listener which responds to frame events.
00018 This frame listener just moves a specified camera around based on
00019 keyboard and mouse movements.
00020 Mouse:    Freelook
00021 W or Up:  Forward
00022 S or Down:Backward
00023 A:        Step left
00024 D:        Step right
00025              PgUp:     Move upwards
00026              PgDown:   Move downwards
00027              F:        Toggle frame rate stats on/off
00028                          R:        Render mode
00029              T:        Cycle texture filtering
00030                        Bilinear, Trilinear, Anisotropic(8)
00031              P:        Toggle on/off display of camera position / orientation
00032 -----------------------------------------------------------------------------
00033 */
00034 
00035 #ifndef __ExampleFrameListener_H__
00036 #define __ExampleFrameListener_H__
00037 
00038 #include "Ogre.h"
00039 #include "OgreStringConverter.h"
00040 #include "OgreException.h"
00041 
00042 //Use this define to signify OIS will be used as a DLL
00043 //(so that dll import/export macros are in effect)
00044 #define OIS_DYNAMIC_LIB
00045 
00046 // NOTICE: You may need to change this line to <OIS.h> if you build OIS from source.
00047 #include <OIS\OIS.h>
00048 
00049 using namespace Ogre;
00050 
00051 class ExampleFrameListener: public FrameListener, public WindowEventListener
00052 {
00053 protected:
00054         virtual void updateStats(void)
00055         {
00056                 static String currFps = "Current FPS: ";
00057                 static String avgFps = "Average FPS: ";
00058                 static String bestFps = "Best FPS: ";
00059                 static String worstFps = "Worst FPS: ";
00060                 static String tris = "Triangle Count: ";
00061                 static String batches = "Batch Count: ";
00062 
00063                 // update stats when necessary
00064                 try {
00065                         OverlayElement* guiAvg = OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");
00066                         OverlayElement* guiCurr = OverlayManager::getSingleton().getOverlayElement("Core/CurrFps");
00067                         OverlayElement* guiBest = OverlayManager::getSingleton().getOverlayElement("Core/BestFps");
00068                         OverlayElement* guiWorst = OverlayManager::getSingleton().getOverlayElement("Core/WorstFps");
00069 
00070                         const RenderTarget::FrameStats& stats = mWindow->getStatistics();
00071                         guiAvg->setCaption(avgFps + StringConverter::toString(stats.avgFPS));
00072                         guiCurr->setCaption(currFps + StringConverter::toString(stats.lastFPS));
00073                         guiBest->setCaption(bestFps + StringConverter::toString(stats.bestFPS)
00074                                 +" "+StringConverter::toString(stats.bestFrameTime)+" ms");
00075                         guiWorst->setCaption(worstFps + StringConverter::toString(stats.worstFPS)
00076                                 +" "+StringConverter::toString(stats.worstFrameTime)+" ms");
00077 
00078                         OverlayElement* guiTris = OverlayManager::getSingleton().getOverlayElement("Core/NumTris");
00079                         guiTris->setCaption(tris + StringConverter::toString(stats.triangleCount));
00080 
00081                         OverlayElement* guiBatches = OverlayManager::getSingleton().getOverlayElement("Core/NumBatches");
00082                         guiBatches->setCaption(batches + StringConverter::toString(stats.batchCount));
00083 
00084                         OverlayElement* guiDbg = OverlayManager::getSingleton().getOverlayElement("Core/DebugText");
00085                         guiDbg->setCaption(mDebugText);
00086                 }
00087                 catch(...) { /* ignore */ }
00088         }
00089 
00090 public:
00091         // Constructor takes a RenderWindow because it uses that to determine input context
00092         ExampleFrameListener(RenderWindow* win, Camera* cam, bool bufferedKeys = false, bool bufferedMouse = false,
00093                              bool bufferedJoy = false ) :
00094                 mCamera(cam), mTranslateVector(Vector3::ZERO), mCurrentSpeed(0), mWindow(win), mStatsOn(true), mNumScreenShots(0),
00095                 mMoveScale(0.0f), mRotScale(0.0f), mTimeUntilNextToggle(0), mFiltering(TFO_BILINEAR),
00096                 mAniso(1), mSceneDetailIndex(0), mMoveSpeed(100), mRotateSpeed(36), mDebugOverlay(0),
00097                 mInputManager(0), mMouse(0), mKeyboard(0), mJoy(0)
00098         {
00099 
00100                 mDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay");
00101 
00102                 LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");
00103                 OIS::ParamList pl;
00104                 size_t windowHnd = 0;
00105                 std::ostringstream windowHndStr;
00106 
00107                 win->getCustomAttribute("WINDOW", &windowHnd);
00108                 windowHndStr << windowHnd;
00109                 pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
00110 
00111                 mInputManager = OIS::InputManager::createInputSystem( pl );
00112 
00113                 //Create all devices (We only catch joystick exceptions here, as, most people have Key/Mouse)
00114                 mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject( OIS::OISKeyboard, bufferedKeys ));
00115                 mMouse = static_cast<OIS::Mouse*>(mInputManager->createInputObject( OIS::OISMouse, bufferedMouse ));
00116                 try {
00117                         mJoy = static_cast<OIS::JoyStick*>(mInputManager->createInputObject( OIS::OISJoyStick, bufferedJoy ));
00118                 }
00119                 catch(...) {
00120                         mJoy = 0;
00121                 }
00122 
00123                 //Set initial mouse clipping size
00124                 windowResized(mWindow);
00125 
00126                 showDebugOverlay(true);
00127 
00128                 //Register as a Window listener
00129                 WindowEventUtilities::addWindowEventListener(mWindow, this);
00130         }
00131 
00132         //Adjust mouse clipping area
00133         virtual void windowResized(RenderWindow* rw)
00134         {
00135                 unsigned int width, height, depth;
00136                 int left, top;
00137                 rw->getMetrics(width, height, depth, left, top);
00138 
00139                 const OIS::MouseState &ms = mMouse->getMouseState();
00140                 ms.width = width;
00141                 ms.height = height;
00142         }
00143 
00144         //Unattach OIS before window shutdown (very important under Linux)
00145         virtual void windowClosed(RenderWindow* rw)
00146         {
00147                 //Only close for window that created OIS (the main window in these demos)
00148                 if( rw == mWindow )
00149                 {
00150                         if( mInputManager )
00151                         {
00152                                 mInputManager->destroyInputObject( mMouse );
00153                                 mInputManager->destroyInputObject( mKeyboard );
00154                                 mInputManager->destroyInputObject( mJoy );
00155 
00156                                 OIS::InputManager::destroyInputSystem(mInputManager);
00157                                 mInputManager = 0;
00158                         }
00159                 }
00160         }
00161 
00162         virtual ~ExampleFrameListener()
00163         {
00164                 //Remove ourself as a Window listener
00165                 WindowEventUtilities::removeWindowEventListener(mWindow, this);
00166                 windowClosed(mWindow);
00167         }
00168 
00169         virtual bool processUnbufferedKeyInput(const FrameEvent& evt)
00170         {
00171 
00172                 if(mKeyboard->isKeyDown(OIS::KC_A))
00173                         mTranslateVector.x = -mMoveScale;       // Move camera left
00174 
00175                 if(mKeyboard->isKeyDown(OIS::KC_D))
00176                         mTranslateVector.x = mMoveScale;        // Move camera RIGHT
00177 
00178                 if(mKeyboard->isKeyDown(OIS::KC_UP) || mKeyboard->isKeyDown(OIS::KC_W) )
00179                         mTranslateVector.z = -mMoveScale;       // Move camera forward
00180 
00181                 if(mKeyboard->isKeyDown(OIS::KC_DOWN) || mKeyboard->isKeyDown(OIS::KC_S) )
00182                         mTranslateVector.z = mMoveScale;        // Move camera backward
00183 
00184                 if(mKeyboard->isKeyDown(OIS::KC_PGUP))
00185                         mTranslateVector.y = mMoveScale;        // Move camera up
00186 
00187                 if(mKeyboard->isKeyDown(OIS::KC_PGDOWN))
00188                         mTranslateVector.y = -mMoveScale;       // Move camera down
00189 
00190                 if(mKeyboard->isKeyDown(OIS::KC_RIGHT))
00191                         mCamera->yaw(-mRotScale);
00192 
00193                 if(mKeyboard->isKeyDown(OIS::KC_LEFT))
00194                         mCamera->yaw(mRotScale);
00195 
00196                 if( mKeyboard->isKeyDown(OIS::KC_ESCAPE) || mKeyboard->isKeyDown(OIS::KC_Q) )
00197                         return false;
00198 
00199         if( mKeyboard->isKeyDown(OIS::KC_F) && mTimeUntilNextToggle <= 0 )
00200                 {
00201                         mStatsOn = !mStatsOn;
00202                         showDebugOverlay(mStatsOn);
00203                         mTimeUntilNextToggle = 1;
00204                 }
00205 
00206                 if( mKeyboard->isKeyDown(OIS::KC_T) && mTimeUntilNextToggle <= 0 )
00207                 {
00208                         switch(mFiltering)
00209                         {
00210                         case TFO_BILINEAR:
00211                                 mFiltering = TFO_TRILINEAR;
00212                                 mAniso = 1;
00213                                 break;
00214                         case TFO_TRILINEAR:
00215                                 mFiltering = TFO_ANISOTROPIC;
00216                                 mAniso = 8;
00217                                 break;
00218                         case TFO_ANISOTROPIC:
00219                                 mFiltering = TFO_BILINEAR;
00220                                 mAniso = 1;
00221                                 break;
00222                         default: break;
00223                         }
00224                         MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
00225                         MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);
00226 
00227                         showDebugOverlay(mStatsOn);
00228                         mTimeUntilNextToggle = 1;
00229                 }
00230 
00231                 if(mKeyboard->isKeyDown(OIS::KC_SYSRQ) && mTimeUntilNextToggle <= 0)
00232                 {
00233                         std::ostringstream ss;
00234                         ss << "screenshot_" << ++mNumScreenShots << ".png";
00235                         mWindow->writeContentsToFile(ss.str());
00236                         mTimeUntilNextToggle = 0.5;
00237                         mDebugText = "Saved: " + ss.str();
00238                 }
00239 
00240                 if(mKeyboard->isKeyDown(OIS::KC_R) && mTimeUntilNextToggle <=0)
00241                 {
00242                         mSceneDetailIndex = (mSceneDetailIndex+1)%3 ;
00243                         switch(mSceneDetailIndex) {
00244                                 case 0 : mCamera->setPolygonMode(PM_SOLID); break;
00245                                 case 1 : mCamera->setPolygonMode(PM_WIREFRAME); break;
00246                                 case 2 : mCamera->setPolygonMode(PM_POINTS); break;
00247                         }
00248                         mTimeUntilNextToggle = 0.5;
00249                 }
00250 
00251                 static bool displayCameraDetails = false;
00252                 if(mKeyboard->isKeyDown(OIS::KC_P) && mTimeUntilNextToggle <= 0)
00253                 {
00254                         displayCameraDetails = !displayCameraDetails;
00255                         mTimeUntilNextToggle = 0.5;
00256                         if (!displayCameraDetails)
00257                                 mDebugText = "";
00258                 }
00259 
00260                 // Print camera details
00261                 if(displayCameraDetails)
00262                         mDebugText = "P: " + StringConverter::toString(mCamera->getDerivedPosition()) +
00263                                                  " " + "O: " + StringConverter::toString(mCamera->getDerivedOrientation());
00264 
00265                 // Return true to continue rendering
00266                 return true;
00267         }
00268 
00269         virtual bool processUnbufferedMouseInput(const FrameEvent& evt)
00270         {
00271 
00272                 // Rotation factors, may not be used if the second mouse button is pressed
00273                 // 2nd mouse button - slide, otherwise rotate
00274                 const OIS::MouseState &ms = mMouse->getMouseState();
00275                 if( ms.buttonDown( OIS::MB_Right ) )
00276                 {
00277                         mTranslateVector.x += ms.X.rel * 0.13;
00278                         mTranslateVector.y -= ms.Y.rel * 0.13;
00279                 }
00280                 else
00281                 {
00282                         mRotX = Degree(-ms.X.rel * 0.13);
00283                         mRotY = Degree(-ms.Y.rel * 0.13);
00284                 }
00285 
00286                 return true;
00287         }
00288 
00289         virtual void moveCamera()
00290         {
00291                 // Make all the changes to the camera
00292                 // Note that YAW direction is around a fixed axis (freelook style) rather than a natural YAW
00293                 //(e.g. airplane)
00294                 mCamera->yaw(mRotX);
00295                 mCamera->pitch(mRotY);
00296                 mCamera->moveRelative(mTranslateVector);
00297         }
00298 
00299         virtual void showDebugOverlay(bool show)
00300         {
00301                 if (mDebugOverlay)
00302                 {
00303                         if (show)
00304                                 mDebugOverlay->show();
00305                         else
00306                                 mDebugOverlay->hide();
00307                 }
00308         }
00309 
00310         // Override frameRenderingQueued event to process that (don't care about frameEnded)
00311         bool frameRenderingQueued(const FrameEvent& evt)
00312         {
00313 
00314                 if(mWindow->isClosed()) return false;
00315 
00316                 mSpeedLimit = mMoveScale * evt.timeSinceLastFrame;
00317 
00318                 //Need to capture/update each device
00319                 mKeyboard->capture();
00320                 mMouse->capture();
00321                 if( mJoy ) mJoy->capture();
00322 
00323                 bool buffJ = (mJoy) ? mJoy->buffered() : true;
00324 
00325         Ogre::Vector3 lastMotion = mTranslateVector;
00326 
00327                 //Check if one of the devices is not buffered
00328                 if( !mMouse->buffered() || !mKeyboard->buffered() || !buffJ )
00329                 {
00330                         // one of the input modes is immediate, so setup what is needed for immediate movement
00331                         if (mTimeUntilNextToggle >= 0)
00332                                 mTimeUntilNextToggle -= evt.timeSinceLastFrame;
00333 
00334                         // Move about 100 units per second
00335                         mMoveScale = mMoveSpeed * evt.timeSinceLastFrame;
00336                         // Take about 10 seconds for full rotation
00337                         mRotScale = mRotateSpeed * evt.timeSinceLastFrame;
00338 
00339                         mRotX = 0;
00340                         mRotY = 0;
00341                         mTranslateVector = Ogre::Vector3::ZERO;
00342 
00343                 }
00344 
00345                 //Check to see which device is not buffered, and handle it
00346                 if( !mKeyboard->buffered() )
00347                         if( processUnbufferedKeyInput(evt) == false )
00348                                 return false;
00349                 if( !mMouse->buffered() )
00350                         if( processUnbufferedMouseInput(evt) == false )
00351                                 return false;
00352 
00353                 // ramp up / ramp down speed
00354         if (mTranslateVector == Ogre::Vector3::ZERO)
00355                 {
00356                         // decay (one third speed)
00357                         mCurrentSpeed -= evt.timeSinceLastFrame * 0.3;
00358                         mTranslateVector = lastMotion;
00359                 }
00360                 else
00361                 {
00362                         // ramp up
00363                         mCurrentSpeed += evt.timeSinceLastFrame;
00364 
00365                 }
00366                 // Limit motion speed
00367                 if (mCurrentSpeed > 1.0)
00368                         mCurrentSpeed = 1.0;
00369                 if (mCurrentSpeed < 0.0)
00370                         mCurrentSpeed = 0.0;
00371 
00372                 mTranslateVector *= mCurrentSpeed;
00373 
00374 
00375                 if( !mMouse->buffered() || !mKeyboard->buffered() || !buffJ )
00376                         moveCamera();
00377 
00378                 return true;
00379         }
00380 
00381         bool frameEnded(const FrameEvent& evt)
00382         {
00383                 updateStats();
00384                 return true;
00385         }
00386 
00387 protected:
00388         Camera* mCamera;
00389 
00390         Vector3 mTranslateVector;
00391         Real mCurrentSpeed;
00392         RenderWindow* mWindow;
00393         bool mStatsOn;
00394 
00395         std::string mDebugText;
00396 
00397         unsigned int mNumScreenShots;
00398         float mMoveScale;
00399         float mSpeedLimit;
00400         Degree mRotScale;
00401         // just to stop toggles flipping too fast
00402         Real mTimeUntilNextToggle ;
00403         Radian mRotX, mRotY;
00404         TextureFilterOptions mFiltering;
00405         int mAniso;
00406 
00407         int mSceneDetailIndex ;
00408         Real mMoveSpeed;
00409         Degree mRotateSpeed;
00410         Overlay* mDebugOverlay;
00411 
00412         //OIS Input devices
00413         OIS::InputManager* mInputManager;
00414         OIS::Mouse*    mMouse;
00415         OIS::Keyboard* mKeyboard;
00416         OIS::JoyStick* mJoy;
00417 };
00418 
00419 #endif