Changeset 161 for code/branches/main_reto_vs05/src

Timestamp:

Nov 4, 2007, 5:00:41 PM (17 years ago)

Author:

rgrieder

Message:

• added namespace Orxonox to every file
  • removed all the "using namespace Ogre" in the header files
• cleaned up with the includes: attempt to include as little as possible to reduce compile time.
  • created a header file: orxonox_prerequisites.h
  • used OgrePrerequisites in the header files
  • avoided including "Ogre.h", using separate files instead
• created empty class: AmmunitionDump

Location:

code/branches/main_reto_vs05/src

Files:

• ammunition_dump.cc (added)
• bullet.cc (modified) (1 diff)
• camera_manager.cc (modified) (1 diff)
• main.cc (modified) (2 diffs)
• ogre_control.cc (modified) (1 diff)
• orxonox.cc (modified) (1 diff)
• orxonox_scene.cc (modified) (1 diff)
• orxonox_ship.cc (modified) (1 diff)
• run_manager.cc (modified) (1 diff)
• weapon_manager.cc (modified) (1 diff)

code/branches/main_reto_vs05/src/bullet.cc

@@ -26 +26 @@
  */
 
+#include "OgreSceneNode.h"
+#include "OgreEntity.h"
+#include "OgreVector3.h"
+
 #include "bullet.h"
 
 
-Bullet::Bullet(SceneNode *mNode, Entity *mEntity, Vector3 mSpeed)
-      : mNode(mNode), mEntity(mEntity), mSpeed(mSpeed)
-{
-        mNode->attachObject(mEntity);
-}
+namespace Orxonox {
+  using namespace Ogre;
+
+  Bullet::Bullet(SceneNode *mNode, Entity *mEntity, Vector3 mSpeed)
+        : mNode(mNode), mEntity(mEntity), mSpeed(mSpeed)
+  {
+          mNode->attachObject(mEntity);
+  }
 
 
-Bullet::~Bullet()
-{
+  Bullet::~Bullet()
+  {
+  }
+
 }

code/branches/main_reto_vs05/src/camera_manager.cc

@@ -26 +26 @@
  */
 
+#include "OgreSceneManager.h"
+#include "OgreCamera.h"
+
 #include "camera_manager.h"
 
+namespace Orxonox {
+  using namespace Ogre;
 
-CameraManager::CameraManager(SceneManager *mScene) : mSceneMgr(mSceneMgr)
-{
-}
+  CameraManager::CameraManager(SceneManager *mScene) : mSceneMgr(mSceneMgr)
+  {
+  }
 
 
-CameraManager::~CameraManager()
-{
-}
+  CameraManager::~CameraManager()
+  {
+  }
 
 
-bool CameraManager::setCameraPosition(int n)
-{
-        return true;
+  bool CameraManager::setCameraPosition(int n)
+  {
+          return true;
+  }
+
 }

code/branches/main_reto_vs05/src/main.cc

@@ -26 +26 @@
  */
 
-
+#include "OgrePlatform.h"
+#include "OgreException.h"
 
 #include "orxonox.h"
@@ -44 +45 @@
     try {
       // create an orxonox aplication and run it
-      Orxonox myApp;
+      Orxonox::Orxonox myApp;
 
       myApp.go();

code/branches/main_reto_vs05/src/ogre_control.cc

@@ -26 +26 @@
  */
 
-/**
-* Ogre control class.
-* This is merely a convenient way to handle Ogre. It only holds the Root
-* object and the render Window. These are the objects, that are independant
-* of the game state (playing, menu browsing, loading, etc.).
-* This class could easily be merged into the Orxnox class.
-*/
-
+#include "OgrePlatform.h"
+#include "OgreRoot.h"
+#include "OgreRenderWindow.h"
+#include "OgreString.h"
+#include "OgreConfigFile.h"
+
+#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
+  #include <CoreFoundation/CoreFoundation.h>
+#endif
 
 #include "ogre_control.h"
 
 
-/**
-* Provide support for mac users.
-*/
-#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
-// 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);
+namespace Orxonox {
+  using namespace Ogre;
+
+  /**
+  * Ogre control class.
+  * This is merely a convenient way to handle Ogre. It only holds the Root
+  * object and the render Window. These are the objects, that are independant
+  * of the game state (playing, menu browsing, loading, etc.).
+  * This class could easily be merged into the Orxnox class.
+  */
+
+
+  /**
+  * Provide support for mac users.
+  */
+  #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
+  // 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
+
+
+  /**
+  * Constructor that determines the resource path platform dependant.
+  */
+  OgreControl::OgreControl() : root_(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
+          resourcePath_ = macBundlePath() + "/Contents/Resources/";
+  #else
+          resourcePath_ = "";
+  #endif
+  }
+
+
+  /**
+  * Standard Destructor.
+  */
+  OgreControl::~OgreControl()
+  {
+          if (root_)
+                  delete root_;
+  }
+
+
+  /* Sets up Ogre.
+  * First, the Root object is being created, then the resources are defined
+  * (not loaded!). And last but not least, the render settings (like resolution
+  * or AA level) are prompted to the user.
+  */
+  bool OgreControl::initialise(void)
+  {
+          String pluginsPath;
+          // only use plugins.cfg if not static
+  #ifndef OGRE_STATIC_LIB
+          pluginsPath = resourcePath_ + "plugins.cfg";
+  #endif
+
+          root_ = new Root(pluginsPath, 
+                  resourcePath_ + "ogre.cfg", resourcePath_ + "Ogre.log");
+
+          setupResources();
+
+          if (!configure())
+                  return false;
+
+          return true;
+  }
+
+
+  /**
+  * Defines the source of the resources.
+  */
+  void OgreControl::setupResources(void)
+  {
+          // Load resource paths from config file
+          ConfigFile cf;
+          cf.load(resourcePath_ + "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
+                  }
+          }
+  }
+
+
+  /**
+  * Prompts a setting window for the render engine if that has not already
+  * been done.
+  * The method also calls the root initialiser in order to get a render window.
+  */
+  bool OgreControl::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(!root_->restoreConfig() && !root_->showConfigDialog())
+                  return false;
+
+          // user clicked OK so initialise
+          // Here we choose to let the system create a default
+    // rendering window by passing 'true'
+          root_->saveConfig();
+          window_ = root_->initialise(true);
+          return true;
+  }
+
+
+  /**
+  * Returns the root object.
+  * @return Root object.
+  */
+  Root* OgreControl::getRoot(void)
+  {
+          return root_;
+  }
+
+
+  /**
+  * Returns the render window.
+  * @return Render window.
+  */
+  RenderWindow* OgreControl::getRenderWindow(void)
+  {
+          return window_;
+  }
+
+
+  /**
+  * Returns the resource path.
+  * @return Resource path.
+  */
+  Ogre::String OgreControl::getResourcePath(void)
+  {
+          return resourcePath_;
+  }
+
 }
-#endif
-
-
-/**
-* Constructor that determines the resource path platform dependant.
-*/
-OgreControl::OgreControl() : root_(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
-        resourcePath_ = macBundlePath() + "/Contents/Resources/";
-#else
-        resourcePath_ = "";
-#endif
-}
-
-
-/**
-* Standard Destructor.
-*/
-OgreControl::~OgreControl()
-{
-        if (root_)
-                delete root_;
-}
-
-
-/* Sets up Ogre.
-* First, the Root object is being created, then the resources are defined
-* (not loaded!). And last but not least, the render settings (like resolution
-* or AA level) are prompted to the user.
-*/
-bool OgreControl::initialise(void)
-{
-        String pluginsPath;
-        // only use plugins.cfg if not static
-#ifndef OGRE_STATIC_LIB
-        pluginsPath = resourcePath_ + "plugins.cfg";
-#endif
-
-        root_ = new Root(pluginsPath, 
-                resourcePath_ + "ogre.cfg", resourcePath_ + "Ogre.log");
-
-        setupResources();
-
-        if (!configure())
-                return false;
-
-        return true;
-}
-
-
-/**
-* Defines the source of the resources.
-*/
-void OgreControl::setupResources(void)
-{
-        // Load resource paths from config file
-        ConfigFile cf;
-        cf.load(resourcePath_ + "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
-                }
-        }
-}
-
-
-/**
-* Prompts a setting window for the render engine if that has not already
-* been done.
-* The method also calls the root initialiser in order to get a render window.
-*/
-bool OgreControl::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(!root_->restoreConfig() && !root_->showConfigDialog())
-                return false;
-
-        // user clicked OK so initialise
-        // Here we choose to let the system create a default
-  // rendering window by passing 'true'
-        root_->saveConfig();
-        window_ = root_->initialise(true);
-        return true;
-}
-
-
-/**
-* Returns the root object.
-* @return Root object.
-*/
-Root* OgreControl::getRoot(void)
-{
-        return root_;
-}
-
-
-/**
-* Returns the render window.
-* @return Render window.
-*/
-RenderWindow* OgreControl::getRenderWindow(void)
-{
-        return window_;
-}
-
-
-/**
-* Returns the resource path.
-* @return Resource path.
-*/
-Ogre::String OgreControl::getResourcePath(void)
-{
-        return resourcePath_;
-}

