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