[Orxonox-commit 2107] r6823 - code/branches/fps/src/libraries/tools/bsp
landauf at orxonox.net
landauf at orxonox.net
Sun May 2 23:49:02 CEST 2010
Author: landauf
Date: 2010-05-02 23:49:01 +0200 (Sun, 02 May 2010)
New Revision: 6823
Added:
code/branches/fps/src/libraries/tools/bsp/ExampleApplication.h
code/branches/fps/src/libraries/tools/bsp/ExampleFrameListener.h
Log:
added ogre sample files for BZN bsp renderer (from ogre 1.6.5, but i think the version doesn't really matter)
Added: code/branches/fps/src/libraries/tools/bsp/ExampleApplication.h
===================================================================
--- code/branches/fps/src/libraries/tools/bsp/ExampleApplication.h (rev 0)
+++ code/branches/fps/src/libraries/tools/bsp/ExampleApplication.h 2010-05-02 21:49:01 UTC (rev 6823)
@@ -0,0 +1,257 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+Also see acknowledgements in Readme.html
+
+You may use this sample code for anything you like, it is not covered by the
+LGPL like the rest of the engine.
+-----------------------------------------------------------------------------
+*/
+/*
+-----------------------------------------------------------------------------
+Filename: ExampleApplication.h
+Description: Base class for all the OGRE examples
+-----------------------------------------------------------------------------
+*/
+
+#ifndef __ExampleApplication_H__
+#define __ExampleApplication_H__
+
+#include "Ogre.h"
+#include "OgreConfigFile.h"
+#include "ExampleFrameListener.h"
+
+#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
+#include <CoreFoundation/CoreFoundation.h>
+
+// This function will locate the path to our application on OS X,
+// unlike windows you can not rely on the curent working directory
+// for locating your configuration files and resources.
+std::string macBundlePath()
+{
+ char path[1024];
+ CFBundleRef mainBundle = CFBundleGetMainBundle();
+ assert(mainBundle);
+
+ CFURLRef mainBundleURL = CFBundleCopyBundleURL(mainBundle);
+ assert(mainBundleURL);
+
+ CFStringRef cfStringRef = CFURLCopyFileSystemPath( mainBundleURL, kCFURLPOSIXPathStyle);
+ assert(cfStringRef);
+
+ CFStringGetCString(cfStringRef, path, 1024, kCFStringEncodingASCII);
+
+ CFRelease(mainBundleURL);
+ CFRelease(cfStringRef);
+
+ return std::string(path);
+}
+#endif
+
+using namespace Ogre;
+
+/** Base class which manages the standard startup of an Ogre application.
+ Designed to be subclassed for specific examples if required.
+*/
+class ExampleApplication
+{
+public:
+ /// Standard constructor
+ ExampleApplication()
+ {
+ mFrameListener = 0;
+ mRoot = 0;
+ // Provide a nice cross platform solution for locating the configuration files
+ // On windows files are searched for in the current working directory, on OS X however
+ // you must provide the full path, the helper function macBundlePath does this for us.
+#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
+ mResourcePath = macBundlePath() + "/Contents/Resources/";
+#else
+ mResourcePath = "";
+#endif
+ }
+ /// Standard destructor
+ virtual ~ExampleApplication()
+ {
+ if (mFrameListener)
+ delete mFrameListener;
+ if (mRoot)
+ OGRE_DELETE mRoot;
+ }
+
+ /// Start the example
+ virtual void go(void)
+ {
+ if (!setup())
+ return;
+
+ mRoot->startRendering();
+
+ // clean up
+ destroyScene();
+ }
+
+protected:
+ Root *mRoot;
+ Camera* mCamera;
+ SceneManager* mSceneMgr;
+ ExampleFrameListener* mFrameListener;
+ RenderWindow* mWindow;
+ Ogre::String mResourcePath;
+
+ // These internal methods package up the stages in the startup process
+ /** Sets up the application - returns false if the user chooses to abandon configuration. */
+ virtual bool setup(void)
+ {
+
+ String pluginsPath;
+ // only use plugins.cfg if not static
+#ifndef OGRE_STATIC_LIB
+ pluginsPath = mResourcePath + "plugins.cfg";
+#endif
+
+ mRoot = OGRE_NEW Root(pluginsPath,
+ mResourcePath + "ogre.cfg", mResourcePath + "Ogre.log");
+
+ setupResources();
+
+ bool carryOn = configure();
+ if (!carryOn) return false;
+
+ chooseSceneManager();
+ createCamera();
+ createViewports();
+
+ // Set default mipmap level (NB some APIs ignore this)
+ TextureManager::getSingleton().setDefaultNumMipmaps(5);
+
+ // Create any resource listeners (for loading screens)
+ createResourceListener();
+ // Load resources
+ loadResources();
+
+ // Create the scene
+ createScene();
+
+ createFrameListener();
+
+ return true;
+
+ }
+ /** Configures the application - returns false if the user chooses to abandon configuration. */
+ virtual bool configure(void)
+ {
+ // Show the configuration dialog and initialise the system
+ // You can skip this and use root.restoreConfig() to load configuration
+ // settings if you were sure there are valid ones saved in ogre.cfg
+ if(mRoot->showConfigDialog())
+ {
+ // If returned true, user clicked OK so initialise
+ // Here we choose to let the system create a default rendering window by passing 'true'
+ mWindow = mRoot->initialise(true);
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ virtual void chooseSceneManager(void)
+ {
+ // Create the SceneManager, in this case a generic one
+ mSceneMgr = mRoot->createSceneManager(ST_GENERIC, "ExampleSMInstance");
+ }
+ virtual void createCamera(void)
+ {
+ // Create the camera
+ mCamera = mSceneMgr->createCamera("PlayerCam");
+
+ // Position it at 500 in Z direction
+ mCamera->setPosition(Vector3(0,0,500));
+ // Look back along -Z
+ mCamera->lookAt(Vector3(0,0,-300));
+ mCamera->setNearClipDistance(5);
+
+ }
+ virtual void createFrameListener(void)
+ {
+ mFrameListener= new ExampleFrameListener(mWindow, mCamera);
+ mFrameListener->showDebugOverlay(true);
+ mRoot->addFrameListener(mFrameListener);
+ }
+
+ virtual void createScene(void) = 0; // pure virtual - this has to be overridden
+
+ virtual void destroyScene(void){} // Optional to override this
+
+ virtual void createViewports(void)
+ {
+ // Create one viewport, entire window
+ Viewport* vp = mWindow->addViewport(mCamera);
+ vp->setBackgroundColour(ColourValue(0,0,0));
+
+ // Alter the camera aspect ratio to match the viewport
+ mCamera->setAspectRatio(
+ Real(vp->getActualWidth()) / Real(vp->getActualHeight()));
+ }
+
+ /// Method which will define the source of resources (other than current folder)
+ virtual void setupResources(void)
+ {
+ // Load resource paths from config file
+ ConfigFile cf;
+ cf.load(mResourcePath + "resources.cfg");
+
+ // Go through all sections & settings in the file
+ ConfigFile::SectionIterator seci = cf.getSectionIterator();
+
+ String secName, typeName, archName;
+ while (seci.hasMoreElements())
+ {
+ secName = seci.peekNextKey();
+ ConfigFile::SettingsMultiMap *settings = seci.getNext();
+ ConfigFile::SettingsMultiMap::iterator i;
+ for (i = settings->begin(); i != settings->end(); ++i)
+ {
+ typeName = i->first;
+ archName = i->second;
+#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
+ // OS X does not set the working directory relative to the app,
+ // In order to make things portable on OS X we need to provide
+ // the loading with it's own bundle path location
+ ResourceGroupManager::getSingleton().addResourceLocation(
+ String(macBundlePath() + "/" + archName), typeName, secName);
+#else
+ ResourceGroupManager::getSingleton().addResourceLocation(
+ archName, typeName, secName);
+#endif
+ }
+ }
+ }
+
+ /// Optional override method where you can create resource listeners (e.g. for loading screens)
+ virtual void createResourceListener(void)
+ {
+
+ }
+
+ /// Optional override method where you can perform resource group loading
+ /// Must at least do ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
+ virtual void loadResources(void)
+ {
+ // Initialise, parse scripts etc
+ ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
+
+ }
+
+
+
+};
+
+
+#endif
Property changes on: code/branches/fps/src/libraries/tools/bsp/ExampleApplication.h
___________________________________________________________________
Added: svn:eol-style
+ native
Added: code/branches/fps/src/libraries/tools/bsp/ExampleFrameListener.h
===================================================================
--- code/branches/fps/src/libraries/tools/bsp/ExampleFrameListener.h (rev 0)
+++ code/branches/fps/src/libraries/tools/bsp/ExampleFrameListener.h 2010-05-02 21:49:01 UTC (rev 6823)
@@ -0,0 +1,417 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+ (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+Also see acknowledgements in Readme.html
+
+You may use this sample code for anything you like, it is not covered by the
+LGPL like the rest of the engine.
+-----------------------------------------------------------------------------
+*/
+/*
+-----------------------------------------------------------------------------
+Filename: ExampleFrameListener.h
+Description: Defines an example frame listener which responds to frame events.
+This frame listener just moves a specified camera around based on
+keyboard and mouse movements.
+Mouse: Freelook
+W or Up: Forward
+S or Down:Backward
+A: Step left
+D: Step right
+ PgUp: Move upwards
+ PgDown: Move downwards
+ F: Toggle frame rate stats on/off
+ R: Render mode
+ T: Cycle texture filtering
+ Bilinear, Trilinear, Anisotropic(8)
+ P: Toggle on/off display of camera position / orientation
+-----------------------------------------------------------------------------
+*/
+
+#ifndef __ExampleFrameListener_H__
+#define __ExampleFrameListener_H__
+
+#include "Ogre.h"
+#include "OgreStringConverter.h"
+#include "OgreException.h"
+
+//Use this define to signify OIS will be used as a DLL
+//(so that dll import/export macros are in effect)
+#define OIS_DYNAMIC_LIB
+#include <OIS/OIS.h>
+
+using namespace Ogre;
+
+class ExampleFrameListener: public FrameListener, public WindowEventListener
+{
+protected:
+ virtual void updateStats(void)
+ {
+ static String currFps = "Current FPS: ";
+ static String avgFps = "Average FPS: ";
+ static String bestFps = "Best FPS: ";
+ static String worstFps = "Worst FPS: ";
+ static String tris = "Triangle Count: ";
+ static String batches = "Batch Count: ";
+
+ // update stats when necessary
+ try {
+ OverlayElement* guiAvg = OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");
+ OverlayElement* guiCurr = OverlayManager::getSingleton().getOverlayElement("Core/CurrFps");
+ OverlayElement* guiBest = OverlayManager::getSingleton().getOverlayElement("Core/BestFps");
+ OverlayElement* guiWorst = OverlayManager::getSingleton().getOverlayElement("Core/WorstFps");
+
+ const RenderTarget::FrameStats& stats = mWindow->getStatistics();
+ guiAvg->setCaption(avgFps + StringConverter::toString(stats.avgFPS));
+ guiCurr->setCaption(currFps + StringConverter::toString(stats.lastFPS));
+ guiBest->setCaption(bestFps + StringConverter::toString(stats.bestFPS)
+ +" "+StringConverter::toString(stats.bestFrameTime)+" ms");
+ guiWorst->setCaption(worstFps + StringConverter::toString(stats.worstFPS)
+ +" "+StringConverter::toString(stats.worstFrameTime)+" ms");
+
+ OverlayElement* guiTris = OverlayManager::getSingleton().getOverlayElement("Core/NumTris");
+ guiTris->setCaption(tris + StringConverter::toString(stats.triangleCount));
+
+ OverlayElement* guiBatches = OverlayManager::getSingleton().getOverlayElement("Core/NumBatches");
+ guiBatches->setCaption(batches + StringConverter::toString(stats.batchCount));
+
+ OverlayElement* guiDbg = OverlayManager::getSingleton().getOverlayElement("Core/DebugText");
+ guiDbg->setCaption(mDebugText);
+ }
+ catch(...) { /* ignore */ }
+ }
+
+public:
+ // Constructor takes a RenderWindow because it uses that to determine input context
+ ExampleFrameListener(RenderWindow* win, Camera* cam, bool bufferedKeys = false, bool bufferedMouse = false,
+ bool bufferedJoy = false ) :
+ mCamera(cam), mTranslateVector(Vector3::ZERO), mCurrentSpeed(0), mWindow(win), mStatsOn(true), mNumScreenShots(0),
+ mMoveScale(0.0f), mRotScale(0.0f), mTimeUntilNextToggle(0), mFiltering(TFO_BILINEAR),
+ mAniso(1), mSceneDetailIndex(0), mMoveSpeed(100), mRotateSpeed(36), mDebugOverlay(0),
+ mInputManager(0), mMouse(0), mKeyboard(0), mJoy(0)
+ {
+
+ mDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay");
+
+ LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");
+ OIS::ParamList pl;
+ size_t windowHnd = 0;
+ std::ostringstream windowHndStr;
+
+ win->getCustomAttribute("WINDOW", &windowHnd);
+ windowHndStr << windowHnd;
+ pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
+
+ mInputManager = OIS::InputManager::createInputSystem( pl );
+
+ //Create all devices (We only catch joystick exceptions here, as, most people have Key/Mouse)
+ mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject( OIS::OISKeyboard, bufferedKeys ));
+ mMouse = static_cast<OIS::Mouse*>(mInputManager->createInputObject( OIS::OISMouse, bufferedMouse ));
+ try {
+ mJoy = static_cast<OIS::JoyStick*>(mInputManager->createInputObject( OIS::OISJoyStick, bufferedJoy ));
+ }
+ catch(...) {
+ mJoy = 0;
+ }
+
+ //Set initial mouse clipping size
+ windowResized(mWindow);
+
+ showDebugOverlay(true);
+
+ //Register as a Window listener
+ WindowEventUtilities::addWindowEventListener(mWindow, this);
+ }
+
+ //Adjust mouse clipping area
+ virtual void windowResized(RenderWindow* rw)
+ {
+ unsigned int width, height, depth;
+ int left, top;
+ rw->getMetrics(width, height, depth, left, top);
+
+ const OIS::MouseState &ms = mMouse->getMouseState();
+ ms.width = width;
+ ms.height = height;
+ }
+
+ //Unattach OIS before window shutdown (very important under Linux)
+ virtual void windowClosed(RenderWindow* rw)
+ {
+ //Only close for window that created OIS (the main window in these demos)
+ if( rw == mWindow )
+ {
+ if( mInputManager )
+ {
+ mInputManager->destroyInputObject( mMouse );
+ mInputManager->destroyInputObject( mKeyboard );
+ mInputManager->destroyInputObject( mJoy );
+
+ OIS::InputManager::destroyInputSystem(mInputManager);
+ mInputManager = 0;
+ }
+ }
+ }
+
+ virtual ~ExampleFrameListener()
+ {
+ //Remove ourself as a Window listener
+ WindowEventUtilities::removeWindowEventListener(mWindow, this);
+ windowClosed(mWindow);
+ }
+
+ virtual bool processUnbufferedKeyInput(const FrameEvent& evt)
+ {
+
+ if(mKeyboard->isKeyDown(OIS::KC_A))
+ mTranslateVector.x = -mMoveScale; // Move camera left
+
+ if(mKeyboard->isKeyDown(OIS::KC_D))
+ mTranslateVector.x = mMoveScale; // Move camera RIGHT
+
+ if(mKeyboard->isKeyDown(OIS::KC_UP) || mKeyboard->isKeyDown(OIS::KC_W) )
+ mTranslateVector.z = -mMoveScale; // Move camera forward
+
+ if(mKeyboard->isKeyDown(OIS::KC_DOWN) || mKeyboard->isKeyDown(OIS::KC_S) )
+ mTranslateVector.z = mMoveScale; // Move camera backward
+
+ if(mKeyboard->isKeyDown(OIS::KC_PGUP))
+ mTranslateVector.y = mMoveScale; // Move camera up
+
+ if(mKeyboard->isKeyDown(OIS::KC_PGDOWN))
+ mTranslateVector.y = -mMoveScale; // Move camera down
+
+ if(mKeyboard->isKeyDown(OIS::KC_RIGHT))
+ mCamera->yaw(-mRotScale);
+
+ if(mKeyboard->isKeyDown(OIS::KC_LEFT))
+ mCamera->yaw(mRotScale);
+
+ if( mKeyboard->isKeyDown(OIS::KC_ESCAPE) || mKeyboard->isKeyDown(OIS::KC_Q) )
+ return false;
+
+ if( mKeyboard->isKeyDown(OIS::KC_F) && mTimeUntilNextToggle <= 0 )
+ {
+ mStatsOn = !mStatsOn;
+ showDebugOverlay(mStatsOn);
+ mTimeUntilNextToggle = 1;
+ }
+
+ if( mKeyboard->isKeyDown(OIS::KC_T) && mTimeUntilNextToggle <= 0 )
+ {
+ switch(mFiltering)
+ {
+ case TFO_BILINEAR:
+ mFiltering = TFO_TRILINEAR;
+ mAniso = 1;
+ break;
+ case TFO_TRILINEAR:
+ mFiltering = TFO_ANISOTROPIC;
+ mAniso = 8;
+ break;
+ case TFO_ANISOTROPIC:
+ mFiltering = TFO_BILINEAR;
+ mAniso = 1;
+ break;
+ default: break;
+ }
+ MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
+ MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);
+
+ showDebugOverlay(mStatsOn);
+ mTimeUntilNextToggle = 1;
+ }
+
+ if(mKeyboard->isKeyDown(OIS::KC_SYSRQ) && mTimeUntilNextToggle <= 0)
+ {
+ std::ostringstream ss;
+ ss << "screenshot_" << ++mNumScreenShots << ".png";
+ mWindow->writeContentsToFile(ss.str());
+ mTimeUntilNextToggle = 0.5;
+ mDebugText = "Saved: " + ss.str();
+ }
+
+ if(mKeyboard->isKeyDown(OIS::KC_R) && mTimeUntilNextToggle <=0)
+ {
+ mSceneDetailIndex = (mSceneDetailIndex+1)%3 ;
+ switch(mSceneDetailIndex) {
+ case 0 : mCamera->setPolygonMode(PM_SOLID); break;
+ case 1 : mCamera->setPolygonMode(PM_WIREFRAME); break;
+ case 2 : mCamera->setPolygonMode(PM_POINTS); break;
+ }
+ mTimeUntilNextToggle = 0.5;
+ }
+
+ static bool displayCameraDetails = false;
+ if(mKeyboard->isKeyDown(OIS::KC_P) && mTimeUntilNextToggle <= 0)
+ {
+ displayCameraDetails = !displayCameraDetails;
+ mTimeUntilNextToggle = 0.5;
+ if (!displayCameraDetails)
+ mDebugText = "";
+ }
+
+ // Print camera details
+ if(displayCameraDetails)
+ mDebugText = "P: " + StringConverter::toString(mCamera->getDerivedPosition()) +
+ " " + "O: " + StringConverter::toString(mCamera->getDerivedOrientation());
+
+ // Return true to continue rendering
+ return true;
+ }
+
+ virtual bool processUnbufferedMouseInput(const FrameEvent& evt)
+ {
+
+ // Rotation factors, may not be used if the second mouse button is pressed
+ // 2nd mouse button - slide, otherwise rotate
+ const OIS::MouseState &ms = mMouse->getMouseState();
+ if( ms.buttonDown( OIS::MB_Right ) )
+ {
+ mTranslateVector.x += ms.X.rel * 0.13;
+ mTranslateVector.y -= ms.Y.rel * 0.13;
+ }
+ else
+ {
+ mRotX = Degree(-ms.X.rel * 0.13);
+ mRotY = Degree(-ms.Y.rel * 0.13);
+ }
+
+ return true;
+ }
+
+ virtual void moveCamera()
+ {
+ // Make all the changes to the camera
+ // Note that YAW direction is around a fixed axis (freelook style) rather than a natural YAW
+ //(e.g. airplane)
+ mCamera->yaw(mRotX);
+ mCamera->pitch(mRotY);
+ mCamera->moveRelative(mTranslateVector);
+ }
+
+ virtual void showDebugOverlay(bool show)
+ {
+ if (mDebugOverlay)
+ {
+ if (show)
+ mDebugOverlay->show();
+ else
+ mDebugOverlay->hide();
+ }
+ }
+
+ // Override frameRenderingQueued event to process that (don't care about frameEnded)
+ bool frameRenderingQueued(const FrameEvent& evt)
+ {
+
+ if(mWindow->isClosed()) return false;
+
+ mSpeedLimit = mMoveScale * evt.timeSinceLastFrame;
+
+ //Need to capture/update each device
+ mKeyboard->capture();
+ mMouse->capture();
+ if( mJoy ) mJoy->capture();
+
+ bool buffJ = (mJoy) ? mJoy->buffered() : true;
+
+ Ogre::Vector3 lastMotion = mTranslateVector;
+
+ //Check if one of the devices is not buffered
+ if( !mMouse->buffered() || !mKeyboard->buffered() || !buffJ )
+ {
+ // one of the input modes is immediate, so setup what is needed for immediate movement
+ if (mTimeUntilNextToggle >= 0)
+ mTimeUntilNextToggle -= evt.timeSinceLastFrame;
+
+ // Move about 100 units per second
+ mMoveScale = mMoveSpeed * evt.timeSinceLastFrame;
+ // Take about 10 seconds for full rotation
+ mRotScale = mRotateSpeed * evt.timeSinceLastFrame;
+
+ mRotX = 0;
+ mRotY = 0;
+ mTranslateVector = Ogre::Vector3::ZERO;
+
+ }
+
+ //Check to see which device is not buffered, and handle it
+ if( !mKeyboard->buffered() )
+ if( processUnbufferedKeyInput(evt) == false )
+ return false;
+ if( !mMouse->buffered() )
+ if( processUnbufferedMouseInput(evt) == false )
+ return false;
+
+ // ramp up / ramp down speed
+ if (mTranslateVector == Ogre::Vector3::ZERO)
+ {
+ // decay (one third speed)
+ mCurrentSpeed -= evt.timeSinceLastFrame * 0.3;
+ mTranslateVector = lastMotion;
+ }
+ else
+ {
+ // ramp up
+ mCurrentSpeed += evt.timeSinceLastFrame;
+
+ }
+ // Limit motion speed
+ if (mCurrentSpeed > 1.0)
+ mCurrentSpeed = 1.0;
+ if (mCurrentSpeed < 0.0)
+ mCurrentSpeed = 0.0;
+
+ mTranslateVector *= mCurrentSpeed;
+
+
+ if( !mMouse->buffered() || !mKeyboard->buffered() || !buffJ )
+ moveCamera();
+
+ return true;
+ }
+
+ bool frameEnded(const FrameEvent& evt)
+ {
+ updateStats();
+ return true;
+ }
+
+protected:
+ Camera* mCamera;
+
+ Vector3 mTranslateVector;
+ Real mCurrentSpeed;
+ RenderWindow* mWindow;
+ bool mStatsOn;
+
+ std::string mDebugText;
+
+ unsigned int mNumScreenShots;
+ float mMoveScale;
+ float mSpeedLimit;
+ Degree mRotScale;
+ // just to stop toggles flipping too fast
+ Real mTimeUntilNextToggle ;
+ Radian mRotX, mRotY;
+ TextureFilterOptions mFiltering;
+ int mAniso;
+
+ int mSceneDetailIndex ;
+ Real mMoveSpeed;
+ Degree mRotateSpeed;
+ Overlay* mDebugOverlay;
+
+ //OIS Input devices
+ OIS::InputManager* mInputManager;
+ OIS::Mouse* mMouse;
+ OIS::Keyboard* mKeyboard;
+ OIS::JoyStick* mJoy;
+};
+
+#endif
Property changes on: code/branches/fps/src/libraries/tools/bsp/ExampleFrameListener.h
___________________________________________________________________
Added: svn:eol-style
+ native
More information about the Orxonox-commit
mailing list