code/branches/main_reto_vs05/src/orxonox.cc

@@ -32 +32 @@
 */
 
+#include "OgreRoot.h"
+#include "OgreTimer.h"
+#include "OgreWindowEventUtilities.h"
 
+#include "ogre_control.h"
+#include "run_manager.h"
 #include "orxonox.h"
 
 
-/**
-* Empty Constructor.
-*/
-Orxonox::Orxonox()
-{
-}
+namespace Orxonox {
+
+  /**
+  * Empty Constructor.
+  */
+  Orxonox::Orxonox()
+  {
+  }
 
 
-/**
-* Empty Destructor.
-*/
-Orxonox::~Orxonox()
-{
-}
+  /**
+  * Empty Destructor.
+  */
+  Orxonox::~Orxonox()
+  {
+  }
 
 
-/**
-* Starts and runs the game
-*/
-void Orxonox::go(void)
-{
-        if (!setup())
-                return;
+  /**
+  * Starts and runs the game
+  */
+  void Orxonox::go(void)
+  {
+          if (!setup())
+                  return;
 
-        timer_ = new Timer();
+    timer_ = new Ogre::Timer();
 
-        unsigned long lastTime = timer_->getMilliseconds();
+          unsigned long lastTime = timer_->getMilliseconds();
 
-        while (true)
-        {
-                //Pump messages in all registered RenderWindow windows
-                WindowEventUtilities::messagePump();
+          while (true)
+          {
+                  //Pump messages in all registered RenderWindow windows
+      Ogre::WindowEventUtilities::messagePump();
 
-                ogre_->getRoot()->renderOneFrame();
+                  ogre_->getRoot()->renderOneFrame();
 
-                if (!runMgr_->tick(timer_->getMilliseconds(),
-            (timer_->getMilliseconds() - lastTime) / 1000.0))
-                        break;
-                lastTime = timer_->getMilliseconds();
-        }
+                  if (!runMgr_->tick(timer_->getMilliseconds(),
+              (timer_->getMilliseconds() - lastTime) / 1000.0))
+                          break;
+                  lastTime = timer_->getMilliseconds();
+          }
 
-        // clean up
-        destroy();
-}
+          // clean up
+          destroy();
+  }
 
 
-/**
-* Create render engine, render window and the Run manager.
-* @return False if failed.
-*/
-bool Orxonox::setup(void)
-{
-        // create new 3D ogre render engine
-        ogre_ = new OgreControl();
-        ogre_->initialise();
+  /**
+  * Create render engine, render window and the Run manager.
+  * @return False if failed.
+  */
+  bool Orxonox::setup(void)
+  {
+          // create new 3D ogre render engine
+          ogre_ = new OgreControl();
+          ogre_->initialise();
 
-        runMgr_ = new RunManager(ogre_);
+          runMgr_ = new RunManager(ogre_);
 
-        return true;
-}
+          return true;
+  }
 
 
-/**
-* Clean everything up.
-*/
-void Orxonox::destroy()
-{
-        if (timer_)
-                delete timer_;
-        if (runMgr_)
-                delete runMgr_;
-        if (ogre_)
-                delete ogre_;
+  /**
+  * Clean everything up.
+  */
+  void Orxonox::destroy()
+  {
+          if (timer_)
+                  delete timer_;
+          if (runMgr_)
+                  delete runMgr_;
+          if (ogre_)
+                  delete ogre_;
+  }
+
 }

code/branches/main_reto_vs05/src/orxonox_scene.cc

@@ -26 +26 @@
  */
 
-/**
-* The orxonox scene includes everything running in the background like terrain,
-* static figures, dangling lamp, etc.
-*/
-
+#include "OgreSceneManager.h"
+#include "OgreSceneNode.h"
+#include "OgreEntity.h"
+#include "OgreLight.h"
+#include "OgreBillboard.h"
+#include "OgreBillboardSet.h"
+#include "OgreVector3.h"
 
 #include "orxonox_scene.h"
 
+namespace Orxonox {
+  using namespace Ogre;
 
-/**
-* Empty Consructor except the initialiser list.
-* @param sceneMgr The Scene Manager.
-*/
-OrxonoxScene::OrxonoxScene(SceneManager *sceneMgr) : sceneMgr_(sceneMgr)
-{
-}
-
-/**
-* Empty Destructor.
-*/
-OrxonoxScene::~OrxonoxScene()
-{
-}
-
-/**
-* Ogre initialisation method.
-* This function is called by the Run Manager to load the neccessary recources
-* and to create the scene.
-* @return False if failed.
-*/
-bool OrxonoxScene::initialise()
-{
-        // Load resources
-        loadResources();
-
-        distance_ = 0;
-        radius_ = 100;
-
-        createScene();
-
-        return true;
-}
+  /**
+  * The orxonox scene includes everything running in the background like terrain,
+  * static figures, dangling lamp, etc.
+  */
 
 
-/**
-* Resource loader.
-* Currently, this method loads everything! TODO: If done this ugly, it should
-* at least be in the Run Manager.
-*/
-void OrxonoxScene::loadResources()
-{
-        // Initialise, parse scripts etc
-        ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
-}
+  /**
+  * Empty Consructor except the initialiser list.
+  * @param sceneMgr The Scene Manager.
+  */
+  OrxonoxScene::OrxonoxScene(SceneManager *sceneMgr) : sceneMgr_(sceneMgr)
+  {
+  }
+
+  /**
+  * Empty Destructor.
+  */
+  OrxonoxScene::~OrxonoxScene()
+  {
+  }
+
+  /**
+  * Ogre initialisation method.
+  * This function is called by the Run Manager to load the neccessary recources
+  * and to create the scene.
+  * @return False if failed.
+  */
+  bool OrxonoxScene::initialise()
+  {
+          // Load resources
+          loadResources();
+
+          distance_ = 0;
+          radius_ = 100;
+
+          createScene();
+
+          return true;
+  }
 
 
-/**
-* Scene creation.
-* Currently just a test scene with an ogre head an a surrounding light.
-*/
-void OrxonoxScene::createScene()
-{
-        sceneMgr_->setAmbientLight(ColourValue(0.3,0.3,0.3));
-
-        //create first entity
-        Entity *head = sceneMgr_->createEntity("head", "ogrehead.mesh");
-
-        //create a scene node to attach the head to
-        SceneNode *node = sceneMgr_->getRootSceneNode()
-        ->createChildSceneNode("OgreHeadNode", Vector3(0,0,0));
-        //attach the ogre head
-        node->attachObject(head);
-
-        // set up skybox
-        sceneMgr_->setSkyBox(true, "Examples/SceneSkyBox2");
-
-        // set up one light_ source
-        light_ = sceneMgr_->createLight("Light1");
-        light_->setType(Light::LT_POINT);
-        light_->setPosition(Vector3(0, 0, 0));
-        light_->setDiffuseColour(1.0, 1.0, 1.0);
-        light_->setSpecularColour(1.0, 1.0, 1.0);
-
-        //create billboard
-        bbs_ = sceneMgr_->createBillboardSet("bb", 1);
-        bbs_->createBillboard(Vector3::ZERO, ColourValue(1.0, 1.0, 1.0));
-        bbs_->setMaterialName("Examples/Flare");
-
-        lightNode_ = sceneMgr_->getRootSceneNode()
-        ->createChildSceneNode("lightNode_", Vector3(0, 100, 0));
-
-        lightNode_->attachObject(bbs_);
-        lightNode_->attachObject(light_);
-}
+  /**
+  * Resource loader.
+  * Currently, this method loads everything! TODO: If done this ugly, it should
+  * at least be in the Run Manager.
+  */
+  void OrxonoxScene::loadResources()
+  {
+          // Initialise, parse scripts etc
+          ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
+  }
 
 
-/**
-* Compute something between frames if neccessary.
-* @param time Absolute time.
-* @param deltaTime Relative time.
-* @return Return true to continue rendering.
-*/
-bool OrxonoxScene::tick(unsigned long time, Real deltaTime)
-{
-        Real t = time/1000.0;
+  /**
+  * Scene creation.
+  * Currently just a test scene with an ogre head an a surrounding light.
+  */
+  void OrxonoxScene::createScene()
+  {
+          sceneMgr_->setAmbientLight(ColourValue(0.3,0.3,0.3));
 
-        lightNode_->setPosition(radius_*sin(5*t), radius_*cos(5*t), sin(1*t)*distance_);
-        
-        light_->setDiffuseColour(sin(1*t), sin(1*t + 2.09), sin(1*t + 2.09*2));
-        light_->setSpecularColour(sin(1*t), sin(1*t + 2.09), sin(1*t + 2.09*2));
+          //create first entity
+          Entity *head = sceneMgr_->createEntity("head", "ogrehead.mesh");
 
-        bbs_->getBillboard(0)->setColour(ColourValue(sin(1*t),
-        sin(1*t + 2.09), sin(1*t + 2.09*2)));
-  
-  return true;
+          //create a scene node to attach the head to
+          SceneNode *node = sceneMgr_->getRootSceneNode()
+          ->createChildSceneNode("OgreHeadNode", Vector3(0,0,0));
+          //attach the ogre head
+          node->attachObject(head);
+
+          // set up skybox
+          sceneMgr_->setSkyBox(true, "Examples/SceneSkyBox2");
+
+          // set up one light_ source
+          light_ = sceneMgr_->createLight("Light1");
+          light_->setType(Light::LT_POINT);
+          light_->setPosition(Vector3(0, 0, 0));
+          light_->setDiffuseColour(1.0, 1.0, 1.0);
+          light_->setSpecularColour(1.0, 1.0, 1.0);
+
+          //create billboard
+          bbs_ = sceneMgr_->createBillboardSet("bb", 1);
+          bbs_->createBillboard(Vector3::ZERO, ColourValue(1.0, 1.0, 1.0));
+          bbs_->setMaterialName("Examples/Flare");
+
+          lightNode_ = sceneMgr_->getRootSceneNode()
+          ->createChildSceneNode("lightNode_", Vector3(0, 100, 0));
+
+          lightNode_->attachObject(bbs_);
+          lightNode_->attachObject(light_);
+  }
+
+
+  /**
+  * Compute something between frames if neccessary.
+  * @param time Absolute time.
+  * @param deltaTime Relative time.
+  * @return Return true to continue rendering.
+  */
+  bool OrxonoxScene::tick(unsigned long time, Real deltaTime)
+  {
+          Real t = time/1000.0;
+
+          lightNode_->setPosition(radius_*sin(5*t), radius_*cos(5*t), sin(1*t)*distance_);
+        
+          light_->setDiffuseColour(sin(1*t), sin(1*t + 2.09), sin(1*t + 2.09*2));
+          light_->setSpecularColour(sin(1*t), sin(1*t + 2.09), sin(1*t + 2.09*2));
+
+          bbs_->getBillboard(0)->setColour(ColourValue(sin(1*t),
+          sin(1*t + 2.09), sin(1*t + 2.09*2)));
+    
+    return true;
+  }
+
 }

code/branches/main_reto_vs05/src/orxonox_ship.cc

@@ -26 +26 @@
  */
 
-/**
-* Base class for any kind of flyable ship in Orxonox.
-* 
-* The ship offers steering methods (like left, right, etc.) and translates
-* them into movement. A ship can also hold more than one weapons (where each
-* of these can be replaced during the game). This means that a ship can have
-* many WeaponManagers but only one MunitionManager (independant object that
-* is referenced in each WeaponManager).
-* Furthermore a ship in Orxonox is responsible for its visualization, which is
-* why it receives a pointer to the SceneManager.
-*/
-
+#include "OgreSceneManager.h"
+#include "OgreSceneNode.h"
+#include "OgreEntity.h"
+#include "OgreVector3.h"
+#include "OgreStringConverter.h"
+
+#include "bullet.h"
 
 #include "orxonox_ship.h"
 
-
-/**
-* Standard constructor, that only initalizes a few variables. Some of them
-* could be made static, since any new ship would be derived from the BaseShip.
-* Or even better: write config files for each ship so that manipulating
-* its properties would be even easier.
-* @param mSceneMgr The current main SceneManager
-* @param mNode The scene node which the ship will be attached to later.
-*/
-OrxonoxShip::OrxonoxShip(SceneManager *sceneMgr, SceneNode *node)
-            : sceneMgr_(sceneMgr), rootNode_(node), currentSpeed_(Vector3(0, 0, 0)),
-      baseThrust_(1000), currentThrust_(Vector3::ZERO),
-      objectCounter_(0), bulletSpeed_(400)
-{
+namespace Orxonox {
+  using namespace Ogre;
+
+  /**
+  * Base class for any kind of flyable ship in Orxonox.
+  * 
+  * The ship offers steering methods (like left, right, etc.) and translates
+  * them into movement. A ship can also hold more than one weapons (where each
+  * of these can be replaced during the game). This means that a ship can have
+  * many WeaponManagers but only one MunitionManager (independant object that
+  * is referenced in each WeaponManager).
+  * Furthermore a ship in Orxonox is responsible for its visualization, which is
+  * why it receives a pointer to the SceneManager.
+  */
+
+
+
+
+  /**
+  * Standard constructor, that only initalizes a few variables. Some of them
+  * could be made static, since any new ship would be derived from the BaseShip.
+  * Or even better: write config files for each ship so that manipulating
+  * its properties would be even easier.
+  * @param mSceneMgr The current main SceneManager
+  * @param mNode The scene node which the ship will be attached to later.
+  */
+  OrxonoxShip::OrxonoxShip(SceneManager *sceneMgr, SceneNode *node)
+              : sceneMgr_(sceneMgr), rootNode_(node), currentSpeed_(Vector3(0, 0, 0)),
+        baseThrust_(1000), currentThrust_(Vector3::ZERO),
+        objectCounter_(0), bulletSpeed_(400)
+  {
+  }
+
+
+  /**
+  * Standard destructor.
+  * Doesn't have any work to do yet.
+  */
+  OrxonoxShip::~OrxonoxShip()
+  {
+  }
+
+
+  /**
+  * Initialises everything.
+  * Once that ResourceGroups are organised, this method loads them.
+  * It might be an idea to make this function static in order for the
+  * SceneManger to call the initialise method of every needed class (macros..)
+  * @return Returns false when failed.
+  */
+  bool OrxonoxShip::initialise()
+  {
+          // load all the resources needed (no resource groups yet,
+    // so the allInit is not executed!)
+          // ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
+
+          // create the "space ship" (currently a fish..)
+          // TODO: names must be unique! use static variables..
+          shipEntity_ = sceneMgr_->createEntity("Ship", "fish.mesh");
+          SceneNode *fishNode = rootNode_->createChildSceneNode("fishNode");
+          fishNode->yaw(Degree(-90));
+          fishNode->attachObject(shipEntity_);
+          fishNode->setScale(Vector3(10, 10, 10));
+
+          return true;
+  }
+
+
+  /**
+  * Gets the ship to accelerate in the current direction.
+  * The value should be between 0 and 1, with one beeing full thrust and 0 none.
+  * @param value Acceleration between 0 and 1
+  */
+  void OrxonoxShip::setMainThrust(const Real value)
+  {
+          //currentThrust_ = value * baseThrust_;
+    currentThrust_.z = value * baseThrust_;
+  }
+
+
+  /**
+  * Gets the ship to accelerate sideways regarding the current direction.
+  * The value should be between 0 and 1, with one beeing full thrust and 0 none.
+  * @param value Acceleration between 0 and 1
+  */
+  void OrxonoxShip::setSideThrust(const Real value)
+  {
+          //currentSideThrust_ = value * baseThrust_;
+    currentThrust_.x = value * baseThrust_;
+  }
+
+
+  /**
+  * Gets the ship to accelerate up and down.
+  * The value should be between 0 and 1, with one beeing full thrust and 0 none.
+  * @param value Acceleration between 0 and 1
+  */
+  void OrxonoxShip::setYThrust(const Real value)
+  {
+    //currentYThrust_ = value * baseThrust_;
+    currentThrust_.y = value * baseThrust_;
+  }
+
+
+  /**
+  * Rotate the ship along with the camera up and down.
+  * @param angle Pitch value.
+  */
+  void OrxonoxShip::turnUpAndDown(const Radian &angle)
+  {
+    rootNode_->pitch(-angle, Node::TS_LOCAL);
+  }
+
+
+  /**
+  * Rotate the ship along with the camera left and right.
+  * @param angle Yaw value.
+  */
+  void OrxonoxShip::turnLeftAndRight(const Radian &angle)
+  {
+    rootNode_->yaw(-angle, Node::TS_PARENT);
+  }
+
+
+  /**
+  * Returns the current speed of the ship according to its parent node.
+  * @return The current speed.
+  */
+  Vector3 OrxonoxShip::getSpeed()
+  {
+    return currentSpeed_;
+  }
+
+  /**
+  * Returns the ship's root SceneNode.
+  * @return The Root Node.
+  */
+  SceneNode* OrxonoxShip::getRootNode()
+  {
+    return rootNode_;
+  }
+
+
+  /**
+  * Fire a bullet (Entity with SceneNode).
+  * This method creates a new Entity plus a SceneNode. But be sure not make
+  * the new Node a child of RootNode_!
+  * @return Bullet containing speed and entity.
+  */
+  Bullet* OrxonoxShip::fire()
+  {
+          // TODO: Names must be unique!
+          SceneNode *temp = rootNode_->getParentSceneNode()->createChildSceneNode(
+          "BulletNode" + StringConverter::toString(objectCounter_));
+          temp->setOrientation(rootNode_->getOrientation());
+          temp->setPosition(rootNode_->getPosition());
+          temp->setScale(Vector3(1, 1, 1) * 10);
+          temp->yaw(Degree(-90));
+          return new Bullet(temp, sceneMgr_->createEntity("bullet"
+          + StringConverter::toString(objectCounter_++), "Barrel.mesh"), currentSpeed_
+          + (rootNode_->getOrientation() * Vector3(0, 0, -1)).normalisedCopy()
+          * bulletSpeed_);
+  }
+
+
+  /**
+  * Standard tick() function.
+  * Currently, only the speed is applied according to the thrust values.
+  * @param time Absolute time.
+  * @param deltaTime Relative time.
+  * @return Return true to continue render
+  */
+  bool OrxonoxShip::tick(unsigned long time, Real deltaTime)
+  {
+    Quaternion quad = rootNode_->getOrientation();
+    quad.normalise();
+    currentSpeed_ += quad * (Vector3(-1, -1, -1) * currentThrust_) * deltaTime;
+    //currentSpeed_ += quad * Vector3(0, 0, -1) * currentThrust_ * deltaTime;
+          //currentSpeed_ += quad * Vector3(-1, 0,  0) * currentSideThrust_ * deltaTime;
+
+          rootNode_->translate(currentSpeed_ * deltaTime);
+
+          return true;
+  }
+
 }
-
-
-/**
-* Standard destructor.
-* Doesn't have any work to do yet.
-*/
-OrxonoxShip::~OrxonoxShip()
-{
-}
-
-
-/**
-* Initialises everything.
-* Once that ResourceGroups are organised, this method loads them.
-* It might be an idea to make this function static in order for the
-* SceneManger to call the initialise method of every needed class (macros..)
-* @return Returns false when failed.
-*/
-bool OrxonoxShip::initialise()
-{
-        // load all the resources needed (no resource groups yet,
-  // so the allInit is not executed!)
-        // ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
-
-        // create the "space ship" (currently a fish..)
-        // TODO: names must be unique! use static variables..
-        shipEntity_ = sceneMgr_->createEntity("Ship", "fish.mesh");
-        SceneNode *fishNode = rootNode_->createChildSceneNode("fishNode");
-        fishNode->yaw(Degree(-90));
-        fishNode->attachObject(shipEntity_);
-        fishNode->setScale(Vector3(10, 10, 10));
-
-        return true;
-}
-
-
-/**
-* Gets the ship to accelerate in the current direction.
-* The value should be between 0 and 1, with one beeing full thrust and 0 none.
-* @param value Acceleration between 0 and 1
-*/
-void OrxonoxShip::setMainThrust(const Real value)
-{
-        //currentThrust_ = value * baseThrust_;
-  currentThrust_.z = value * baseThrust_;
-}
-
-
-/**
-* Gets the ship to accelerate sideways regarding the current direction.
-* The value should be between 0 and 1, with one beeing full thrust and 0 none.
-* @param value Acceleration between 0 and 1
-*/
-void OrxonoxShip::setSideThrust(const Real value)
-{
-        //currentSideThrust_ = value * baseThrust_;
-  currentThrust_.x = value * baseThrust_;
-}
-
-
-/**
-* Gets the ship to accelerate up and down.
-* The value should be between 0 and 1, with one beeing full thrust and 0 none.
-* @param value Acceleration between 0 and 1
-*/
-void OrxonoxShip::setYThrust(const Real value)
-{
-  //currentYThrust_ = value * baseThrust_;
-  currentThrust_.y = value * baseThrust_;
-}
-
-
-/**
-* Rotate the ship along with the camera up and down.
-* @param angle Pitch value.
-*/
-void OrxonoxShip::turnUpAndDown(const Radian &angle)
-{
-  rootNode_->pitch(-angle, Node::TS_LOCAL);
-}
-
-
-/**
-* Rotate the ship along with the camera left and right.
-* @param angle Yaw value.
-*/
-void OrxonoxShip::turnLeftAndRight(const Radian &angle)
-{
-  rootNode_->yaw(-angle, Node::TS_PARENT);
-}
-
-
-/**
-* Returns the current speed of the ship according to its parent node.
-* @return The current speed.
-*/
-Vector3 OrxonoxShip::getSpeed()
-{
-  return currentSpeed_;
-}
-
-/**
-* Returns the ship's root SceneNode.
-* @return The Root Node.
-*/
-SceneNode* OrxonoxShip::getRootNode()
-{
-  return rootNode_;
-}
-
-
-/**
-* Fire a bullet (Entity with SceneNode).
-* This method creates a new Entity plus a SceneNode. But be sure not make
-* the new Node a child of RootNode_!
-* @return Bullet containing speed and entity.
-*/
-Bullet* OrxonoxShip::fire()
-{
-        // TODO: Names must be unique!
-        SceneNode *temp = rootNode_->getParentSceneNode()->createChildSceneNode(
-        "BulletNode" + StringConverter::toString(objectCounter_));
-        temp->setOrientation(rootNode_->getOrientation());
-        temp->setPosition(rootNode_->getPosition());
-        temp->setScale(Vector3(1, 1, 1) * 10);
-        temp->yaw(Degree(-90));
-        return new Bullet(temp, sceneMgr_->createEntity("bullet"
-        + StringConverter::toString(objectCounter_++), "Barrel.mesh"), currentSpeed_
-        + (rootNode_->getOrientation() * Vector3(0, 0, -1)).normalisedCopy()
-        * bulletSpeed_);
-}
-
-
-/**
-* Standard tick() function.
-* Currently, only the speed is applied according to the thrust values.
-* @param time Absolute time.
-* @param deltaTime Relative time.
-* @return Return true to continue render
-*/
-bool OrxonoxShip::tick(unsigned long time, Real deltaTime)
-{
-  Quaternion quad = rootNode_->getOrientation();
-  quad.normalise();
-  currentSpeed_ += quad * (Vector3(-1, -1, -1) * currentThrust_) * deltaTime;
-  //currentSpeed_ += quad * Vector3(0, 0, -1) * currentThrust_ * deltaTime;
-        //currentSpeed_ += quad * Vector3(-1, 0,  0) * currentSideThrust_ * deltaTime;
-
-        rootNode_->translate(currentSpeed_ * deltaTime);
-
-        return true;
-}

code/branches/main_reto_vs05/src/run_manager.cc

@@ -39 +39 @@
 */
 
+#include "Ogre.h"
+//#include "OgreRoot.h"
+//#include "OgreSceneManager.h"
+//#include "OgreSceneNode.h"
+//#include "OgreCamera.h"
+//#include "OgreViewport.h"
+//#include "OgreRenderWindow.h"
+//#include "OgreOverlay.h"
+//#include "OgreOverlayManager.h"
+//#include "OgreOverlayElement.h"
+//#include "OgreTextureManager.h"
+//#include "OgreMaterialManager.h"
+//#include "OgreLogManager.h"
+//#include "OgreVector3.h"
+//#include "OgreStringConverter.h"
+//#include "OgreWindowEventUtilities.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>
+
+#include "ogre_control.h"
+#include "orxonox_scene.h"
+#include "orxonox_ship.h"
+#include "bullet.h"
+#include "camera_manager.h"
+
 #include "run_manager.h"
 
-
-/**
-* Contructor only needs the render window and the Root object which are both
-* the OgreControl object.
-* Right now the constructor does all the initialisation work. This could also
-* be done in a new method "initialize()", for whatever purpose.
-* 
-* 
-* @param ogre_ The OgreControl object holding the render window and the Root
-*/
-RunManager::RunManager(OgreControl * ogre)
-      : ogre_(ogre), window_(ogre->getRenderWindow()), leftButtonDown_(false),
-      statsOn_(true), screenShotCounter_(0), timeUntilNextToggle_(0),
-      filtering_(TFO_BILINEAR), aniso_(1), sceneDetailIndex_(0),
-      mouseSensitivity_(0.003),
-      debugOverlay_(0), inputManager_(0), mouse_(0), keyboard_(0), joystick_(0)
-{
-
-  // SETTING UP THE SCENE
-
-  // create one new SceneManger
-  sceneMgr_ = ogre_->getRoot()->createSceneManager(ST_GENERIC, "backgroundScene_");
-
-  // background scene (world objects, skybox, lights, etc.)
-  backgroundScene_ = new OrxonoxScene(sceneMgr_);
-
-  // PLAYER SPACESHIP
-
-  // Create a space ship object and its SceneNode.
-  // Some ideas about the steering: The ship should only receive events like
-  // up, down, left, right, roll left, roll right, move down, move up, etc).
-  // Multiple interpretations of these commands would make the game more
-  // but it also makes AI steering more difficult, since for every type of
-  // steering, new methods have to be written.
-  // --> clearly define how a space ship can fly (rolling?, conservation of
-  // impuls?, direct mouse sight steeering?, etc.)
-  // It should also be considered, that the ship should provide another Node
-  // for a camera to be attached (otherwise the spaceship in front of the
-  // would be very static, never moving at all).
-
-  // Construct a new spaceship and give it the node
-  playerShip_ = new OrxonoxShip(sceneMgr_, sceneMgr_->getRootSceneNode()
-    ->createChildSceneNode("ShipNode", Vector3(20, 20, 20)));
-
-
-  // RESOURCE LOADING (using ResourceGroups if implemented)
-
-  // load all resources and create the entities by calling the initialise()
-  // methods for each object (don't initialise in the constructor!).
-  backgroundScene_->initialise();
-  playerShip_->initialise();
-
-
-  // CAMERA AND VIEWPORT
-  // TODO: create a camera manager. It should be able to change its position
-  // around the space ship (predefined states would be nice too). And it should
-  // also be able to switch between different locations (like ship, spactator,
-  // certain fixed positions (e.g. finish line, etc.)). These are just ideas.
-
-  // create camera and viewport
-  createCamera();
-  createViewports();
-
-
-  // Set default mipmap level (NB some APIs ignore this)
-  TextureManager::getSingleton().setDefaultNumMipmaps(5);
-
-  
-  // BULLET LIST FOR THE TEST APPLICATION
-
-  // TODO: Use STL to make life easier. But it works this way too..
-  bullets_ = new Bullet*[10];
-  bulletsIndex_ = 0;
-  bulletsSize_ = 10;
-
-
-  // HUMAN INTERFACE
-
-  using namespace OIS;
-
-  debugOverlay_ = OverlayManager::getSingleton()
-    .getByName("Core/DebugOverlay");
-
-  LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");
-  ParamList pl;
-  size_t windowHnd = 0;
-  std::ostringstream windowHndStr;
-
-  window_->getCustomAttribute("WINDOW", &windowHnd);
-  windowHndStr << windowHnd;
-  pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
-
-  inputManager_ = InputManager::createInputSystem( pl );
-
-  // Create all devices (We only catch joystick exceptions here,
-  // as, most people have Key/Mouse)
-  keyboard_ = static_cast<Keyboard*>(inputManager_
-    ->createInputObject( OISKeyboard, false ));
-  mouse_ = static_cast<Mouse*>(inputManager_
-    ->createInputObject( OISMouse, false ));
-  try {
-    joystick_ = static_cast<JoyStick*>(inputManager_
-      ->createInputObject( OISJoyStick, false ));
-  }
-  catch(...) {
-    joystick_ = 0;
-  }
-
-  //Set initial mouse clipping size
-  windowResized(window_);
-
-  showDebugOverlay(true);
-
-  // REGISTER THIS OBJECT AS A WINDOW EVENT LISTENER IN OGRE
-  // It will then receive events liek windowClosed, windowResized, etc.
-  WindowEventUtilities::addWindowEventListener(window_, this);
+namespace Orxonox {
+  using namespace Ogre;
+
+  /**
+  * Contructor only needs the render window and the Root object which are both
+  * the OgreControl object.
+  * Right now the constructor does all the initialisation work. This could also
+  * be done in a new method "initialize()", for whatever purpose.
+  * 
+  * 
+  * @param ogre_ The OgreControl object holding the render window and the Root
+  */
+  RunManager::RunManager(OgreControl * ogre)
+        : ogre_(ogre), window_(ogre->getRenderWindow()), leftButtonDown_(false),
+        statsOn_(true), screenShotCounter_(0), timeUntilNextToggle_(0),
+        filtering_(TFO_BILINEAR), aniso_(1), sceneDetailIndex_(0),
+        mouseSensitivity_(0.003),
+        debugOverlay_(0), inputManager_(0), mouse_(0), keyboard_(0), joystick_(0)
+  {
+
+    // SETTING UP THE SCENE
+
+    // create one new SceneManger
+    sceneMgr_ = ogre_->getRoot()->createSceneManager(ST_GENERIC, "backgroundScene_");
+
+    // background scene (world objects, skybox, lights, etc.)
+    backgroundScene_ = new OrxonoxScene(sceneMgr_);
+
+    // PLAYER SPACESHIP
+
+    // Create a space ship object and its SceneNode.
+    // Some ideas about the steering: The ship should only receive events like
+    // up, down, left, right, roll left, roll right, move down, move up, etc).
+    // Multiple interpretations of these commands would make the game more
+    // but it also makes AI steering more difficult, since for every type of
+    // steering, new methods have to be written.
+    // --> clearly define how a space ship can fly (rolling?, conservation of
+    // impuls?, direct mouse sight steeering?, etc.)
+    // It should also be considered, that the ship should provide another Node
+    // for a camera to be attached (otherwise the spaceship in front of the
+    // would be very static, never moving at all).
+
+    // Construct a new spaceship and give it the node
+    playerShip_ = new OrxonoxShip(sceneMgr_, sceneMgr_->getRootSceneNode()
+      ->createChildSceneNode("ShipNode", Vector3(20, 20, 20)));
+
+
+    // RESOURCE LOADING (using ResourceGroups if implemented)
+
+    // load all resources and create the entities by calling the initialise()
+    // methods for each object (don't initialise in the constructor!).
+    backgroundScene_->initialise();
+    playerShip_->initialise();
+
+
+    // CAMERA AND VIEWPORT
+    // TODO: create a camera manager. It should be able to change its position
+    // around the space ship (predefined states would be nice too). And it should
+    // also be able to switch between different locations (like ship, spactator,
+    // certain fixed positions (e.g. finish line, etc.)). These are just ideas.
+
+    // create camera and viewport
+    createCamera();
+    createViewports();
+
+
+    // Set default mipmap level (NB some APIs ignore this)
+    TextureManager::getSingleton().setDefaultNumMipmaps(5);
+
+    
+    // BULLET LIST FOR THE TEST APPLICATION
+
+    // TODO: Use STL to make life easier. But it works this way too..
+    bullets_ = new Bullet*[10];
+    bulletsIndex_ = 0;
+    bulletsSize_ = 10;
+
+
+    // HUMAN INTERFACE
+
+    using namespace OIS;
+
+    debugOverlay_ = OverlayManager::getSingleton()
+      .getByName("Core/DebugOverlay");
+
+    LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");
+    ParamList pl;
+    size_t windowHnd = 0;
+    std::ostringstream windowHndStr;
+
+    window_->getCustomAttribute("WINDOW", &windowHnd);
+    windowHndStr << windowHnd;
+    pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
+
+    inputManager_ = InputManager::createInputSystem( pl );
+
+    // Create all devices (We only catch joystick exceptions here,
+    // as, most people have Key/Mouse)
+    keyboard_ = static_cast<Keyboard*>(inputManager_
+      ->createInputObject( OISKeyboard, false ));
+    mouse_ = static_cast<Mouse*>(inputManager_
+      ->createInputObject( OISMouse, false ));
+    try {
+      joystick_ = static_cast<JoyStick*>(inputManager_
+        ->createInputObject( OISJoyStick, false ));
+    }
+    catch(...) {
+      joystick_ = 0;
+    }
+
+    //Set initial mouse clipping size
+    windowResized(window_);
+
+    showDebugOverlay(true);
+
+    // REGISTER THIS OBJECT AS A WINDOW EVENT LISTENER IN OGRE
+    // It will then receive events liek windowClosed, windowResized, etc.
+    WindowEventUtilities::addWindowEventListener(window_, this);
+  }
+
+  /**
+  * Standard destructor.
+  * Removes this object as a window event listener and deletes all created
+  * variables.
+  */
+  RunManager::~RunManager()
+  {
+    //Remove ourself as a Window listener
+    WindowEventUtilities::removeWindowEventListener(window_, this);
+    windowClosed(window_);
+
+    if (backgroundScene_)
+      delete backgroundScene_;
+    if (playerShip_)
+      delete playerShip_;
+
+    // clean up the bullet list
+    for (int i = 0; i < bulletsIndex_; i++)
+      delete bullets_[i];
+    delete bullets_;
+  }
+
+
+  /**
+  * Method to compute anyting between 2 frames.
+  * 
+  * Everything that needs to be computed during the games happens right here.
+  * The only exception are the listeners (which should only set variables,
+  * not actually do something).
+  * 
+  * @param time Absolute play time
+  * @param deltaTime Time passed since last frame
+  * @return Return false to end rendering
+  */
+  bool RunManager::tick(unsigned long time, float deltaTime)
+  {
+    // synchronize with internal class timer
+    totalTime_ = time;
+
+    // Call tick() for every object
+    // This could be done by registering (needs a factory..)
+    backgroundScene_->tick(time, deltaTime);
+    playerShip_->tick(time, deltaTime);
+
+
+    // Update the 'HUD'
+    updateStats();
+
+    // update the bullet positions
+    for (int i = 0; i < bulletsIndex_; i++)
+    {
+      bullets_[i]->mNode->translate(bullets_[i]->mSpeed*deltaTime);
+      bullets_[i]->mNode->yaw(Degree(deltaTime*100));
+      bullets_[i]->mNode->roll(Degree(deltaTime*300));
+    }
+
+    // HUMAN INTERFACE
+
+    using namespace OIS;
+
+    if(window_->isClosed())     return false;
+
+    //Need to capture/update each device
+    keyboard_->capture();
+    mouse_->capture();
+    if( joystick_ ) joystick_->capture();
+
+    bool buffJ = (joystick_) ? joystick_->buffered() : true;
+
+    //Check if one of the devices is not buffered
+    if( !mouse_->buffered() || !keyboard_->buffered() || !buffJ )
+    {
+      // one of the input modes is immediate, so setup what
+      // is needed for immediate movement
+      if (timeUntilNextToggle_ >= 0)
+        timeUntilNextToggle_ -= deltaTime;
+    }
+
+    // handle HID devices
+    if( processUnbufferedKeyInput() == false )
+        return false;
+    if( processUnbufferedMouseInput() == false )
+        return false;
+
+    // keep rendering
+    return true;
+  }
+
+
+  /**
+  * Adjust mouse clipping area.
+  * This method is called by Ogre without regards of tick()!
+  * Avoid doing too much in this call.
+  * @param rw render window
+  */
+  void RunManager::windowResized(RenderWindow* rw)
+  {
+    unsigned int width, height, depth;
+    int left, top;
+    rw->getMetrics(width, height, depth, left, top);
+
+    const OIS::MouseState &ms = mouse_->getMouseState();
+    ms.width = width;
+    ms.height = height;
+  }
+
+
+  /**
+  * Unattach OIS before window shutdown (very important under Linux).
+  * Again, avoid computing a lot in this function.
+  * @param rw Render Window
+  */
+  void RunManager::windowClosed(RenderWindow* rw)
+  {
+    //Only close for window that created OIS (the main window in these demos)
+    if( rw == window_ )
+    {
+      if( inputManager_ )
+      {
+        inputManager_->destroyInputObject( mouse_ );
+        inputManager_->destroyInputObject( keyboard_ );
+        inputManager_->destroyInputObject( joystick_ );
+
+        OIS::InputManager::destroyInputSystem(inputManager_);
+        inputManager_ = 0;
+      }
+    }
+  }
+
+  /**
+  * Processes the Keyboard input.
+  * TODO: Use listeners to improve performance.
+  * A lookup table should be implemented to bind any key to a specific action.
+  * @return Return true to keep rendering
+  */
+  bool RunManager::processUnbufferedKeyInput()
+  {
+    using namespace OIS;
+
+    if(keyboard_->isKeyDown(KC_A) || keyboard_->isKeyDown(KC_LEFT))
+      playerShip_->setSideThrust(1);
+    else if(keyboard_->isKeyDown(KC_D) || keyboard_->isKeyDown(KC_RIGHT))
+      playerShip_->setSideThrust(-1);
+    else
+      playerShip_->setSideThrust(0);
+
+    if(keyboard_->isKeyDown(KC_UP) || keyboard_->isKeyDown(KC_W) )
+      playerShip_->setMainThrust(1);
+    else if(keyboard_->isKeyDown(KC_DOWN) || keyboard_->isKeyDown(KC_S) )
+      playerShip_->setMainThrust(-1);
+    else
+      playerShip_->setMainThrust(0);
+
+    if (keyboard_->isKeyDown(KC_C))
+      playerShip_->setYThrust(1);
+    else if (keyboard_->isKeyDown(KC_SPACE))
+      playerShip_->setYThrust(-1);
+    else
+      playerShip_->setYThrust(0);
+
+    if( keyboard_->isKeyDown(KC_ESCAPE) || keyboard_->isKeyDown(KC_Q) )
+      return false;
+
+    if( keyboard_->isKeyDown(KC_F) && timeUntilNextToggle_ <= 0 )
+    {
+      statsOn_ = !statsOn_;
+      showDebugOverlay(statsOn_);
+      timeUntilNextToggle_ = 1;
+    }
+
+    if( keyboard_->isKeyDown(KC_T) && timeUntilNextToggle_ <= 0 )
+    {
+      switch(filtering_)
+      {
+      case TFO_BILINEAR:
+        filtering_ = TFO_TRILINEAR;
+        aniso_ = 1;
+        break;
+      case TFO_TRILINEAR:
+        filtering_ = TFO_ANISOTROPIC;
+        aniso_ = 8;
+        break;
+      case TFO_ANISOTROPIC:
+        filtering_ = TFO_BILINEAR;
+        aniso_ = 1;
+        break;
+      default: break;
+      }
+      MaterialManager::getSingleton().setDefaultTextureFiltering(filtering_);
+      MaterialManager::getSingleton().setDefaultAnisotropy(aniso_);
+
+      showDebugOverlay(statsOn_);
+      timeUntilNextToggle_ = 1;
+    }
+
+    if(keyboard_->isKeyDown(KC_SYSRQ) && timeUntilNextToggle_ <= 0)
+    {
+      std::ostringstream ss;
+      ss << "screenshot_" << ++screenShotCounter_ << ".png";
+      window_->writeContentsToFile(ss.str());
+      timeUntilNextToggle_ = 0.5;
+      debugText_ = "Saved: " + ss.str();
+    }
+
+    if(keyboard_->isKeyDown(KC_R) && timeUntilNextToggle_ <=0)
+    {
+      sceneDetailIndex_ = (sceneDetailIndex_+1)%3 ;
+      switch(sceneDetailIndex_) {
+          case 0 : camera_->setPolygonMode(PM_SOLID); break;
+          case 1 : camera_->setPolygonMode(PM_WIREFRAME); break;
+          case 2 : camera_->setPolygonMode(PM_POINTS); break;
+      }
+      timeUntilNextToggle_ = 0.5;
+    }
+
+    static bool displayCameraDetails = false;
+    if(keyboard_->isKeyDown(KC_P) && timeUntilNextToggle_ <= 0)
+    {
+      displayCameraDetails = !displayCameraDetails;
+      timeUntilNextToggle_ = 0.5;
+      if (!displayCameraDetails)
+        debugText_ = "";
+    }
+
+    // Print camera details
+    if(displayCameraDetails)
+      debugText_ = " | Speed = "
+            + StringConverter::toString(playerShip_->getSpeed());
+    // debugText_ = "P: " + StringConverter::toString(camera_
+    //      ->getDerivedPosition()) + " " + "O: "
+    //      + StringConverter::toString(camera_->getDerivedOrientation());
+
+    // Return true to continue rendering
+    return true;
+  }
+
+
+  /**
+  * Processes the Mouse input.
+  * TODO: Use listeners to improve performance.
+  * A lookup table should be implemented to bind ANY button or movement
+  * to a specific action.
+  * @return Return true to keep rendering
+  */
+  bool RunManager::processUnbufferedMouseInput()
+  {
+    using namespace OIS;
+
+    const MouseState &ms = mouse_->getMouseState();
+
+    // This is a 'hack' to show some flying barrels..
+    // Usually, the Bullet created by the ship should be managed
+    // by the physics engine..
+    if (ms.buttonDown(MB_Left) && !leftButtonDown_)
+    {
+      // Prevent continuous fire for the moment.
+      leftButtonDown_ = true;
+      
+      // let ship fire one shot with its only weapon (Barrels..)
+      Bullet *tempBullet = playerShip_->fire();
+
+      // resize array if neccessary (double the size then)
+      if (bulletsIndex_ >= bulletsSize_)
+      {
+        // redimension the array
+        Bullet **tempArray = new Bullet*[2*bulletsSize_];
+        for (int i = 0; i < bulletsSize_; i++)
+          tempArray[i] = bullets_[i];
+        bulletsSize_ *= 2;
+        delete bullets_;
+        bullets_ = tempArray;
+      }
+
+      // add the bullet to the list
+      bullets_[bulletsIndex_++] = tempBullet;
+
+    }
+    else if (!ms.buttons)
+      leftButtonDown_ = false;
+
+    // space ship steering. This should definitely be done in the steering object
+    // Simply give it the mouse movements.
+    playerShip_->turnUpAndDown(Radian(ms.Y.rel * mouseSensitivity_));
+    playerShip_->turnLeftAndRight(Radian(ms.X.rel * mouseSensitivity_));
+    //playerShip_->mRootNode->pitch(Degree(-ms.Y.rel * 0.13), Ogre::Node::TransformSpace::TS_LOCAL);
+    //playerShip_->mRootNode->yaw(Degree(-ms.X.rel * 0.13), Ogre::Node::TransformSpace::TS_PARENT);
+
+    // keep rendering
+    return true;
+  }
+
+  /**
+  * Show the debug overlay of desired.
+  * @param show Whether or not to show the debug overlay
+  */
+  void RunManager::showDebugOverlay(bool show)
+  {
+    if (debugOverlay_)
+    {
+      if (show)
+        debugOverlay_->show();
+      else
+        debugOverlay_->hide();
+    }
+  }
+
+
+  /**
+  * Show stats (e.g. FPS) in the left lower corner of the screen.
+  * Copied from the ExampleFrameListener.h in the Ogre SDK
+  */
+  void RunManager::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 = window_->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(debugText_);
+    }
+    catch(...) { /* ignore */ }
+  }
+
+
+
+  /**
+  * Simple camera creator.
+  * playerShip_Node->attachObject(camera_) should no be here! This is what the camera
+  * manager is for. Right now, this method should do just fine, setting the
+  * cam behind the ship.
+  */
+  void RunManager::createCamera(void)
+  {
+    camera_ = sceneMgr_->createCamera("PlayerCam");
+    playerShip_->getRootNode()->attachObject(camera_);
+    camera_->setNearClipDistance(5);
+    camera_->setPosition(Vector3(0,10,500));
+    camera_->lookAt(Vector3(0,0,0));
+  }
+
+  /**
+  * Simple viewport creator.
+  * TODO: fully understand the concept of viewports concerning orxnox.
+  * E.g. do we need splitscreen mode?
+  * For now the viewport uses the entire render window and is based on the one
+  * camera created so far.
+  */
+  void RunManager::createViewports(void)
+  {
+    // Create one viewport, entire window
+    Viewport* vp = window_->addViewport(camera_);
+    vp->setBackgroundColour(ColourValue(0,0,0));
+
+    // Alter the camera aspect ratio to match the viewport
+    camera_->setAspectRatio(
+      Real(vp->getActualWidth()) / Real(vp->getActualHeight()));
+  }
+
 }
-
-/**
-* Standard destructor.
-* Removes this object as a window event listener and deletes all created
-* variables.
-*/
-RunManager::~RunManager()
-{
-  //Remove ourself as a Window listener
-  WindowEventUtilities::removeWindowEventListener(window_, this);
-  windowClosed(window_);
-
-  if (backgroundScene_)
-    delete backgroundScene_;
-  if (playerShip_)
-    delete playerShip_;
-
-  // clean up the bullet list
-  for (int i = 0; i < bulletsIndex_; i++)
-    delete bullets_[i];
-  delete bullets_;
-}
-
-
-/**
-* Method to compute anyting between 2 frames.
-* 
-* Everything that needs to be computed during the games happens right here.
-* The only exception are the listeners (which should only set variables,
-* not actually do something).
-* 
-* @param time Absolute play time
-* @param deltaTime Time passed since last frame
-* @return Return false to end rendering
-*/
-bool RunManager::tick(unsigned long time, float deltaTime)
-{
-  // synchronize with internal class timer
-  totalTime_ = time;
-
-  // Call tick() for every object
-  // This could be done by registering (needs a factory..)
-  backgroundScene_->tick(time, deltaTime);
-  playerShip_->tick(time, deltaTime);
-
-
-  // Update the 'HUD'
-  updateStats();
-
-  // update the bullet positions
-  for (int i = 0; i < bulletsIndex_; i++)
-  {
-    bullets_[i]->mNode->translate(bullets_[i]->mSpeed*deltaTime);
-    bullets_[i]->mNode->yaw(Degree(deltaTime*100));
-    bullets_[i]->mNode->roll(Degree(deltaTime*300));
-  }
-
-  // HUMAN INTERFACE
-
-  using namespace OIS;
-
-  if(window_->isClosed())       return false;
-
-  //Need to capture/update each device
-  keyboard_->capture();
-  mouse_->capture();
-  if( joystick_ ) joystick_->capture();
-
-  bool buffJ = (joystick_) ? joystick_->buffered() : true;
-
-  //Check if one of the devices is not buffered
-  if( !mouse_->buffered() || !keyboard_->buffered() || !buffJ )
-  {
-    // one of the input modes is immediate, so setup what
-    // is needed for immediate movement
-    if (timeUntilNextToggle_ >= 0)
-      timeUntilNextToggle_ -= deltaTime;
-  }
-
-  // handle HID devices
-  if( processUnbufferedKeyInput() == false )
-      return false;
-  if( processUnbufferedMouseInput() == false )
-      return false;
-
-  // keep rendering
-  return true;
-}
-
-
-/**
-* Adjust mouse clipping area.
-* This method is called by Ogre without regards of tick()!
-* Avoid doing too much in this call.
-* @param rw render window
-*/
-void RunManager::windowResized(RenderWindow* rw)
-{
-  unsigned int width, height, depth;
-  int left, top;
-  rw->getMetrics(width, height, depth, left, top);
-
-  const OIS::MouseState &ms = mouse_->getMouseState();
-  ms.width = width;
-  ms.height = height;
-}
-
-
-/**
-* Unattach OIS before window shutdown (very important under Linux).
-* Again, avoid computing a lot in this function.
-* @param rw Render Window
-*/
-void RunManager::windowClosed(RenderWindow* rw)
-{
-  //Only close for window that created OIS (the main window in these demos)
-  if( rw == window_ )
-  {
-    if( inputManager_ )
-    {
-      inputManager_->destroyInputObject( mouse_ );
-      inputManager_->destroyInputObject( keyboard_ );
-      inputManager_->destroyInputObject( joystick_ );
-
-      OIS::InputManager::destroyInputSystem(inputManager_);
-      inputManager_ = 0;
-    }
-  }
-}
-
-/**
-* Processes the Keyboard input.
-* TODO: Use listeners to improve performance.
-* A lookup table should be implemented to bind any key to a specific action.
-* @return Return true to keep rendering
-*/
-bool RunManager::processUnbufferedKeyInput()
-{
-  using namespace OIS;
-
-  if(keyboard_->isKeyDown(KC_A) || keyboard_->isKeyDown(KC_LEFT))
-    playerShip_->setSideThrust(1);
-  else if(keyboard_->isKeyDown(KC_D) || keyboard_->isKeyDown(KC_RIGHT))
-    playerShip_->setSideThrust(-1);
-  else
-    playerShip_->setSideThrust(0);
-
-  if(keyboard_->isKeyDown(KC_UP) || keyboard_->isKeyDown(KC_W) )
-    playerShip_->setMainThrust(1);
-  else if(keyboard_->isKeyDown(KC_DOWN) || keyboard_->isKeyDown(KC_S) )
-    playerShip_->setMainThrust(-1);
-  else
-    playerShip_->setMainThrust(0);
-
-  if (keyboard_->isKeyDown(KC_C))
-    playerShip_->setYThrust(1);
-  else if (keyboard_->isKeyDown(KC_SPACE))
-    playerShip_->setYThrust(-1);
-  else
-    playerShip_->setYThrust(0);
-
-  if( keyboard_->isKeyDown(KC_ESCAPE) || keyboard_->isKeyDown(KC_Q) )
-    return false;
-
-  if( keyboard_->isKeyDown(KC_F) && timeUntilNextToggle_ <= 0 )
-  {
-    statsOn_ = !statsOn_;
-    showDebugOverlay(statsOn_);
-    timeUntilNextToggle_ = 1;
-  }
-
-  if( keyboard_->isKeyDown(KC_T) && timeUntilNextToggle_ <= 0 )
-  {
-    switch(filtering_)
-    {
-    case TFO_BILINEAR:
-      filtering_ = TFO_TRILINEAR;
-      aniso_ = 1;
-      break;
-    case TFO_TRILINEAR:
-      filtering_ = TFO_ANISOTROPIC;
-      aniso_ = 8;
-      break;
-    case TFO_ANISOTROPIC:
-      filtering_ = TFO_BILINEAR;
-      aniso_ = 1;
-      break;
-    default: break;
-    }
-    MaterialManager::getSingleton().setDefaultTextureFiltering(filtering_);
-    MaterialManager::getSingleton().setDefaultAnisotropy(aniso_);
-
-    showDebugOverlay(statsOn_);
-    timeUntilNextToggle_ = 1;
-  }
-
-  if(keyboard_->isKeyDown(KC_SYSRQ) && timeUntilNextToggle_ <= 0)
-  {
-    std::ostringstream ss;
-    ss << "screenshot_" << ++screenShotCounter_ << ".png";
-    window_->writeContentsToFile(ss.str());
-    timeUntilNextToggle_ = 0.5;
-    debugText_ = "Saved: " + ss.str();
-  }
-
-  if(keyboard_->isKeyDown(KC_R) && timeUntilNextToggle_ <=0)
-  {
-    sceneDetailIndex_ = (sceneDetailIndex_+1)%3 ;
-    switch(sceneDetailIndex_) {
-        case 0 : camera_->setPolygonMode(PM_SOLID); break;
-        case 1 : camera_->setPolygonMode(PM_WIREFRAME); break;
-        case 2 : camera_->setPolygonMode(PM_POINTS); break;
-    }
-    timeUntilNextToggle_ = 0.5;
-  }
-
-  static bool displayCameraDetails = false;
-  if(keyboard_->isKeyDown(KC_P) && timeUntilNextToggle_ <= 0)
-  {
-    displayCameraDetails = !displayCameraDetails;
-    timeUntilNextToggle_ = 0.5;
-    if (!displayCameraDetails)
-      debugText_ = "";
-  }
-
-  // Print camera details
-  if(displayCameraDetails)
-    debugText_ = " | Speed = "
-          + StringConverter::toString(playerShip_->getSpeed());
-  // debugText_ = "P: " + StringConverter::toString(camera_
-  //      ->getDerivedPosition()) + " " + "O: "
-  //      + StringConverter::toString(camera_->getDerivedOrientation());
-
-  // Return true to continue rendering
-  return true;
-}
-
-
-/**
-* Processes the Mouse input.
-* TODO: Use listeners to improve performance.
-* A lookup table should be implemented to bind ANY button or movement
-* to a specific action.
-* @return Return true to keep rendering
-*/
-bool RunManager::processUnbufferedMouseInput()
-{
-  using namespace OIS;
-
-  const MouseState &ms = mouse_->getMouseState();
-
-  // This is a 'hack' to show some flying barrels..
-  // Usually, the Bullet created by the ship should be managed
-  // by the physics engine..
-  if (ms.buttonDown(MB_Left) && !leftButtonDown_)
-  {
-    // Prevent continuous fire for the moment.
-    leftButtonDown_ = true;
-    
-    // let ship fire one shot with its only weapon (Barrels..)
-    Bullet *tempBullet = playerShip_->fire();
-
-    // resize array if neccessary (double the size then)
-    if (bulletsIndex_ >= bulletsSize_)
-    {
-      // redimension the array
-      Bullet **tempArray = new Bullet*[2*bulletsSize_];
-      for (int i = 0; i < bulletsSize_; i++)
-        tempArray[i] = bullets_[i];
-      bulletsSize_ *= 2;
-      delete bullets_;
-      bullets_ = tempArray;
-    }
-
-    // add the bullet to the list
-    bullets_[bulletsIndex_++] = tempBullet;
-
-  }
-  else if (!ms.buttons)
-    leftButtonDown_ = false;
-
-  // space ship steering. This should definitely be done in the steering object
-  // Simply give it the mouse movements.
-  playerShip_->turnUpAndDown(Radian(ms.Y.rel * mouseSensitivity_));
-  playerShip_->turnLeftAndRight(Radian(ms.X.rel * mouseSensitivity_));
-  //playerShip_->mRootNode->pitch(Degree(-ms.Y.rel * 0.13), Ogre::Node::TransformSpace::TS_LOCAL);
-  //playerShip_->mRootNode->yaw(Degree(-ms.X.rel * 0.13), Ogre::Node::TransformSpace::TS_PARENT);
-
-  // keep rendering
-  return true;
-}
-
-/**
-* Show the debug overlay of desired.
-* @param show Whether or not to show the debug overlay
-*/
-void RunManager::showDebugOverlay(bool show)
-{
-  if (debugOverlay_)
-  {
-    if (show)
-      debugOverlay_->show();
-    else
-      debugOverlay_->hide();
-  }
-}
-
-
-/**
-* Show stats (e.g. FPS) in the left lower corner of the screen.
-* Copied from the ExampleFrameListener.h in the Ogre SDK
-*/
-void RunManager::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 = window_->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(debugText_);
-  }
-  catch(...) { /* ignore */ }
-}
-
-
-
-/**
-* Simple camera creator.
-* playerShip_Node->attachObject(camera_) should no be here! This is what the camera
-* manager is for. Right now, this method should do just fine, setting the
-* cam behind the ship.
-*/
-void RunManager::createCamera(void)
-{
-  camera_ = sceneMgr_->createCamera("PlayerCam");
-  playerShip_->getRootNode()->attachObject(camera_);
-  camera_->setNearClipDistance(5);
-  camera_->setPosition(Vector3(0,10,500));
-  camera_->lookAt(Vector3(0,0,0));
-}
-
-/**
-* Simple viewport creator.
-* TODO: fully understand the concept of viewports concerning orxnox.
-* E.g. do we need splitscreen mode?
-* For now the viewport uses the entire render window and is based on the one
-* camera created so far.
-*/
-void RunManager::createViewports(void)
-{
-  // Create one viewport, entire window
-  Viewport* vp = window_->addViewport(camera_);
-  vp->setBackgroundColour(ColourValue(0,0,0));
-
-  // Alter the camera aspect ratio to match the viewport
-  camera_->setAspectRatio(
-    Real(vp->getActualWidth()) / Real(vp->getActualHeight()));
-}

code/branches/main_reto_vs05/src/weapon_manager.cc

@@ -26 +26 @@
  */
 
+#include "OgreSceneManager.h"
+
 #include "weapon_manager.h"
 
-WeaponManager::WeaponManager(SceneManager *mSceneMgr)
-{
-        
-}
+
+namespace Orxonox {
+  using namespace Ogre;
+
+  WeaponManager::WeaponManager(SceneManager *mSceneMgr)
+  {
+        
+  }
 
 
-WeaponManager::~WeaponManager()
-{
+  WeaponManager::~WeaponManager()
+  {
+  }
+
 }