Changeset 8079 for code/trunk/src

code/trunk

Property svn:mergeinfo changed

/code/branches/kicklib (added)	merged: 7975,7977
/code/branches/usability (added)	merged: 7915-7916,7922,7924-7930,7935-7936,7938-7939,7962-7963,7966,7970,7972,7976,7978,7985-8003,8005-8006,8008,8013,8018-8041,8076-8078

code/trunk/src/CMakeLists.txt

r7955	r8079
119	119	ADD_SUBDIRECTORY(libraries)
120	120	ADD_SUBDIRECTORY(orxonox)
	121	SET(ORXONOX_MODULES CACHE INTERNAL "")
121	122	ADD_SUBDIRECTORY(modules)
122	123

code/trunk/src/external/enet/win32.c

r7954	r8079
11	11	#define ENET_BUILDING_LIB 1
12	12	#include "enet/enet.h"
	13	#include <ws2tcpip.h>
13	14
14	15	static enet_uint32 timeBase = 0;

code/trunk/src/libraries/core/CMakeLists.txt

-                      r7284
+                      r8079
   OrxonoxClass.cc
   Resource.cc
-  WindowEventListener.cc
   # hierarchy
 …
   Template.cc
   XMLPort.cc
+COMPILATION_BEGIN ListenerCompilation.cc
+  ViewportEventListener.cc
+  WindowEventListener.cc
   XMLNameListener.cc
+COMPILATION_END
 COMPILATION_BEGIN FilesystemCompilation.cc
 …
     Game.h
     GameMode.h
+    GraphicsManager.h
     GUIManager.h
     Loader.h

code/trunk/src/libraries/core/Core.cc

-                      r7872
+                      r8079
 #ifdef ORXONOX_RELEASE
         const unsigned int defaultLevelLogFile = 3;
+        SetConfigValue(bDevMode_, false)
+            .description("Developer mode. If not set, hides some things from the user to not confuse him.");
 #else
         const unsigned int defaultLevelLogFile = 4;
+        SetConfigValue(bDevMode_, true)
+            .description("Developer mode. If not set, hides some things from the user to not confuse him.");
 #endif
         SetConfigValueExternal(softDebugLevelLogFile_, "OutputHandler", "softDebugLevelLogFile", defaultLevelLogFile)

code/trunk/src/libraries/core/Core.h

-                      r7870
+                      r8079
                 { return this->ogreConfigTimestamp_; }
+            inline bool inDevMode(void) const
+                { return this->bDevMode_; }
         private:
             Core(const Core&); //!< Don't use (undefined symbol)
 …
             long long                     lastLevelTimestamp_;         ///< Timestamp when the last level was started
             long long                     ogreConfigTimestamp_;        ///< Timestamp wehen the ogre config level was modified
+            bool                          bDevMode_;                   //!< Developers bit. If set to false, some options are not available as to not confuse the normal user.
             static Core*                  singletonPtr_s;

code/trunk/src/libraries/core/CorePrereqs.h

r7849	r8079
182	182	class Thread;
183	183	class ThreadPool;
	184	class ViewportEventListener;
184	185	template <class T>
185	186	class WeakPtr;

code/trunk/src/libraries/core/GUIManager.cc

-                      r7876
+                      r8079
 #include <boost/bind.hpp>
 #include <memory>
+extern "C" {
+#include <lua.h>
+}
 #include <CEGUIDefaultLogger.h>
 #include <CEGUIExceptions.h>
 …
     SetConsoleCommand("showGUI", &GUIManager::showGUI).defaultValue(1, false).defaultValue(2, false);
     SetConsoleCommand("hideGUI", &GUIManager::hideGUI);
+    SetConsoleCommand("toggleGUI", &GUIManager::toggleGUI).defaultValue(1, false).defaultValue(2, false);
     /**
 …
+    {
         GUIManager::getInstance().executeCode("hideMenuSheet(\"" + name + "\")");
+    }
+    /**
+    @brief
+        Toggles specified GUI.
+        If the GUI with the input name is already shown and on the top, it is hidden, else it is shown.
+    */
+    /*static*/ void GUIManager::toggleGUI(const std::string& name, bool bHidePrevious, bool bNoInput)
+    {
+        GUIManager::getInstance().executeCode("getGUIFirstActive(\"" + name + "\", " + multi_cast<std::string>(bHidePrevious) + ", " + multi_cast<std::string>(bNoInput) + ")");
+    }
+    /**
+    @brief
+        Helper method to toggle a specified GUI.
+        Is called by lua.
+    */
+    void GUIManager::toggleGUIHelper(const std::string& name, bool bHidePrevious, bool bNoInput, bool show)
+    {
+        if(show)
+            GUIManager::showGUI(name, bHidePrevious, bNoInput);
+        else
+            GUIManager::hideGUI(name);
+    }
 …
     void GUIManager::windowResized(unsigned int newWidth, unsigned int newHeight)
+    {
         this->guiRenderer_->setDisplaySize(CEGUI::Size(newWidth, newHeight));
+    }
     /**
         @brief Notify CEGUI if the windows loses the focus (stops higlight of menu items, etc).
+        this->guiRenderer_->setDisplaySize(CEGUI::Size((float)newWidth, (float)newHeight));
+    }
+    /**
+        @brief Notify CEGUI if the windows loses the focus (stops highlighting of menu items, etc).
     */
     void GUIManager::windowFocusChanged(bool bFocus)

code/trunk/src/libraries/core/GUIManager.h

-                      r7874
+                      r8079
 #include "util/Singleton.h"
 #include "input/InputHandler.h"
+#include "Core.h"
 #include "OrxonoxClass.h"
 #include "WindowEventListener.h"
 …
         void showGUIExtra(const std::string& name, const std::string& ptr, bool bHidePrevious = false, bool bNoInput = false);
         static void hideGUI(const std::string& name);
+        static void toggleGUI(const std::string& name, bool bHidePrevious = false, bool bNoInput = false);
+        void toggleGUIHelper(const std::string& name, bool bHidePrevious, bool bNoInput, bool show); // tolua_export
         void keyESC();
         void setBackgroundImage(const std::string& imageSet, const std::string imageName); // tolua_export
         void setBackgroundImage(const std::string& image);
+        /**
+        @brief Helper method to get the developer's mode without having to export Core.h.
+        @see Core::inDevMode
+        */
+        static bool inDevMode(void) { return Core::getInstance().inDevMode(); } // tolua_export
         //! Creates a new InputState to be used with a GUI Sheet

code/trunk/src/libraries/core/Game.cc

-                      r7284
+                      r8079
 #include "GameMode.h"
 #include "GameState.h"
+#include "GraphicsManager.h"
 #include "GUIManager.h"
 #include "command/ConsoleCommand.h"
 …
     static void printFPS()
         { COUT(0) << Game::getInstance().getAvgFPS() << std::endl; }
     SetConsoleCommand("printFPS", &printFPS);
+    SetConsoleCommand("Stats", "printFPS", &printFPS);
     static void printTickTime()
         { COUT(0) << Game::getInstance().getAvgTickTime() << std::endl; }
     SetConsoleCommand("printTickTime", &printTickTime);
+    SetConsoleCommand("Stats", "printTickTime", &printTickTime);
     std::map<std::string, GameStateInfo> Game::gameStateDeclarations_s;
 …
         SetConfigValue(statisticsAvgLength_, 1000000)
             .description("Sets the time in microseconds interval at which average fps, etc. gets calculated.");
+        SetConfigValue(fpsLimit_, 50)
+        SetConfigValueExternal(fpsLimit_, "GraphicsSettings", "fpsLimit", 50)
             .description("Sets the desired frame rate (0 for no limit).");
+    }
 …
             // Limit frame rate
+            this->updateFPSLimiter();
+            static bool hasVSync = GraphicsManager::getInstance().hasVSyncEnabled(); // can be static since changes of VSync currently require a restart
+            if (this->fpsLimit_ > 0 && !hasVSync)
+                this->updateFPSLimiter();
+        }

code/trunk/src/libraries/core/GraphicsManager.cc

-                      r7874
+                      r8079
 #include "SpecialConfig.h"
 #include "util/Clock.h"
+#include "util/Convert.h"
 #include "util/Exception.h"
 #include "util/StringUtils.h"
 …
 #include "Game.h"
 #include "GameMode.h"
+#include "GUIManager.h"
 #include "Loader.h"
 #include "MemoryArchive.h"
 #include "PathConfig.h"
+#include "ViewportEventListener.h"
 #include "WindowEventListener.h"
 #include "XMLFile.h"
 #include "command/ConsoleCommand.h"
+#include "input/InputManager.h"
 namespace orxonox
+{
+    static const std::string __CC_GraphicsManager_group = "GraphicsManager";
+    static const std::string __CC_setScreenResolution_name = "setScreenResolution";
+    static const std::string __CC_setFSAA_name = "setFSAA";
+    static const std::string __CC_setVSync_name = "setVSync";
+    DeclareConsoleCommand(__CC_GraphicsManager_group, __CC_setScreenResolution_name, &prototype::string__uint_uint_bool);
+    DeclareConsoleCommand(__CC_GraphicsManager_group, __CC_setFSAA_name, &prototype::string__string);
+    DeclareConsoleCommand(__CC_GraphicsManager_group, __CC_setVSync_name, &prototype::string__bool);
     static const std::string __CC_printScreen_name = "printScreen";
     DeclareConsoleCommand(__CC_printScreen_name, &prototype::void__void);
 …
         , renderWindow_(0)
         , viewport_(0)
+        , lastFrameStartTime_(0.0f)
+        , lastFrameEndTime_(0.0f)
+    {
         RegisterObject(GraphicsManager);
 …
         Ogre::WindowEventUtilities::removeWindowEventListener(renderWindow_, ogreWindowEventListener_.get());
         ModifyConsoleCommand(__CC_printScreen_name).resetFunction();
+        ModifyConsoleCommand(__CC_GraphicsManager_group, __CC_setScreenResolution_name).resetFunction();
+        ModifyConsoleCommand(__CC_GraphicsManager_group, __CC_setFSAA_name).resetFunction();
+        ModifyConsoleCommand(__CC_GraphicsManager_group, __CC_setVSync_name).resetFunction();
         // Undeclare the resources
 …
         CCOUT(4) << "Configuring Renderer" << std::endl;
+        if (!ogreRoot_->restoreConfig() || Core::getInstance().getOgreConfigTimestamp() > Core::getInstance().getLastLevelTimestamp())
+        bool updatedConfig = Core::getInstance().getOgreConfigTimestamp() > Core::getInstance().getLastLevelTimestamp();
+        if (updatedConfig)
+            COUT(2) << "Ogre config file has changed, but no level was started since then. Displaying config dialogue again to verify the changes." << std::endl;
+        if (!ogreRoot_->restoreConfig() || updatedConfig)
+        {
             if (!ogreRoot_->showConfigDialog())
 …
         // add console commands
         ModifyConsoleCommand(__CC_printScreen_name).setFunction(&GraphicsManager::printScreen, this);
+        ModifyConsoleCommand(__CC_GraphicsManager_group, __CC_setScreenResolution_name).setFunction(&GraphicsManager::setScreenResolution, this);
+        ModifyConsoleCommand(__CC_GraphicsManager_group, __CC_setFSAA_name).setFunction(&GraphicsManager::setFSAA, this);
+        ModifyConsoleCommand(__CC_GraphicsManager_group, __CC_setVSync_name).setFunction(&GraphicsManager::setVSync, this);
+    }
 …
     @note
         A note about the Ogre::FrameListener: Even though we don't use them,
+        they still get called. However, the delta times are not correct (except
+        for timeSinceLastFrame, which is the most important). A little research
+        as shown that there is probably only one FrameListener that doesn't even
+        need the time. So we shouldn't run into problems.
+        they still get called.
     */
     void GraphicsManager::postUpdate(const Clock& time)
+    {
+        // Time before rendering
+        uint64_t timeBeforeTick = time.getRealMicroseconds();
+        // Ogre's time keeping object
         Ogre::FrameEvent evt;
+        evt.timeSinceLastFrame = time.getDeltaTime();
+        evt.timeSinceLastEvent = time.getDeltaTime(); // note: same time, but shouldn't matter anyway
+        // don't forget to call _fireFrameStarted to OGRE to make sure
+        // everything goes smoothly
+        // Translate to Ogre float times before the update
+        float temp = lastFrameStartTime_;
+        lastFrameStartTime_ = (float)timeBeforeTick * 0.000001f;
+        evt.timeSinceLastFrame = lastFrameStartTime_ - temp;
+        evt.timeSinceLastEvent = lastFrameStartTime_ - lastFrameEndTime_;
+        // Ogre requires the time too
         ogreRoot_->_fireFrameStarted(evt);
 …
         // This calls the WindowEventListener objects.
         Ogre::WindowEventUtilities::messagePump();
         // make sure the window stays active even when not focused
+        // Make sure the window stays active even when not focused
         // (probably only necessary on windows)
         this->renderWindow_->setActive(true);
-        // Time before rendering
-        uint64_t timeBeforeTick = time.getRealMicroseconds();
         // Render frame
 …
         Game::getInstance().subtractTickTime((int32_t)(timeAfterTick - timeBeforeTick));
+        // again, just to be sure OGRE works fine
+        ogreRoot_->_fireFrameEnded(evt); // note: uses the same time as _fireFrameStarted
+        // Translate to Ogre float times after the update
+        temp = lastFrameEndTime_;
+        lastFrameEndTime_ = (float)timeBeforeTick * 0.000001f;
+        evt.timeSinceLastFrame = lastFrameEndTime_ - temp;
+        evt.timeSinceLastEvent = lastFrameEndTime_ - lastFrameStartTime_;
+        // Ogre also needs the time after the frame finished
+        ogreRoot_->_fireFrameEnded(evt);
+    }
     void GraphicsManager::setCamera(Ogre::Camera* camera)
+    {
+        Ogre::Camera* oldCamera = this->viewport_->getCamera();
         this->viewport_->setCamera(camera);
+        GUIManager::getInstance().setCamera(camera);
+        for (ObjectList<ViewportEventListener>::iterator it = ObjectList<ViewportEventListener>::begin(); it != ObjectList<ViewportEventListener>::end(); ++it)
+            it->cameraChanged(this->viewport_, oldCamera);
+    }
 …
     bool GraphicsManager::isFullScreen() const
+    {
+        return this->renderWindow_->isFullScreen();
+    }
+    unsigned int GraphicsManager::getWindowWidth() const
+    {
+        return this->renderWindow_->getWidth();
+    }
+    unsigned int GraphicsManager::getWindowHeight() const
+    {
+        return this->renderWindow_->getHeight();
+    }
+    bool GraphicsManager::hasVSyncEnabled() const
+    {
         Ogre::ConfigOptionMap& options = ogreRoot_->getRenderSystem()->getConfigOptions();
+        if (options.find("Full Screen") != options.end())
+        {
+            if (options["Full Screen"].currentValue == "Yes")
+                return true;
+            else
+                return false;
+        }
+        Ogre::ConfigOptionMap::iterator it = options.find("VSync");
+        if (it != options.end())
+            return (it->second.currentValue == "Yes");
         else
+        {
-            COUT(0) << "Could not find 'Full Screen' render system option. Fix This!!!" << std::endl;
             return false;
+        }
+    }
+    std::string GraphicsManager::getFSAAMode() const
+    {
+        Ogre::ConfigOptionMap& options = ogreRoot_->getRenderSystem()->getConfigOptions();
+        Ogre::ConfigOptionMap::iterator it = options.find("FSAA");
+        if (it != options.end())
+            return it->second.currentValue;
+        else
+            return "";
+    }
+    std::string GraphicsManager::setScreenResolution(unsigned int width, unsigned int height, bool fullscreen)
+    {
+        // workaround to detect if the colour depth should be written to the config file
+        bool bWriteColourDepth = false;
+        Ogre::ConfigOptionMap& options = ogreRoot_->getRenderSystem()->getConfigOptions();
+        Ogre::ConfigOptionMap::iterator it = options.find("Video Mode");
+        if (it != options.end())
+            bWriteColourDepth = (it->second.currentValue.find('@') != std::string::npos);
+        if (bWriteColourDepth)
+        {
+            this->ogreRoot_->getRenderSystem()->setConfigOption("Video Mode", multi_cast<std::string>(width)
+                                                                    + " x " + multi_cast<std::string>(height)
+                                                                    + " @ " + multi_cast<std::string>(this->getRenderWindow()->getColourDepth()) + "-bit colour");
+        }
+        else
+        {
+            this->ogreRoot_->getRenderSystem()->setConfigOption("Video Mode", multi_cast<std::string>(width)
+                                                                    + " x " + multi_cast<std::string>(height));
+        }
+        this->ogreRoot_->getRenderSystem()->setConfigOption("Full Screen", fullscreen ? "Yes" : "No");
+        std::string validate = this->ogreRoot_->getRenderSystem()->validateConfigOptions();
+        if (validate == "")
+        {
+            GraphicsManager::getInstance().getRenderWindow()->setFullscreen(fullscreen, width, height);
+            this->ogreRoot_->saveConfig();
+            Core::getInstance().updateOgreConfigTimestamp();
+            // Also reload the input devices
+            InputManager::getInstance().reload();
+        }
+        return validate;
+    }
+    std::string GraphicsManager::setFSAA(const std::string& mode)
+    {
+        this->ogreRoot_->getRenderSystem()->setConfigOption("FSAA", mode);
+        std::string validate = this->ogreRoot_->getRenderSystem()->validateConfigOptions();
+        if (validate == "")
+        {
+            //this->ogreRoot_->getRenderSystem()->reinitialise(); // can't use this that easily, because it recreates the render window, invalidating renderWindow_
+            this->ogreRoot_->saveConfig();
+            Core::getInstance().updateOgreConfigTimestamp();
+        }
+        return validate;
+    }
+    std::string GraphicsManager::setVSync(bool vsync)
+    {
+        this->ogreRoot_->getRenderSystem()->setConfigOption("VSync", vsync ? "Yes" : "No");
+        std::string validate = this->ogreRoot_->getRenderSystem()->validateConfigOptions();
+        if (validate == "")
+        {
+            //this->ogreRoot_->getRenderSystem()->reinitialise(); // can't use this that easily, because it recreates the render window, invalidating renderWindow_
+            this->ogreRoot_->saveConfig();
+            Core::getInstance().updateOgreConfigTimestamp();
+        }
+        return validate;
+    }

code/trunk/src/libraries/core/GraphicsManager.h

-                      r7401
+                      r8079
 #include "OrxonoxClass.h"
+// tolua_begin
 namespace orxonox
+{
 …
         Graphics engine manager class
     */
+    class _CoreExport GraphicsManager : public Singleton<GraphicsManager>, public OrxonoxClass, public Ogre::LogListener
+    {
+    class _CoreExport GraphicsManager
+// tolua_end
+        : public Singleton<GraphicsManager>, public OrxonoxClass, public Ogre::LogListener
+    { // tolua_export
         friend class Singleton<GraphicsManager>;
     public:
 …
         Ogre::RenderWindow* getRenderWindow() { return this->renderWindow_; }
         size_t getRenderWindowHandle();
+// tolua_begin
+        static GraphicsManager& getInstance() { return Singleton<GraphicsManager>::getInstance(); } // tolua_export
         bool isFullScreen() const;
+        unsigned int getWindowWidth() const;
+        unsigned int getWindowHeight() const;
+        bool hasVSyncEnabled() const;
+        std::string getFSAAMode() const;
+// tolua_end
         void upgradeToGraphics();
 …
         // console commands
         void printScreen();
+        std::string setScreenResolution(unsigned int width, unsigned int height, bool fullscreen);
+        std::string setFSAA(const std::string& mode);
+        std::string setVSync(bool vsync);
         scoped_ptr<OgreWindowEventListener> ogreWindowEventListener_; //!< Pimpl to hide OgreWindowUtilities.h
 …
         Ogre::RenderWindow* renderWindow_;             //!< the one and only render window
         Ogre::Viewport*     viewport_;                 //!< default full size viewport
+        float               lastFrameStartTime_;       //!< Time stamp of the beginning of the last frame
+        float               lastFrameEndTime_;         //!< Time stamp of the end of the last frame
         // XML files for the resources and the debug overlay
 …
         static GraphicsManager* singletonPtr_s;        //!< Pointer to the Singleton
+// tolua_begin
     };
+}
+// tolua_end
 #endif /* _GraphicsManager_H__ */

code/trunk/src/libraries/core/Loader.cc

-                      r7648
+                      r8079
         Returns true if successful.
     */
     bool Loader::load(const XMLFile* file, const ClassTreeMask& mask, bool verbose)
+    bool Loader::load(const XMLFile* file, const ClassTreeMask& mask, bool verbose, bool bRemoveLuaTags)
+    {
         if (!file)
 …
         std::string xmlInput;
         if (file->getLuaSupport())
+        if (file->getLuaSupport() && !bRemoveLuaTags)
+        {
             // Use the LuaState to replace the XML tags (calls our function)
 …
+            }
             xmlInput = Resource::open(file->getFilename())->getAsString();
+            if (bRemoveLuaTags)
+            {
+                // Remove all Lua code.
+                // Note: we only need this to speed up parsing of level files at the
+                // start of the program.
+                // Assumption: the LevelInfo tag does not use Lua scripting
+                xmlInput = removeLuaTags(xmlInput);
+            }
+        }
 …
+    }
+    std::string Loader::replaceLuaTags(const std::string& text)
+    {
+        // create map with all Lua tags
+        std::map<size_t, bool> luaTags;
+    bool Loader::getLuaTags(const std::string& text, std::map<size_t, bool>& luaTags)
+    {
+        // fill map with all Lua tags
+        {
             size_t pos = 0;
 …
+            {
                 COUT(2) << "Warning: Error in level file" << std::endl;
+                // todo: errorhandling
+                return "";
+            }
+        }
+                // TODO: error handling
+                return false;
+            }
+        }
+        return true;
+    }
+    std::string Loader::replaceLuaTags(const std::string& text)
+    {
+        // create a map with all lua tags
+        std::map<size_t, bool> luaTags;
+        if (!getLuaTags(text, luaTags))
+            return "";
         // Use a stringstream object to speed up the parsing
 …
         return output.str();
+    }
+    std::string Loader::removeLuaTags(const std::string& text)
+    {
+        // create a map with all lua tags
+        std::map<size_t, bool> luaTags;
+        if (!getLuaTags(text, luaTags))
+            return "";
+        // Use a stringstream object to speed up the concatenation
+        std::ostringstream output;
+        // cut the original string into pieces and only write the non Lua parts
+        std::map<size_t, bool>::iterator it = luaTags.begin();
+        bool bLuaCode = false;
+        size_t start = 0;
+        size_t end = 0;
+        do
+        {
+            if (it != luaTags.end())
+                end = (it++)->first;
+            else
+                end = std::string::npos;
+            if (!bLuaCode)
+            {
+                output << text.substr(start, end - start);
+                start = end + 5;
+            }
+            else
+                start = end + 2;
+            bLuaCode = !bLuaCode;
+        }
+        while (end != std::string::npos);
+        return output.str();
+    }
+}

code/trunk/src/libraries/core/Loader.h

-                      r7648
+                      r8079
 #include "CorePrereqs.h"
+#include <map>
 #include <vector>
 #include "ClassTreeMask.h"
 …
             static bool reload(const ClassTreeMask& mask = ClassTreeMask(), bool verbose = true);
+            static bool load(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool verbose = true);
+            static bool load(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(),
+                             bool verbose = true, bool bRemoveLuaTags = false);
             static void unload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
             static bool reload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool verbose = true);
             static std::string replaceLuaTags(const std::string& text);
+            static std::string removeLuaTags(const std::string& text);
             static ClassTreeMask currentMask_s;
         private:
+            static bool getLuaTags(const std::string& text, std::map<size_t, bool>& luaTags);
             static std::vector<std::pair<const XMLFile*, ClassTreeMask> > files_s;
     };

code/trunk/src/libraries/core/OrxonoxClass.h

r7850	r8079
194	194
195	195	protected:
	196	virtual ~DestructionListener() {}
	197
196	198	inline void registerAsDestructionListener(OrxonoxClass* object)
197	199	{ if (object) { object->registerDestructionListener(this); } }

code/trunk/src/libraries/core/WeakPtr.h

r7850	r8079
129	129
130	130	/// Destructor
131		inline ~WeakPtr()
	131	inline virtual ~WeakPtr()
132	132	{
133	133	this->unregisterAsDestructionListener(this->base_);

code/trunk/src/libraries/core/command/CommandEvaluation.h

-                      r7401
+                      r8079
         @remarks execCommand_ and hintCommand_ can be different in this case: There are multiple
         commands avaliable, let's say "tcl", "tclexecute", and "tclquery". The user enters
         "tcl", which is already a valid command. Now execCommand_ points to the "tcl"-command,
         but hintCommand_ still points to the autocompletion command of CommandExecutor, because
         the auto-completion list must still return the three possible commands, "tcl tclexecute tclquery"
         because the user may want to execute "tclquery" and needs auto-completion.
+        commands avaliable, let's say "tcl" and "TclThreadManager". The user enters "tcl", which
+        is already a valid command. Now execCommand_ points to the "tcl"-command, but hintCommand_
+        still points to the autocompletion command of CommandExecutor, because the auto-completion
+        list must still return the two possible commands, "tcl TclThreadManager" because the user
+        may want to write "TclThreadManager ..." and needs auto-completion.
         @see See @ref CommandExecutorExample "this description" for an example.

code/trunk/src/libraries/core/command/ConsoleCommand.h

-                      r7861
+                      r8079
         inline void void__void(void) {}
         inline void void__string(const std::string&) {}
+        inline std::string string__bool(bool) { return ""; }
+        inline std::string string__string(const std::string&) { return ""; }
+        inline std::string string__uint_uint_bool(unsigned int, unsigned int, bool) { return ""; }
+    }

code/trunk/src/libraries/core/command/ConsoleCommandCompilation.cc

-                      r7401
+                      r8079
 namespace orxonox
+{
+    SetConsoleCommand("source", source).argumentCompleter(0, autocompletion::files());
+//    SetConsoleCommand("source", source).argumentCompleter(0, autocompletion::files());  // disabled because we use the implementation in Tcl
     SetConsoleCommand("echo", echo);
+    SetConsoleCommand("puts", puts);
+    SetConsoleCommand("read", read).argumentCompleter(0, autocompletion::files());
+    SetConsoleCommand("append", append).argumentCompleter(0, autocompletion::files());
+    SetConsoleCommand("write", write).argumentCompleter(0, autocompletion::files());
+//    SetConsoleCommand("puts", puts);                                                    // disabled because we use the implementation in Tcl
+//    SetConsoleCommand("read", read).argumentCompleter(0, autocompletion::files());      // disabled because we use the implementation in Tcl
+//    SetConsoleCommand("append", append).argumentCompleter(0, autocompletion::files());  // disabled because we use the implementation in Tcl
+//    SetConsoleCommand("write", write).argumentCompleter(0, autocompletion::files());    // disabled because we use the implementation in Tcl
     SetConsoleCommand("calculate", calculate);

code/trunk/src/libraries/core/command/Shell.cc

-                      r7401
+                      r8079
+{
     SetConsoleCommand("log",     OutputHandler::log    );
     SetConsoleCommand("error",   OutputHandler::error  );
     SetConsoleCommand("warning", OutputHandler::warning);
     SetConsoleCommand("info",    OutputHandler::info   );
     SetConsoleCommand("debug",   OutputHandler::debug  );
+    SetConsoleCommand("error",   OutputHandler::error  ).hide();
+    SetConsoleCommand("warning", OutputHandler::warning).hide();
+    SetConsoleCommand("info",    OutputHandler::info   ).hide();
+    SetConsoleCommand("debug",   OutputHandler::debug  ).hide();
     unsigned int Shell::cacheSize_s;

code/trunk/src/libraries/core/command/TclBind.cc

-                      r7401
+                      r8079
+{
     SetConsoleCommand("tcl", &TclBind::tcl);
     SetConsoleCommand("bgerror", &TclBind::bgerror);
+    SetConsoleCommand("bgerror", &TclBind::bgerror).hide();
     TclBind* TclBind::singletonPtr_s = 0;
 …
             this->interpreter_->def("::orxonox::query", TclBind::tcl_query, Tcl::variadic());
+            this->interpreter_->def("::orxonox::execute", TclBind::tcl_execute, Tcl::variadic());
             this->interpreter_->def("::orxonox::crossquery", TclThreadManager::tcl_crossquery, Tcl::variadic());
-            this->interpreter_->def("execute", TclBind::tcl_execute, Tcl::variadic());
             this->interpreter_->def("::orxonox::crossexecute", TclThreadManager::tcl_crossexecute, Tcl::variadic());
             try
+            {
+                this->interpreter_->eval("proc query        {args}    { ::orxonox::query $args }");
+                this->interpreter_->def("query", TclBind::tcl_query, Tcl::variadic());
+                this->interpreter_->def("execute", TclBind::tcl_execute, Tcl::variadic());
                 this->interpreter_->eval("proc crossquery   {id args} { ::orxonox::crossquery 0 $id $args }");
                 this->interpreter_->eval("proc crossexecute {id args} { ::orxonox::crossquery 0 $id $args }");
+                this->interpreter_->eval("proc crossexecute {id args} { ::orxonox::crossexecute 0 $id $args }");
                 this->interpreter_->eval("proc running      {}        { return 1 }");
                 this->interpreter_->eval("set id 0");
 …
+    {
         COUT(4) << "Tcl_query: " << args.get() << std::endl;
+        return TclBind::tcl_helper(args, true);
+    }
+    /**
+        @brief Callback: Used to send an Orxonox-command from Tcl to the CommandExecutor.
+    */
+    void TclBind::tcl_execute(Tcl::object const &args)
+    {
+        COUT(4) << "Tcl_execute: " << args.get() << std::endl;
+        TclBind::tcl_helper(args, false);
+    }
+    /**
+        @brief Helper function, used by tcl_query() and tcl_execute().
+    */
+    std::string TclBind::tcl_helper(Tcl::object const &args, bool bQuery)
+    {
         const std::string& command = stripEnclosingBraces(args.get());
         int error;
+        std::string result;
         CommandEvaluation evaluation = CommandExecutor::evaluate(command);
+        const std::string& result = evaluation.query(&error);
+        if (bQuery)
+            result = evaluation.query(&error).getString();
+        else
+            error = evaluation.execute();
         switch (error)
+        {
 …
     /**
-        @brief Callback: Used to send an Orxonox-command from Tcl to the CommandExecutor.
-    */
-    void TclBind::tcl_execute(Tcl::object const &args)
+    {
-        COUT(4) << "Tcl_execute: " << args.get() << std::endl;
-        const std::string& command = stripEnclosingBraces(args.get());
-        if (CommandExecutor::execute(command, false))
+        {
-            COUT(1) << "Error: Can't execute command \"" << command << "\"!" << std::endl;
+        }
+    }
-    /**
         @brief Console command, executes Tcl code. Can be used to bind Tcl-commands to a key, because native
         Tcl-commands can not be evaluated and are thus not supported by the key-binder.
 …
             try
+            {
+                const std::string& output = TclBind::getInstance().interpreter_->eval("uplevel #0 " + tclcode);
+                if (!output.empty())
+                {
+                    COUT(0) << "tcl> " << output << std::endl;
+                }
+                return output;
+                return TclBind::getInstance().interpreter_->eval("uplevel #0 " + tclcode);
+            }
             catch (Tcl::tcl_error const &e)
             {   COUT(1) << "tcl> Error: " << e.what() << std::endl;   }
+            {   COUT(1) << "Tcl error: " << e.what() << std::endl;   }
+        }

code/trunk/src/libraries/core/command/TclBind.h

r7401	r8079
126	126	TclBind(const TclBind& other); ///< Copy-constructor, not implemented
127	127
	128	static std::string tcl_helper(Tcl::object const &args, bool bQuery);
	129
128	130	Tcl::interpreter* interpreter_; ///< The wrapped Tcl interpreter
129	131	std::string tclDataPath_; ///< The path to the directory that contains the Orxonox-specific Tcl-files

code/trunk/src/libraries/core/command/TclThreadManager.cc

r7401	r8079
55	55	const float TCLTHREADMANAGER_MAX_CPU_USAGE = 0.50f;
56	56
57		~~SetConsoleCommand("tclexecute", &TclThreadManager::execute).argumentCompleter(0, autocompletion::tclthreads());~~
58		~~SetConsoleCommand("tclquery", &TclThreadManager::query ).argumentCompleter(0, autocompletion::tclthreads());~~
59	57	SetConsoleCommand("TclThreadManager", "create", &TclThreadManager::create);
60	58	SetConsoleCommand("TclThreadManager", "destroy", &TclThreadManager::destroy).argumentCompleter(0, autocompletion::tclthreads());

code/trunk/src/libraries/core/input/InputManager.cc

-                      r7874
+                      r8079
         state->destroy();
+    }
+    bool InputManager::setMouseExclusive(const std::string& name, TriBool::Value value)
+    {
+        if (name == "empty")
+        {
+            COUT(2) << "InputManager: Changing the empty state is not allowed!" << std::endl;
+            return false;
+        }
+        std::map<std::string, InputState*>::iterator it = statesByName_.find(name);
+        if (it != statesByName_.end())
+        {
+            it->second->setMouseExclusive(value);
+            return true;
+        }
+        return false;
+    }
+}

code/trunk/src/libraries/core/input/InputManager.h

-                      r7874
+                      r8079
         */
         bool destroyState(const std::string& name); // tolua_export
+        /**
+        @brief
+            Changes the mouse mode of an input state.
+        @return
+            True if the call was successful, fals if the name was not found
+        */
+        bool setMouseExclusive(const std::string& name, TriBool::Value value); // tolua_export
         //-------------------------------

code/trunk/src/libraries/core/input/KeyBinder.cc

-                      r7958
+                      r8079
                         // decrease counter
                         button->nCommands_[mode_index]--;
+                        // note: we don't replace the old array - it's not one element too large, but no one cares since nCommands_ defines the size
+                        // old array would not get deleted if nCommands_ is now 0
+                        // otherwise: nobody cares about an array that is one element too large - nCommands_ defines the size
+                        if (button->nCommands_[mode_index] == 0)
+                        {
+                            delete[] button->commands_[mode_index];
+                            button->commands_[mode_index] = 0;
+                        }
                         // decrement the index since we shifted the array and continue searching for more occurrences of the command

code/trunk/src/libraries/core/input/Keyboard.cc

-                      r6422
+                      r8079
+    {
         // update modifiers
+        if (arg.key == OIS::KC_RMENU    || arg.key == OIS::KC_LMENU)
+            modifiers_ |= KeyboardModifier::Alt;   // alt key
+        if (arg.key == OIS::KC_RCONTROL || arg.key == OIS::KC_LCONTROL)
+            modifiers_ |= KeyboardModifier::Ctrl;  // ctrl key
+        if (arg.key == OIS::KC_RSHIFT   || arg.key == OIS::KC_LSHIFT)
+            modifiers_ |= KeyboardModifier::Shift; // shift key
+        switch (arg.key)
+        {
+            case OIS::KC_RMENU:
+            case OIS::KC_LMENU:
+                modifiers_ |= KeyboardModifier::Alt;   // alt key
+                break;
+            case OIS::KC_RCONTROL:
+            case OIS::KC_LCONTROL:
+                modifiers_ |= KeyboardModifier::Ctrl;  // ctrl key
+                break;
+            case OIS::KC_RSHIFT:
+            case OIS::KC_LSHIFT:
+                modifiers_ |= KeyboardModifier::Shift; // shift key
+                break;
+            case OIS::KC_TAB:
+                // Do not distribute the alt+tab event (messes with the operating system)
+                if ((modifiers_ & KeyboardModifier::Alt) != 0)
+                    return true;
+            default:;
+        }
+        // Do not distribute the alt+tab event (messes with the operating system)
+        if ((modifiers_ & KeyboardModifier::Alt) != 0 && arg.key == OIS::KC_TAB)
+            return true;
+        KeyEvent evt(arg);
+        KeyEvent evt(static_cast<KeyCode::ByEnum>(arg.key), Keyboard::getKeyText(arg), 0);
         super::buttonPressed(evt);
         return true;
 …
+    {
         // update modifiers
+        if (arg.key == OIS::KC_RMENU    || arg.key == OIS::KC_LMENU)
+            modifiers_ &= ~KeyboardModifier::Alt;   // alt key
+        if (arg.key == OIS::KC_RCONTROL || arg.key == OIS::KC_LCONTROL)
+            modifiers_ &= ~KeyboardModifier::Ctrl;  // ctrl key
+        if (arg.key == OIS::KC_RSHIFT   || arg.key == OIS::KC_LSHIFT)
+            modifiers_ &= ~KeyboardModifier::Shift; // shift key
+        switch (arg.key)
+        {
+            case OIS::KC_RMENU:
+            case OIS::KC_LMENU:
+                modifiers_ &= ~KeyboardModifier::Alt;   // alt key
+                break;
+            case OIS::KC_RCONTROL:
+            case OIS::KC_LCONTROL:
+                modifiers_ &= ~KeyboardModifier::Ctrl;  // ctrl key
+                break;
+            case OIS::KC_RSHIFT:
+            case OIS::KC_LSHIFT:
+                modifiers_ &= ~KeyboardModifier::Shift; // shift key
+                break;
+            default:;
+        }
         KeyEvent evt(arg);
+        KeyEvent evt(static_cast<KeyCode::ByEnum>(arg.key), Keyboard::getKeyText(arg), 0);
         super::buttonReleased(evt);
         return true;
+    }
+    /// A map which returns the corresponding chars for some key codes
+    unsigned int Keyboard::getKeyText(const OIS::KeyEvent& arg)
+    {
+        switch (arg.key)
+        {
+            case OIS::KC_NUMPAD0:     return static_cast<unsigned int>('0');
+            case OIS::KC_NUMPAD1:     return static_cast<unsigned int>('1');
+            case OIS::KC_NUMPAD2:     return static_cast<unsigned int>('2');
+            case OIS::KC_NUMPAD3:     return static_cast<unsigned int>('3');
+            case OIS::KC_NUMPAD4:     return static_cast<unsigned int>('4');
+            case OIS::KC_NUMPAD5:     return static_cast<unsigned int>('5');
+            case OIS::KC_NUMPAD6:     return static_cast<unsigned int>('6');
+            case OIS::KC_NUMPAD7:     return static_cast<unsigned int>('7');
+            case OIS::KC_NUMPAD8:     return static_cast<unsigned int>('8');
+            case OIS::KC_NUMPAD9:     return static_cast<unsigned int>('9');
+            case OIS::KC_DECIMAL:     return static_cast<unsigned int>('.');
+            case OIS::KC_DIVIDE:      return static_cast<unsigned int>('/');
+            case OIS::KC_NUMPADENTER: return static_cast<unsigned int>('\n');
+            default:                  return arg.text;
+        }
+    }
+}

code/trunk/src/libraries/core/input/Keyboard.h

r7809	r8079
83	83	static std::string getClassNameImpl() { return "Keyboard"; }
84	84
	85	static unsigned int getKeyText(const OIS::KeyEvent& arg);
	86
85	87	//! Bit mask representing keyboard modifiers
86	88	int modifiers_;

code/trunk/src/libraries/network/Host.cc

-                      r7801
+                      r8079
 namespace orxonox {
+  static const std::string __CC_printRTT_group = "Stats";
   static const std::string __CC_printRTT_name = "printRTT";
   SetConsoleCommand("chat", &Host::Chat);
   SetConsoleCommand(__CC_printRTT_name, &Host::printRTT);
+  SetConsoleCommand(__CC_printRTT_group, __CC_printRTT_name, &Host::printRTT);
   // Host*               Host::instance_=0;
 …
   //   assert(instance_==0);
     instances_s.push_back(this);
     ModifyConsoleCommand(__CC_printRTT_name).setObject(this);
+    ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(this);
     this->bIsActive_ = false;
+  }
 …
     assert( std::find( instances_s.begin(), instances_s.end(), this )!=instances_s.end() );
     instances_s.erase(std::find( instances_s.begin(), instances_s.end(), this ));
     ModifyConsoleCommand(__CC_printRTT_name).setObject(0);
+    ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(0);
+  }

code/trunk/src/libraries/tools/ResourceLocation.cc

r7709	r8079
30	30
31	31	#include <OgreResourceGroupManager.h>
	32	#include <OgreException.h>
32	33	#include <boost/filesystem.hpp>
33	34

code/trunk/src/libraries/tools/Shader.cc

-                      r6417
+                      r8079
 #include <OgreCompositorManager.h>
-#include <OgreCompositorInstance.h>
-#include <OgreSceneManager.h>
 #include <OgreRoot.h>
 #include <OgrePlugin.h>
-#include <OgreMaterial.h>
-#include <OgreTechnique.h>
-#include <OgrePass.h>
-#include <OgreMaterialManager.h>
 #include "core/CoreIncludes.h"
 …
 namespace orxonox
+{
     bool Shader::bLoadedCgPlugin_s = false;
     Shader::MaterialMap Shader::parameters_s;
+    /**
+        @brief Initializes the values and sets the scene manager.
+    */
     Shader::Shader(Ogre::SceneManager* scenemanager) : compositorInstance_(0)
+    {
 …
         this->scenemanager_ = scenemanager;
-        this->compositorInstance_ = 0;
         this->bVisible_ = true;
         this->bLoadCompositor_ = GameMode::showsGraphics();
+        this->bViewportInitialized_ = false;
+        if (this->bLoadCompositor_ && Ogre::Root::getSingletonPtr())
+        {
+            Shader::bLoadedCgPlugin_s = false;
+        this->registeredAsListener_ = false;
+        static bool hasCgProgramManager = Shader::hasCgProgramManager();
+        this->bLoadCompositor_ &= hasCgProgramManager;
+    }
+    /**
+        @brief Removes the compositor and frees the resources.
+    */
+    Shader::~Shader()
+    {
+        if (this->compositorInstance_ && GraphicsManager::getInstance().getViewport())
+            Ogre::CompositorManager::getSingleton().removeCompositor(GraphicsManager::getInstance().getViewport(), this->compositorName_);
+    }
+    /**
+        @brief Inherited from ViewportEventListener - called if the camera changes.
+        Since the new camera could be in a different scene, the shader has to make sure
+        it deactivates or activates itself accordingly.
+        Additionally the shader has to be turned off and on even if the camera stays in
+        the same scene to fix a weird behavior of Ogre.
+    */
+    void Shader::cameraChanged(Ogre::Viewport* viewport, Ogre::Camera* oldCamera)
+    {
+        if (!this->bLoadCompositor_ || !this->scenemanager_)
+            return;
+        // load the compositor if not already done
+        if (!this->compositorName_.empty() && !this->compositorInstance_)
+            this->changedCompositorName(viewport);
+        // update compositor in viewport (shader should only be active if the current camera is in the same scene as the shader)
+        // Note:
+        // The shader needs also to be switched off and on after changing the camera in the
+        // same scene to avoid weird behaviour with active compositors while switching the
+        // camera (like freezing the image)
+        //
+        // Last known Ogre version needing this workaround:
+        // 1.4.8
+        // 1.7.2
+        if (oldCamera && this->scenemanager_ == oldCamera->getSceneManager())
+            Ogre::CompositorManager::getSingleton().setCompositorEnabled(viewport, this->compositorName_, false);
+        if (viewport->getCamera() && this->scenemanager_ == viewport->getCamera()->getSceneManager())
+            Ogre::CompositorManager::getSingleton().setCompositorEnabled(viewport, this->compositorName_, this->isVisible());
+    }
+    /**
+        @brief Changes the compositor - default viewport.
+    */
+    void Shader::changedCompositorName()
+    {
+        // For the moment, we get the viewport always from the graphics manager
+        // TODO: Try to support multiple viewports - note however that scenemanager_->getCurrentViewport() returns NULL
+        //       after switching to a camera in a different scene (only for the first time this scene is displayed though)
+        this->changedCompositorName(GraphicsManager::getInstance().getViewport());
+    }
+    /**
+        @brief Changes the compositor.
+    */
+    void Shader::changedCompositorName(Ogre::Viewport* viewport)
+    {
+        if (this->bLoadCompositor_)
+        {
+            assert(viewport);
+            if (this->compositorInstance_)
+            {
+                // remove the old compositor, remove the listener
+                Ogre::CompositorManager::getSingleton().removeCompositor(viewport, this->oldcompositorName_);
+                this->compositorInstance_->removeListener(this);
+                this->compositorInstance_ = 0;
+            }
+            if (!this->compositorName_.empty())
+            {
+                // add the new compositor
+                this->compositorInstance_ = Ogre::CompositorManager::getSingleton().addCompositor(viewport, this->compositorName_);
+                if (this->compositorInstance_)
+                {
+                    // register as listener if required
+                    if (this->registeredAsListener_)
+                        this->compositorInstance_->addListener(this);
+                    // set visibility according to the isVisible() and the camera/viewport
+                    if (viewport->getCamera())
+                        Ogre::CompositorManager::getSingleton().setCompositorEnabled(viewport, this->compositorName_, this->isVisible() && viewport->getCamera() && this->scenemanager_ == viewport->getCamera()->getSceneManager());
+                }
+                else
+                    COUT(2) << "Warning: Couldn't load compositor with name \"" << this->compositorName_ << "\"." << std::endl;
+            }
+            this->oldcompositorName_ = this->compositorName_;
+        }
+    }
+    /**
+        @brief Changes the visibility of the shader. Doesn't free any resources if set to invisible.
+    */
+    void Shader::updateVisibility()
+    {
+        if (this->compositorInstance_)
+            Ogre::CompositorManager::getSingleton().setCompositorEnabled(GraphicsManager::getInstance().getViewport(), this->compositorName_, this->isVisible());
+    }
+    /**
+        @brief Defines a new integer value for a given parameter. The parameter will be updated if the compositor is rendered the next time.
+    */
+    void Shader::setParameter(size_t technique, size_t pass, const std::string& parameter, int value)
+    {
+        ParameterContainer container = {technique, pass, parameter, value, 0.0f, MT_Type::Int};
+        this->parameters_.push_back(container);
+        this->addAsListener();
+    }
+    /**
+        @brief Defines a new float value for a given parameter. The parameter will be updated if the compositor is rendered the next time.
+    */
+    void Shader::setParameter(size_t technique, size_t pass, const std::string& parameter, float value)
+    {
+        ParameterContainer container = {technique, pass, parameter, 0, value, MT_Type::Float};
+        this->parameters_.push_back(container);
+        this->addAsListener();
+    }
+    /**
+        @brief Registers the shader as CompositorInstance::Listener at the compositor. Used to change parameters.
+    */
+    void Shader::addAsListener()
+    {
+        if (!this->registeredAsListener_)
+        {
+            this->registeredAsListener_ = true;
+            if (this->compositorInstance_)
+                this->compositorInstance_->addListener(this);
+        }
+    }
+    /**
+        @brief Inherited by Ogre::CompositorInstance::Listener, called whenever the material is rendered. Used to change parameters.
+    */
+    void Shader::notifyMaterialRender(Ogre::uint32 pass_id, Ogre::MaterialPtr& materialPtr)
+    {
+        // iterate through the list of parameters
+        for (std::list<ParameterContainer>::iterator it = this->parameters_.begin(); it != this->parameters_.end(); ++it)
+        {
+            Ogre::Technique* techniquePtr = materialPtr->getTechnique(it->technique_);
+            if (techniquePtr)
+            {
+                Ogre::Pass* passPtr = techniquePtr->getPass(it->pass_);
+                if (passPtr)
+                {
+                    // change the value of the parameter depending on its type
+                    switch (it->valueType_)
+                    {
+                        case MT_Type::Int:
+                            passPtr->getFragmentProgramParameters()->setNamedConstant(it->parameter_, it->valueInt_);
+                            break;
+                        case MT_Type::Float:
+                            passPtr->getFragmentProgramParameters()->setNamedConstant(it->parameter_, it->valueFloat_);
+                            break;
+                        default:
+                            break;
+                    }
+                }
+                else
+                    COUT(2) << "Warning: No pass " << it->pass_ << " in technique " << it->technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << std::endl;
+            }
+            else
+                COUT(2) << "Warning: No technique " << it->technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << std::endl;
+        }
+        this->parameters_.clear();
+    }
+    /**
+        @brief Detects if the Cg program manager plugin is active.
+    */
+    /* static */ bool Shader::hasCgProgramManager()
+    {
+        if (Ogre::Root::getSingletonPtr())
+        {
             const Ogre::Root::PluginInstanceList& plugins = Ogre::Root::getSingleton().getInstalledPlugins();
             for (size_t i = 0; i < plugins.size(); ++i)
+            {
                 if (plugins[i]->getName() == "Cg Program Manager")
+                {
-                    Shader::bLoadedCgPlugin_s = true;
-                    break;
+                }
+            }
+        }
-        this->bLoadCompositor_ &= Shader::bLoadedCgPlugin_s;
+    }
-    Shader::~Shader()
+    {
-        if (this->compositorInstance_ && this->bLoadCompositor_)
+        {
-            Ogre::Viewport* viewport = GraphicsManager::getInstance().getViewport();
-            assert(viewport);
-            Ogre::CompositorManager::getSingleton().removeCompositor(viewport, this->compositor_);
+        }
+    }
-    void Shader::setSceneManager(Ogre::SceneManager* scenemanager)
+    {
-        this->scenemanager_ = scenemanager;
-        this->bViewportInitialized_ = false;
+    }
-    void Shader::tick(float dt)
+    {
-        SUPER(Shader, tick, dt);
-        if (this->bLoadCompositor_ && !this->bViewportInitialized_ && this->scenemanager_ && this->scenemanager_->getCurrentViewport())
+        {
-            this->bViewportInitialized_ = true;
-            this->updateVisibility();
+        }
+    }
-    void Shader::changedCompositor()
+    {
-        if (this->bLoadCompositor_)
+        {
-            Ogre::Viewport* viewport = GraphicsManager::getInstance().getViewport();
-            assert(viewport);
-            if (!this->oldcompositor_.empty())
+            {
-                Ogre::CompositorManager::getSingleton().removeCompositor(viewport, this->oldcompositor_);
-                this->compositorInstance_ = 0;
+            }
-            if (!this->compositor_.empty())
+            {
-                this->compositorInstance_ = Ogre::CompositorManager::getSingleton().addCompositor(viewport, this->compositor_);
-                if (!this->compositorInstance_)
-                    COUT(2) << "Warning: Couldn't load compositor with name \"" << this->compositor_ << "\"." << std::endl;
-                Ogre::CompositorManager::getSingleton().setCompositorEnabled(viewport, this->compositor_, this->bViewportInitialized_ && this->isVisible());
+            }
-            this->oldcompositor_ = this->compositor_;
+        }
+    }
-    void Shader::updateVisibility()
+    {
-        if (this->compositorInstance_ && this->scenemanager_)
-            this->compositorInstance_->setEnabled(this->scenemanager_->getCurrentViewport() && this->isVisible());
+    }
-    void Shader::setParameter(const std::string& material, size_t technique, size_t pass, const std::string& parameter, float value)
+    {
-        if (Shader::_setParameter(material, technique, pass, parameter, value))
+        {
-            if (this->bViewportInitialized_ && this->compositorInstance_ && this->isVisible())
+            {
-                this->compositorInstance_->setEnabled(false);
-                this->compositorInstance_->setEnabled(true);
+            }
+        }
+    }
-    void Shader::setParameter(const std::string& material, size_t technique, size_t pass, const std::string& parameter, int value)
+    {
-        if (Shader::_setParameter(material, technique, pass, parameter, value))
+        {
-            if (this->bViewportInitialized_ && this->compositorInstance_ && this->isVisible())
+            {
-                this->compositorInstance_->setEnabled(false);
-                this->compositorInstance_->setEnabled(true);
+            }
+        }
+    }
-    bool Shader::_setParameter(const std::string& material, size_t technique, size_t pass, const std::string& parameter, float value)
+    {
-        ParameterPointer* pointer = Shader::getParameterPointer(material, technique, pass, parameter);
-        if (pointer)
+        {
-            if (pointer->first)
+            {
-                if ((*static_cast<float*>(pointer->second)) != value)
+                {
-                    (*static_cast<float*>(pointer->second)) = value;
                     return true;
+                }
+            }
-            else
+            {
-                if ((*static_cast<int*>(pointer->second)) != static_cast<int>(value))
+                {
-                    (*static_cast<int*>(pointer->second)) = static_cast<int>(value);
-                    return true;
+                }
+            }
+        }
         return false;
+    }
-    bool Shader::_setParameter(const std::string& material, size_t technique, size_t pass, const std::string& parameter, int value)
+    {
-        ParameterPointer* pointer = Shader::getParameterPointer(material, technique, pass, parameter);
-        if (pointer)
+        {
-            if (pointer->first)
+            {
-                if ((*static_cast<float*>(pointer->second)) != static_cast<float>(value))
+                {
-                    (*static_cast<float*>(pointer->second)) = static_cast<float>(value);
-                    return true;
+                }
+            }
-            else
+            {
-                if ((*static_cast<int*>(pointer->second)) != value)
+                {
-                    (*static_cast<int*>(pointer->second)) = value;
-                    return true;
+                }
+            }
+        }
-        return false;
+    }
-    float Shader::getParameter(const std::string& material, size_t technique, size_t pass, const std::string& parameter)
+    {
-        ParameterPointer* pointer = Shader::getParameterPointer(material, technique, pass, parameter);
-        if (pointer)
+        {
-            if (pointer->first)
-                return (*static_cast<float*>(pointer->second));
-            else
-                return static_cast<float>(*static_cast<int*>(pointer->second));
+        }
-        else
-            return 0;
+    }
-    bool Shader::getParameterIsFloat(const std::string& material, size_t technique, size_t pass, const std::string& parameter)
+    {
-        ParameterPointer* pointer = Shader::getParameterPointer(material, technique, pass, parameter);
-        if (pointer)
-            return pointer->first;
-        else
-            return false;
+    }
-    bool Shader::getParameterIsInt(const std::string& material, size_t technique, size_t pass, const std::string& parameter)
+    {
-        ParameterPointer* pointer = Shader::getParameterPointer(material, technique, pass, parameter);
-        if (pointer)
-            return (!pointer->first);
-        else
-            return false;
+    }
-    Shader::ParameterPointer* Shader::getParameterPointer(const std::string& material, size_t technique, size_t pass, const std::string& parameter)
+    {
-        if (!GameMode::showsGraphics() || !Shader::bLoadedCgPlugin_s)
-            return 0;
-        MaterialMap::iterator material_iterator = Shader::parameters_s.find(material);
-        if (material_iterator != Shader::parameters_s.end())
+        {
-            TechniqueVector& technique_vector = material_iterator->second;
-            if (technique < technique_vector.size())
+            {
-                PassVector& pass_vector = technique_vector[technique];
-                if (pass < pass_vector.size())
+                {
-                    ParameterMap& parameter_map = pass_vector[pass];
-                    ParameterMap::iterator parameter_iterator = parameter_map.find(parameter);
-                    if (parameter_iterator != parameter_map.end())
-                        return (&parameter_iterator->second);
-                    else
-                        COUT(2) << "Warning: No shader parameter \"" << parameter << "\" in pass " << pass << " in technique " << technique << " in material \"" << material << "\"." << std::endl;
+                }
-                else
-                    COUT(2) << "Warning: No pass " << pass << " in technique " << technique << " in material \"" << material << "\" or pass has no shader." << std::endl;
+            }
-            else
-                COUT(2) << "Warning: No technique " << technique << " in material \"" << material << "\" or technique has no pass with shader." << std::endl;
+        }
-        else
+        {
-            bool foundAtLeastOneShaderParameter = false;
-            Ogre::MaterialManager::ResourceMapIterator iterator = Ogre::MaterialManager::getSingleton().getResourceIterator();
-            Ogre::Material* material_pointer = 0;
-            while (iterator.hasMoreElements())
+            {
-                Ogre::Resource* resource = iterator.getNext().get();
-                if (resource->getName() == material)
-                    material_pointer = (Ogre::Material*)resource;
+            }
-            if (!material_pointer)
+            {
-                COUT(2) << "Warning: No material with name \"" << material << "\" found." << std::endl;
-                return 0;
+            }
-            for (unsigned int t = 0; t < material_pointer->getNumTechniques(); ++t)
+            {
-                Ogre::Technique* technique_pointer = material_pointer->getTechnique(t);
-                if (!technique_pointer)
-                    continue;
-                for (unsigned int p = 0; p < technique_pointer->getNumPasses(); ++p)
+                {
-                    Ogre::Pass* pass_pointer = technique_pointer->getPass(p);
-                    if (!pass_pointer)
-                        continue;
-                    if (!pass_pointer->getFragmentProgramName().empty())
+                    {
-                        Ogre::GpuProgramParameters* parameter_pointer = pass_pointer->getFragmentProgramParameters().get();
-                        if (!parameter_pointer)
-                            continue;
-                        const Ogre::GpuConstantDefinitionMap& constant_definitions = parameter_pointer->getConstantDefinitions().map;
-                        for (Ogre::GpuConstantDefinitionMap::const_iterator definition_iterator = constant_definitions.begin(); definition_iterator != constant_definitions.end(); ++definition_iterator)
+                        {
-                            void* temp = (definition_iterator->second.isFloat())
-                                            ? static_cast<void*>(parameter_pointer->getFloatPointer(definition_iterator->second.physicalIndex))
-                                            : static_cast<void*>(parameter_pointer->getIntPointer(definition_iterator->second.physicalIndex));
-                            ParameterPointer parameter_pointer = ParameterPointer(definition_iterator->second.isFloat(), temp);
-                            TechniqueVector& technique_vector = Shader::parameters_s[material];
-                            technique_vector.resize(technique + 1);
-                            PassVector& pass_vector = technique_vector[technique];
-                            pass_vector.resize(pass + 1);
-                            pass_vector[pass][definition_iterator->first] = parameter_pointer;
-                            foundAtLeastOneShaderParameter = true;
+                        }
+                    }
+                }
+            }
-            // recursive call if the material was added to the map
-            if (foundAtLeastOneShaderParameter)
-                return Shader::getParameterPointer(material, technique, pass, parameter);
+        }
-        return 0;
+    }
+}

code/trunk/src/libraries/tools/Shader.h

-                      r5781
+                      r8079
 #include <vector>
+#include <OgreCompositorInstance.h>
+#include "util/MultiType.h"
 #include "util/OgreForwardRefs.h"
 #include "tools/interfaces/Tickable.h"
+#include "core/ViewportEventListener.h"
 namespace orxonox
+{
+    class _ToolsExport Shader : public Tickable
+    /**
+        @brief Shader is a wrapper class around Ogre::CompositorInstance. It provides some
+        functions to easily change the visibility and parameters for shader programs.
+    */
+    class _ToolsExport Shader : public ViewportEventListener, public Ogre::CompositorInstance::Listener
+    {
-        typedef std::pair<bool, void*>                  ParameterPointer;
-        typedef std::map<std::string, ParameterPointer> ParameterMap;
-        typedef std::vector<ParameterMap>               PassVector;
-        typedef std::vector<PassVector>                 TechniqueVector;
-        typedef std::map<std::string, TechniqueVector>  MaterialMap;
         public:
             Shader(Ogre::SceneManager* scenemanager = 0);
             virtual ~Shader();
+            virtual void tick(float dt);
+            /// Defines if the shader is visible or not.
             inline void setVisible(bool bVisible)
+            {
 …
+                }
+            }
+            /// Returns whether or not the shader is visible.
             inline bool isVisible() const
                 { return this->bVisible_; }
             void updateVisibility();
+            inline void setCompositor(const std::string& compositor)
+            /// Defines the compositor's name (located in a .compositor file).
+            inline void setCompositorName(const std::string& name)
+            {
                 if (this->compositor_ != compositor)
+                if (this->compositorName_ != name)
+                {
                     this->compositor_ = compositor;
                     this->changedCompositor();
+                    this->compositorName_ = name;
+                    this->changedCompositorName();
+                }
+            }
+            inline const std::string& getCompositor() const
+                { return this->compositor_; }
+            void changedCompositor();
+            /// Returns the compositor's name.
+            inline const std::string& getCompositorName() const
+                { return this->compositorName_; }
+            void changedCompositorName();
+            void changedCompositorName(Ogre::Viewport* viewport);
+            void setSceneManager(Ogre::SceneManager* scenemanager);
+            /// Sets the scenemanager (usually provided in the constructor, but can be set later). Shouldn't be changed once it's set.
+            inline void setSceneManager(Ogre::SceneManager* scenemanager)
+                { this->scenemanager_ = scenemanager; }
+            /// Returns the scene manager.
             inline Ogre::SceneManager* getSceneManager() const
                 { return this->scenemanager_; }
+            void setParameter(const std::string& material, size_t technique, size_t pass, const std::string& parameter, float value);
+            void setParameter(const std::string& material, size_t technique, size_t pass, const std::string& parameter, int value);
+            virtual void cameraChanged(Ogre::Viewport* viewport, Ogre::Camera* oldCamera);
+            static bool _setParameter(const std::string& material, size_t technique, size_t pass, const std::string& parameter, float value);
+            static bool _setParameter(const std::string& material, size_t technique, size_t pass, const std::string& parameter, int value);
+            static float getParameter(const std::string& material, size_t technique, size_t pass, const std::string& parameter);
+            static bool  getParameterIsFloat(const std::string& material, size_t technique, size_t pass, const std::string& parameter);
+            static bool  getParameterIsInt  (const std::string& material, size_t technique, size_t pass, const std::string& parameter);
+            static ParameterPointer* getParameterPointer(const std::string& material, size_t technique, size_t pass, const std::string& parameter);
+            void setParameter(size_t technique, size_t pass, const std::string& parameter, float value);
+            void setParameter(size_t technique, size_t pass, const std::string& parameter, int value);
+            virtual void notifyMaterialRender(Ogre::uint32 pass_id, Ogre::MaterialPtr& materialPtr);
         private:
+            Ogre::SceneManager* scenemanager_;
+            Ogre::CompositorInstance* compositorInstance_;
+            bool bVisible_;
+            bool bLoadCompositor_;
+            bool bViewportInitialized_;
+            std::string compositor_;
+            std::string oldcompositor_;
+            static bool hasCgProgramManager();
+            static MaterialMap parameters_s;
+            static bool bLoadedCgPlugin_s;
+            Ogre::SceneManager* scenemanager_;              ///< The scenemanager for which the shader is active
+            Ogre::CompositorInstance* compositorInstance_;  ///< The compositor instance representing the wrapped compositor
+            bool bVisible_;                                 ///< True if the shader should be visible
+            bool bLoadCompositor_;                          ///< True if the compositor should be loaded (usually false if no graphics)
+            std::string compositorName_;                    ///< The name of the current compositor
+            std::string oldcompositorName_;                 ///< The name of the previous compositor (used to unregister)
+        private:
+            void addAsListener();
+            /// Helper struct to store parameters for shader programs.
+            struct ParameterContainer
+            {
+                size_t technique_;          ///< The ID of the technique
+                size_t pass_;               ///< The ID of the pass
+                std::string parameter_;     ///< The name of the parameter
+                int valueInt_;              ///< The desired int value of the parameter
+                float valueFloat_;          ///< The desired float value of the parameter
+                MT_Type::Value valueType_;  ///< The type of the parameter (currently only int or float)
+            };
+            std::list<ParameterContainer> parameters_;  ///< The list of parameters that should be set on the next update
+            bool registeredAsListener_;                 ///< True if the shader should register itself as listener at the compositor
     };
+}

code/trunk/src/libraries/tools/Timer.cc

-                      r7401
+                      r8079
 #include <set>
+#include <boost/bimap.hpp>
 #include "util/Clock.h"
 …
 #include "core/command/CommandExecutor.h"
 #include "core/command/Functor.h"
+#include "tools/interfaces/TimeFactorListener.h"
 namespace orxonox
+{
     SetConsoleCommand("delay", &delay).argumentCompleter(1, autocompletion::command());
+    SetConsoleCommand("delayreal", &delayreal).argumentCompleter(1, autocompletion::command());
+    SetConsoleCommand("killdelay", &killdelay);
     SetConsoleCommand("killdelays", &killdelays);
+    static std::set<Timer*> delaytimerset;
+    /**
+        @brief Console-command: Calls another console command after @a delay seconds.
+    static boost::bimap<unsigned int, Timer*> delaytimers;
+    static unsigned int delayHandleCounter = 0;
+    /**
+        @brief Console-command: Calls another console command after @a delay seconds (game time).
         @param delay The delay in seconds
         @param command The console command
+    */
+    void delay(float delay, const std::string& command)
+    {
+        Timer* delaytimer = new Timer();
+        delaytimerset.insert(delaytimer);
+        @return The handle of the delayed command, can be used as argument for killdelay()
+    */
+    unsigned int delay(float delay, const std::string& command)
+    {
+        return addDelayedCommand(new Timer(), delay, command);
+    }
+    /**
+        @brief Console-command: Calls another console command after @a delay seconds (real time)
+        @param delay The delay in seconds
+        @param command The console command
+        @return The handle of the delayed command, can be used as argument for killdelay()
+    */
+    unsigned int delayreal(float delay, const std::string& command)
+    {
+        return addDelayedCommand(new RealTimer(), delay, command);
+    }
+    /**
+        @brief Helper function, used by delay() and delayreal() to add a delayed command.
+        @param timer The timer which will execute the command
+        @param delay The delay in seconds
+        @param command The console command
+        @return The handle of the delayed command, can be used as argument for killdelay()
+    */
+    unsigned int addDelayedCommand(Timer* timer, float delay, const std::string& command)
+    {
+        delaytimers.insert(boost::bimap<unsigned int, Timer*>::value_type(++delayHandleCounter, timer));
         const ExecutorStaticPtr& delayexecutor = createExecutor(createFunctor(&executeDelayedCommand));
+        delayexecutor->setDefaultValues(delaytimer, command);
+        delaytimer->setTimer(delay, false, delayexecutor);
+        delayexecutor->setDefaultValues(timer, command);
+        timer->setTimer(delay, false, delayexecutor);
+        return delayHandleCounter;
+    }
 …
         CommandExecutor::execute(command);
         timer->destroy();
         delaytimerset.erase(timer);
+        delaytimers.right.erase(timer);
+    }
 …
     void killdelays()
+    {
+        for (std::set<Timer*>::iterator it = delaytimerset.begin(); it != delaytimerset.end(); ++it)
+            (*it)->destroy();
+        delaytimerset.clear();
+        for (boost::bimap<unsigned int, Timer*>::left_map::iterator it = delaytimers.left.begin(); it != delaytimers.left.end(); ++it)
+            it->second->destroy();
+        delaytimers.clear();
+    }
+    /**
+        @brief Console-command: Kills a delayed command with given handle.
+    */
+    void killdelay(unsigned int handle)
+    {
+        boost::bimap<unsigned int, Timer*>::left_map::iterator it = delaytimers.left.find(handle);
+        if (it != delaytimers.left.end())
+        {
+            it->second->destroy();
+            delaytimers.left.erase(it);
+        }
+    }
 …
+    {
         this->init();
         RegisterObject(Timer);
+        RegisterRootObject(Timer);
+    }
 …
+    {
         this->init();
         RegisterObject(Timer);
+        RegisterRootObject(Timer);
         this->setTimer(interval, bLoop, executor, bKillAfterCall);
 …
         this->time_ = 0;
+    }
+    /**
+        @brief Returns the current time factor of the game.
+    */
+    float Timer::getTimeFactor()
+    {
+        return TimeFactorListener::getTimeFactor();
+    }
 …
+        }
+    }
+    ///////////////
+    // RealTimer //
+    ///////////////
+    /// @copydoc Timer::Timer
+    RealTimer::RealTimer()
+    {
+        RegisterObject(RealTimer);
+    }
+    /// @copydoc Timer::Timer(float, bool, const ExecutorPtr&, bool)
+    RealTimer::RealTimer(float interval, bool bLoop, const ExecutorPtr& executor, bool bKillAfterCall) : Timer(interval, bLoop, executor, bKillAfterCall)
+    {
+        RegisterObject(RealTimer);
+    }
+    /// Returns always 1 because RealTimer doesn't depend on the game time.
+    float RealTimer::getTimeFactor()
+    {
+        return 1;
+    }
+}

code/trunk/src/libraries/tools/Timer.h

-                      r7851
+                      r8079
 #include "core/OrxonoxClass.h"
 #include "core/command/Executor.h"
-#include "tools/interfaces/TimeFactorListener.h"
 namespace orxonox
+{
+    void delay(float delay, const std::string& command);
+    void killdelays();
+    unsigned int delay(float delay, const std::string& command);
+    unsigned int delayreal(float delay, const std::string& command);
+    unsigned int addDelayedCommand(Timer* timer, float delay, const std::string& command);
     void executeDelayedCommand(Timer* timer, const std::string& command);
+    void killdelay(unsigned int handle);
+    void killdelays();
     /**
         @brief Timer is a helper class that executes a function after a given amount of time.
+        @brief Timer is a helper class that executes a function after a given amount of seconds in game-time.
         @see See @ref TimerExample "Timer.h" for an example.
+        The time interval of Timer depends on the game time, hence it stops if the game is paused or runs
+        slower/faster if the game-speed is modified. See RealTimer for a timer class which doesn't depend
+        on the game time.
     */
     class _ToolsExport Timer : public TimeFactorListener
+    class _ToolsExport Timer : virtual public OrxonoxClass
+    {
         public:
 …
             void run();
             /// Re-starts the Timer: The executor will be called after @a interval seconds.
+            /// Re-starts the timer: The executor will be called after @a interval seconds.
             inline void startTimer()
                 { this->bActive_ = true; this->time_ = this->interval_; }
             /// Stops the Timer.
+            /// Stops the timer.
             inline void stopTimer()
                 { this->bActive_ = false; this->time_ = this->interval_; }
             /// Pauses the Timer - it will continue with the actual state if you call unpauseTimer().
+            /// Pauses the timer - it will continue with the actual state if you call unpauseTimer().
             inline void pauseTimer()
                 { this->bActive_ = false; }
             /// Unpauses the Timer - continues with the given state.
+            /// Unpauses the timer - continues with the given state.
             inline void unpauseTimer()
                 { this->bActive_ = true; }
             /// Returns true if the Timer is active (neither stopped nor paused).
+            /// Returns true if the timer is active (neither stopped nor paused).
             inline bool isActive() const
                 { return this->bActive_; }
             /// Returns the remaining time until the Timer calls the executor.
+            /// Returns the remaining time until the timer calls the executor.
             inline float getRemainingTime() const
                 { return static_cast<float>(this->time_ / 1000000.0f); }
             /// Increases the remaining time of the Timer by the given amount of time (in seconds).
+            /// Increases the remaining time of the timer by the given amount of time (in seconds).
             inline void addTime(float time)
                 { if (time > 0.0f) this->time_ += static_cast<long long>(time * 1000000.0f); }
             /// Decreases the remaining time of the Timer by the given amount of time (in seconds)
+            /// Decreases the remaining time of the timer by the given amount of time (in seconds)
             inline void removeTime(float time)
                 { if (time > 0.0f) this->time_ -= static_cast<long long>(time * 1000000.0f); }
 …
             void tick(const Clock& time);
+        protected:
+            virtual float getTimeFactor();
         private:
             void init();
 …
             long long interval_;    //!< The time-interval in micro seconds
             bool bLoop_;            //!< If true, the executor gets called every @a interval seconds
             bool bActive_;          //!< If true, the Timer ticks and calls the executor if the time's up
+            bool bActive_;          //!< If true, the timer ticks and calls the executor if the time's up
             bool bKillAfterCall_;   //!< If true the timer gets deleted after it expired and called the executor
             long long time_;        //!< Internal variable, counting the time untill the next executor-call
     };
+    /**
+        @brief RealTimer is a helper class that executes a function after a given amount of seconds in real-time.
+        The time interval of RealTimer doesn't depend on the game time, it will also call the function
+        if the game is paused. See Timer for a timer class that depends on the game time.
+    */
+    class _ToolsExport RealTimer : public Timer
+    {
+        public:
+            RealTimer();
+            RealTimer(float interval, bool bLoop, const ExecutorPtr& executor, bool bKillAfterCall = false);
+        protected:
+            virtual float getTimeFactor();
+    };
+}

code/trunk/src/libraries/tools/ToolsPrereqs.h

r7163	r8079
85	85	class Mesh;
86	86	class ParticleInterface;
	87	class RealTimer;
87	88	class ResourceCollection;
88	89	class ResourceLocation;

code/trunk/src/modules/designtools/ScreenshotManager.cc

-                      r7284
+                      r8079
+    {
         Ogre::RenderWindow* pRenderWindow = GraphicsManager::getInstance().getRenderWindow();
-        int gridSize = 3;
-        std::string fileExtension = ".png";
-        bool overlayFlag = true;
         //set file extension for the Screenshot files
         mFileExtension   = fileExtension;
+        this->mFileExtension_  = ".png";
         // the gridsize
         mGridSize        = gridSize;
+        this->mGridSize_ = 3;
         // flag for overlay rendering
         mDisableOverlays = overlayFlag;
+        this->mDisableOverlays_ = true;
         //get current window size
         mWindowWidth   = pRenderWindow->getWidth();
         mWindowHeight  = pRenderWindow->getHeight();
+        this->mWindowWidth_   = pRenderWindow->getWidth();
+        this->mWindowHeight_  = pRenderWindow->getHeight();
         //create temporary texture
+        mTempTex = Ogre::TextureManager::getSingleton().createManual("ScreenShotTex",
+                                                                  Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D,
+                                                                    mWindowWidth, mWindowHeight,0, Ogre::PF_B8G8R8, Ogre::TU_RENDERTARGET);
+        this->mTempTex_ = Ogre::TextureManager::getSingleton().createManual("ScreenShotTex", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, this->mWindowWidth_, this->mWindowHeight_, 0, Ogre::PF_B8G8R8, Ogre::TU_RENDERTARGET);
         //get The current Render Target of the temp Texture
         mRT = mTempTex->getBuffer()->getRenderTarget();
+        this->mRT_ = this->mTempTex_->getBuffer()->getRenderTarget();
         //HardwarePixelBufferSharedPtr to the Buffer of the temp Texture
         mBuffer = mTempTex->getBuffer();
+        this->mBuffer_ = this->mTempTex_->getBuffer();
         //create PixelBox
             uint8_t* data_ = new uint8_t[(mWindowWidth * mGridSize) * (mWindowHeight * mGridSize) * 3];
         mFinalPicturePB = Ogre::PixelBox(mWindowWidth * mGridSize,mWindowHeight * mGridSize,1,Ogre::PF_B8G8R8,data_);
+        uint8_t* data_ = new uint8_t[(this->mWindowWidth_ * this->mGridSize_) * (this->mWindowHeight_ * this->mGridSize_) * 3];
+        this->mFinalPicturePB_ = Ogre::PixelBox(this->mWindowWidth_ * this->mGridSize_, this->mWindowHeight_ * this->mGridSize_, 1, Ogre::PF_B8G8R8, data_);
+    }
 …
+    /* Creates a screenshot with the given camera.
+    * @param camera Pointer to the camera "looking at" the scene of interest
+    * @param fileName the filename of the screenshot file.
+    /**
+    @brief
+        Creates a screenshot with the given camera.
+    @param camera
+        Pointer to the camera "looking at" the scene of interest
+    @param fileName
+        the filename of the screenshot file.
     */
     void ScreenshotManager::makeScreenshot() const
 …
         //Remove all viewports, so the added Viewport(camera) ist the only
         mRT->removeAllViewports();
         mRT->addViewport(camera);
+        mRT_->removeAllViewports();
+        mRT_->addViewport(camera);
         //set the viewport settings
         Ogre::Viewport *vp = mRT->getViewport(0);
+        Ogre::Viewport *vp = mRT_->getViewport(0);
         vp->setClearEveryFrame(true);
         vp->setOverlaysEnabled(false);
 …
         // we disable overlay rendering if it is set in config file and the viewport setting is enabled
         if(mDisableOverlays && enableOverlayFlag)
+        if(mDisableOverlays_ && enableOverlayFlag)
             GraphicsManager::getInstance().getViewport()->setOverlaysEnabled(false);
         if(mGridSize <= 1)
+        if(mGridSize_ <= 1)
+        {
             // Simple case where the contents of the screen are taken directly
             // Also used when an invalid value is passed within gridSize (zero or negative grid size)
             mRT->update();    //render
+            mRT_->update();    //render
             //write the file on the Harddisk
             mRT->writeContentsToFile(fileName + "." + mFileExtension);
+            mRT_->writeContentsToFile(fileName + "." + mFileExtension_);
+        }
         else
 …
             // compute the Stepsize for the drid
             Ogre::Real frustumGridStepHorizontal  = (originalFrustumRight * 2) / mGridSize;
             Ogre::Real frustumGridStepVertical  = (originalFrustumTop * 2) / mGridSize;
+            Ogre::Real frustumGridStepHorizontal  = (originalFrustumRight * 2) / mGridSize_;
+            Ogre::Real frustumGridStepVertical  = (originalFrustumTop * 2) / mGridSize_;
             // process each grid
             Ogre::Real frustumLeft, frustumRight, frustumTop, frustumBottom;
             for (unsigned int nbScreenshots = 0; nbScreenshots < mGridSize * mGridSize; nbScreenshots++)
+            for (unsigned int nbScreenshots = 0; nbScreenshots < mGridSize_ * mGridSize_; nbScreenshots++)
+            {
                 int y = nbScreenshots / mGridSize;
                 int x = nbScreenshots - y * mGridSize;
+                int y = nbScreenshots / mGridSize_;
+                int x = nbScreenshots - y * mGridSize_;
                 // Shoggoth frustum extents setting
 …
                 // ignore time duration between frames
                 Ogre::Root::getSingletonPtr()->clearEventTimes();
                 mRT->update();    //render
+                mRT_->update();    //render
                 //define the current
                 Ogre::Box subBox = Ogre::Box(x* mWindowWidth,y * mWindowHeight,x * mWindowWidth + mWindowWidth, y * mWindowHeight + mWindowHeight);
+                Ogre::Box subBox = Ogre::Box(x* mWindowWidth_,y * mWindowHeight_,x * mWindowWidth_ + mWindowWidth_, y * mWindowHeight_ + mWindowHeight_);
                 //copy the content from the temp buffer into the final picture PixelBox
                 //Place the tempBuffer content at the right position
                 mBuffer->blitToMemory(mFinalPicturePB.getSubVolume(subBox));
+                mBuffer_->blitToMemory(mFinalPicturePB_.getSubVolume(subBox));
+            }
 …
             Ogre::Image finalImage; //declare the final Image Object
             //insert the PixelBox data into the Image Object
             finalImage = finalImage.loadDynamicImage(static_cast<unsigned char*>(mFinalPicturePB.data), mFinalPicturePB.getWidth(),mFinalPicturePB.getHeight(),Ogre::PF_B8G8R8);
+            finalImage = finalImage.loadDynamicImage(static_cast<unsigned char*>(mFinalPicturePB_.data), mFinalPicturePB_.getWidth(), mFinalPicturePB_.getHeight(),Ogre::PF_B8G8R8);
             // Save the Final image to a file
             finalImage.save(fileName + "." + mFileExtension);
+            finalImage.save(fileName + "." + mFileExtension_);
+        }
 …
+    }
+    /**
+    @brief
+        Set the size of the grid.
+    @param size
+        The size of the grid.
+    */
+    void ScreenshotManager::setGridSize(unsigned int size)
+    {
+        if(size == this->mGridSize_)
+            return;
+        this->mGridSize_ = size;
+        // New PixelBox for the changed size.
+        uint8_t* data_ = new uint8_t[(this->mWindowWidth_ * this->mGridSize_) * (this->mWindowHeight_ * this->mGridSize_) * 3];
+        this->mFinalPicturePB_ = Ogre::PixelBox(this->mWindowWidth_ * this->mGridSize_, this->mWindowHeight_ * this->mGridSize_, 1, Ogre::PF_B8G8R8, data_);
+    }
+    /**
+    @brief
+        Get a timestamp for the curent time instant.
+    @return
+        Returns a string with the timestamp.
+    */
     std::string ScreenshotManager::getTimestamp()
+    {

code/trunk/src/modules/designtools/ScreenshotManager.h

-                      r7163
+                      r8079
+{
+    /* Class encapsulates Screenshot functionality and provides a method for making multi grid screenshots.
+    *  pRenderWindow:    Pointer to the render window.  This could be "mWindow" from the ExampleApplication,
+    *              the window automatically created obtained when calling
+    *              Ogre::Root::getSingletonPtr()->initialise(false) and retrieved by calling
+    *              "Ogre::Root::getSingletonPtr()->getAutoCreatedWindow()", or the manually created
+    *              window from calling "mRoot->createRenderWindow()".
+    *  gridSize:      The magnification factor.  A 2 will create a 2x2 grid, doubling the size of the
+                screenshot.  A 3 will create a 3x3 grid, tripling the size of the screenshot.
+    *  fileExtension:    The extension of the screenshot file name, hence the type of graphics file to generate.
+    *              To generate "MyScreenshot.png" this parameter would contain ".png".
+    /**
+    @brief
+        Class encapsulates Screenshot functionality and provides a method for making multi grid screenshots.
     */
     class ScreenshotManager : public OrxonoxClass, public Singleton<ScreenshotManager>
 …
         friend class Singleton<ScreenshotManager>;
     public:
         ScreenshotManager();
         ~ScreenshotManager();
+        public:
+            ScreenshotManager();
+            virtual ~ScreenshotManager();
+      /* Creates a screenshot with the given camera.
+        * @param camera Pointer to the camera "looking at" the scene of interest
+        * @param fileName the filename of the screenshot file.
+      */
+        void makeScreenshot() const;
+            void makeScreenshot() const; //!< Creates a screenshot with the given camera.
+        static void makeScreenshot_s()
+            { getInstance().makeScreenshot(); }
+            /**
+            @brief Creates a screenshot with a given size.
+            @param size Size is factor by which the current screen size is scaled.
+            */
+            static void makeScreenshot_s(unsigned int size)
+                { getInstance().setGridSize(size); getInstance().makeScreenshot(); }
+    protected:
+        static std::string getTimestamp();
+            void setGridSize(unsigned int size); //!< Set the size of the grid.
+        std::string    mFileExtension;
+        unsigned int   mGridSize, mWindowWidth, mWindowHeight;
+        bool           mDisableOverlays;
+        //temp texture with current screensize
+        Ogre::TexturePtr mTempTex;
+        Ogre::RenderTexture* mRT;
+        Ogre::HardwarePixelBufferSharedPtr mBuffer;
+        //PixelBox for a large Screenshot, if grid size is > 1
+        Ogre::PixelBox  mFinalPicturePB;
+        uint8_t* data_;
+        protected:
+            static std::string getTimestamp();
+        static ScreenshotManager* singletonPtr_s;
+            std::string mFileExtension_;
+            unsigned int mGridSize_; //!< The magnification factor.  A 2 will create a 2x2 grid, doubling the size of the screenshot.  A 3 will create a 3x3 grid, tripling the size of the screenshot.
+            unsigned int mWindowWidth_, mWindowHeight_;
+            bool mDisableOverlays_;
+            //! temp texture with current screensize
+            Ogre::TexturePtr mTempTex_;
+            Ogre::RenderTexture* mRT_;
+            Ogre::HardwarePixelBufferSharedPtr mBuffer_;
+            //! PixelBox for a large Screenshot, if grid size is > 1
+            Ogre::PixelBox  mFinalPicturePB_;
+            uint8_t* data_;
+            static ScreenshotManager* singletonPtr_s;
     };

code/trunk/src/modules/designtools/SkyboxGenerator.cc

r7284	r8079
59	59
60	60	this->setConfigValues();
61		takeScreenshot_ = false;
	61	this->takeScreenshot_ = false;
62	62	this->captionsRemoved_ = false;
63	63	}

code/trunk/src/modules/notifications/NotificationManager.cc

r7552	r8079
103	103	{
104	104	// Destroys all NotificationQueues that have been registered with the NotificationManager.
105		for(std::map<const std::string, NotificationQueue*>::iterator it = this->queues_.begin(); it != this->queues_.end(); it++)
	105	std::map<const std::string, NotificationQueue*>::iterator it = this->queues_.begin();
	106	while(it != this->queues_.end())
	107	{
106	108	it->second->destroy(true);
	109	it = this->queues_.begin();
	110	}
107	111
108	112	this->queues_.clear();
…	…
298	302	}
299	303
	304	COUT(4) << "NotificationListener '" << identifier << "' unregistered with the NotificationManager." << std::endl;
	305
300	306	// Remove the NotificationListener from the list of NotificationListeners.
301	307	this->listenerList_.erase(listener);
302	308	// Remove the Notifications list that was associated with the input NotificationListener.
303	309	this->notificationLists_.erase(identifier);
304
305		~~COUT(4) << "NotificationListener unregistered with the NotificationManager." << std::endl;~~
306	310	}
307	311
…	…
361	365	bool NotificationManager::registerQueue(NotificationQueue* queue)
362	366	{
	367	COUT(4) << "NotificationQueue '" << queue->getName() << "' registered with the NotificationManager." << std::endl;
363	368	return this->queues_.insert(std::pair<const std::string, NotificationQueue*>(queue->getName(), queue)).second;
364	369	}
…	…
372	377	void NotificationManager::unregisterQueue(NotificationQueue* queue)
373	378	{
	379	COUT(4) << "NotificationQueue '" << queue->getName() << "' unregistered with the NotificationManager." << std::endl;
374	380	this->queues_.erase(queue->getName());
375	381	}

code/trunk/src/modules/notifications/NotificationQueue.cc

-                      r7489
+                      r8079
             GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeQueue(\"" + this->getName() +  "\")");
+        COUT(3) << "NotificationQueue '" << this->getName() << "' destroyed." << std::endl;
         this->OrxonoxClass::destroy();
+    }
 …
             while(it != this->ordering_.upper_bound(&this->timeLimit_))
+            {
+                std::multiset<NotificationContainer*, NotificationContainerCompare>::iterator temp = it;
+                it++;
+                this->remove(temp); // Remove the Notifications that have expired.
+                this->remove(it); // Remove the Notifications that have expired.
+                it = this->ordering_.begin();
+            }
 …
         if(GameMode::showsGraphics())
             GUIManager::getInstance().getLuaState()->doString("NotificationLayer.pushNotification(\"" + this->getName() + "\", \"" + notification->getMessage() + "\")");
+        COUT(5) << "Notification \"" << notification->getMessage() << "\" pushed to NotificationQueue '" << this->getName() << "'" << endl;
+    }
 …
         // Get all the NotificationContainers that were sent the same time the NotificationContainer we want to pop was sent.
         std::pair<std::multiset<NotificationContainer*, NotificationContainerCompare>::iterator, std::multiset<NotificationContainer*, NotificationContainerCompare>::iterator> iterators = this->ordering_.equal_range(container);
         // Iterate through all suspects and remove the container as soon as we find it.
         for(std::multiset<NotificationContainer*, NotificationContainerCompare>::iterator it = iterators.first; it != iterators.second; it++)
 …
             if(container == *it)
+            {
+                COUT(5) << "Notification \"" << (*it)->notification->getMessage() << "\" popped from NotificationQueue '" << this->getName() << "'" << endl;
                 this->ordering_.erase(it);
                 break;
 …
         // Get the index at which the Notification is.
         std::vector<NotificationContainer*>::difference_type index = it - this->notifications_.begin ();
+        COUT(5) << "Notification \"" << (*it)->notification->getMessage() << "\" removed from NotificationQueue '" << this->getName() << "'" << endl;
         this->ordering_.erase(containerIterator);
         this->notifications_.erase(it);
 …
     void NotificationQueue::clear(bool noGraphics)
+    {
+        COUT(4) << "Clearing NotificationQueue " << this->getName() << "." << endl;
         this->ordering_.clear();
         // Delete all NotificationContainers in the list.
 …
     /**
     @brief
         Produces all targets of the NotificationQueue concatinated as string, with kommas (',') as seperators.
+        Produces all targets of the NotificationQueue concatinated as string, with commas (',') as seperators.
     @return
         Returns the targets as a string.

code/trunk/src/modules/objects/triggers/DistanceMultiTrigger.cc

-                      r7601
+                      r8079
         this->distance_ = 100.0f;
         this->targetName_ = BLANKSTRING;
+        this->targetName_ = "";
         this->singleTargetMode_ = false;
+    }
 …
+    {
         // If the targetname is no blank string single-target mode is enabled.
         if(targetname.compare(BLANKSTRING) != 0)
+        if(targetname != "")
             this->singleTargetMode_ = true;
         else

code/trunk/src/modules/objects/triggers/DistanceTrigger.cc

r7601	r8079
50	50	this->distance_ = 100;
51	51	this->targetMask_.exclude(Class(BaseObject));
52		this->targetName_ = ~~BLANKSTRING~~;
	52	this->targetName_ = "";
53	53	this->singleTargetMode_ = false;
54	54	}

code/trunk/src/modules/objects/triggers/DistanceTrigger.h

r7601	r8079
70	70
71	71	inline void setTargetName(const std::string& targetname)
72		{ if(targetname~~.compare(BLANKSTRING) != 0~~) this->singleTargetMode_ = true; else this->singleTargetMode_ = false; this->targetName_ = targetname; }
	72	{ if(targetname != "") this->singleTargetMode_ = true; else this->singleTargetMode_ = false; this->targetName_ = targetname; }
73	73	inline const std::string& getTargetName(void)
74	74	{ return this->targetName_; }

code/trunk/src/modules/overlays/OverlaysPrereqs.h

r7655	r8079
89	89	class KillMessage;
90	90	class LastManStandingInfos;
	91	class PauseNotice;
91	92	class TeamBaseMatchScore;
92	93	class UnderAttackHealthBar;

code/trunk/src/modules/overlays/hud/CMakeLists.txt

r7655	r8079
16	16	GametypeFadingMessage.cc
17	17	LastManStandingInfos.cc
	18	PauseNotice.cc
18	19	)

code/trunk/src/modules/pickup/PickupRepresentation.cc

r7548	r8079
156	156	{
157	157	COUT(4) << "PickupRepresentation: No spawner representation found." << std::endl;
158		if(this->spawnerTemplate_ == ~~BLANKSTRING~~)
	158	if(this->spawnerTemplate_ == "")
159	159	{
160	160	COUT(4) << "PickupRepresentation: Spawner template is empty." << std::endl;

code/trunk/src/modules/questsystem/QuestItem.cc

r7456	r8079
87	87	void QuestItem::setId(const std::string & id)
88	88	{
89		if(id~~.compare(BLANKSTRING) == 0~~) // Checks whether the id is a valid id.
	89	if(id == "") // Checks whether the id is a valid id.
90	90	{
91	91	COUT(2) << "Invalid id. QuestItem id {" << id << "} could not be set." << std::endl;

code/trunk/src/modules/questsystem/QuestManager.cc

-                      r7552
+                      r8079
     /**
     @brief
         Registers a Quest with the QuestManager to make it globally accessable.
+        Registers a Quest with the QuestManager to make it globally accessible.
         Uses it's id to make sure to be able to be identify and retrieve it later.
     @param quest
 …
     /**
     @brief
         Registers a QuestHint with the QuestManager to make it globally accessable.
+        Registers a QuestHint with the QuestManager to make it globally accessible.
         Uses it's id to make sure to be able to be identify and retrieve it later.
     @param hint
 …
     Quest* QuestManager::findQuest(const std::string & questId)
+    {
         if(questId.compare(BLANKSTRING) == 1) // Check vor validity of the given id.
+        if(questId == "") // Check for validity of the given id.
             ThrowException(Argument, "Invalid questId.");
 …
     QuestHint* QuestManager::findHint(const std::string & hintId)
+    {
         if(hintId.compare(BLANKSTRING) == 1) // Check vor validity of the given id.
+        if(hintId == "") // Check for validity of the given id.
             ThrowException(Argument, "Invalid hintId.");

code/trunk/src/modules/questsystem/effects/AddQuestHint.cc

r7552	r8079
86	86	bool AddQuestHint::setHintId(const std::string & id)
87	87	{
88		if(id~~.compare(BLANKSTRING) == 0~~)
	88	if(id == "")
89	89	{
90	90	COUT(2) << "Invalid id. QuestItem id {" << id << "} could not be set." << std::endl;

code/trunk/src/modules/questsystem/effects/ChangeQuestStatus.cc

r7456	r8079
81	81	bool ChangeQuestStatus::setQuestId(const std::string & id)
82	82	{
83		if(id~~.compare(BLANKSTRING) == 0~~)
	83	if(id == "")
84	84	{
85	85	COUT(2) << "Invalid id. QuestItem id {" << id << "} could not be set." << std::endl;

code/trunk/src/orxonox/CameraManager.cc

-                      r7879
+                      r8079
 #include "CameraManager.h"
+#include <cassert>
 #include <OgreSceneManager.h>
 #include <OgreViewport.h>
 #include <OgreCompositorManager.h>
-#include "util/StringUtils.h"
 #include "util/ScopedSingletonManager.h"
 #include "core/GameMode.h"
 #include "core/GraphicsManager.h"
-#include "core/GUIManager.h"
 #include "core/ObjectList.h"
 #include "tools/Shader.h"
 #include "graphics/Camera.h"
-#include "Scene.h"
 namespace orxonox
 …
     CameraManager::CameraManager()
-        : viewport_(GraphicsManager::getInstance().getViewport())
+    {
         assert(GameMode::showsGraphics());
 …
     CameraManager::~CameraManager()
+    {
-        GUIManager::getInstance().setCamera(0);
+    }
 …
             if (!this->cameraList_.empty())
                 this->cameraList_.front()->setFocus();
+            else
+                this->useCamera(NULL);
+        }
         else
 …
     void CameraManager::useCamera(Ogre::Camera* camera)
+    {
+        // This workaround is needed to avoid weird behaviour with active compositors while
+        // switching the camera (like freezing the image)
+        //
+        // Last known Ogre version needing this workaround:
+        // 1.4.8
+        // 1.7.2
+        // deactivate all compositors
+        {
+            Ogre::ResourceManager::ResourceMapIterator iterator = Ogre::CompositorManager::getSingleton().getResourceIterator();
+            while (iterator.hasMoreElements())
+                Ogre::CompositorManager::getSingleton().setCompositorEnabled(this->viewport_, iterator.getNext()->getName(), false);
+        }
+        this->viewport_->setCamera(camera);
+        GUIManager::getInstance().setCamera(camera);
+        // reactivate all visible compositors
+        {
+            for (ObjectList<Shader>::iterator it = ObjectList<Shader>::begin(); it != ObjectList<Shader>::end(); ++it)
+                it->updateVisibility();
+        }
+        GraphicsManager::getInstance().setCamera(camera);
+    }
+}

code/trunk/src/orxonox/CameraManager.h

-                      r6746
+                      r8079
 #include "OrxonoxPrereqs.h"
-#include <cassert>
 #include <list>
 #include "util/OgreForwardRefs.h"
 #include "util/Singleton.h"
 #include "core/OrxonoxClass.h"
-#include "core/SmartPtr.h"
 namespace orxonox
 …
             std::list<Camera*>    cameraList_;
-            Ogre::Viewport*       viewport_;
             static CameraManager* singletonPtr_s;

code/trunk/src/orxonox/ChatInputHandler.cc

-                      r7284
+                      r8079
 #include "ChatInputHandler.h"
+#include <cassert>
+#include <string>
+#include <CEGUIWindow.h>
+#include <CEGUIWindowManager.h>
+#include <elements/CEGUIListbox.h>
+#include <elements/CEGUIListboxItem.h>
+#include <elements/CEGUIListboxTextItem.h>
 #include "util/ScopedSingletonManager.h"
 #include "core/CoreIncludes.h"
 #include "core/GUIManager.h"
-#include "core/CorePrereqs.h"
 #include "core/command/ConsoleCommand.h"
+#include <CEGUIWindow.h>
+#include <elements/CEGUIListbox.h>
+#include <elements/CEGUIListboxItem.h>
+#include <elements/CEGUIListboxTextItem.h>
+#include <CEGUIWindowManager.h>
+#include <string>
+#include "core/input/InputBuffer.h"
+#include "core/input/InputManager.h"
+#include "core/input/InputState.h"
+#include "network/Host.h"
+#include "PlayerManager.h"
+#include "infos/PlayerInfo.h"
 namespace orxonox
 …
     this->inputState = InputManager::getInstance().createInputState( "chatinput", false, false, InputStatePriority::Dynamic );
     this->inputState->setKeyHandler(this->inpbuf);
+  }
+  ChatInputHandler::~ChatInputHandler()
+  {
+    /* Clean up */
+    InputManager::getInstance().destroyState("chatinput");
+    delete this->inpbuf;
+  }
 …
     // reds
     for( i = 0; i < NumberOfColors/3; ++i )
+    { this->text_colors[ i ] = new CEGUI::colour( red, green, blue );
+      assert( this->text_colors[ i ] );
+    { this->text_colors[ i ] = CEGUI::colour( red, green, blue );
       green += 0.2f, blue += 0.2f;
+    }
 …
     red = 0.5, green = 1, blue = 0.5;
     for( ; i < NumberOfColors*2/3; ++i )
+    { this->text_colors[ i ] = new CEGUI::colour( red, green, blue );
+      assert( this->text_colors[ i ] );
+    { this->text_colors[ i ] = CEGUI::colour( red, green, blue );
       red += 0.2f, blue += 0.2f;
+    }
 …
     red = 0.5, green = 0.5, blue = 1;
     for( ; i < NumberOfColors; ++i )
+    { this->text_colors[ i ] = new CEGUI::colour( red, green, blue );
+      assert( this->text_colors[ i ] );
+    { this->text_colors[ i ] = CEGUI::colour( red, green, blue );
       red += 0.2f, green += 0.2f;
+    }
 …
     /* set the color according to the hash */
     tocolor->setTextColours( *(this->text_colors[ hash ]) );
+    tocolor->setTextColours( this->text_colors[ hash ] );
+  }

code/trunk/src/orxonox/ChatInputHandler.h

-                      r7163
+                      r8079
 #define _ChatInputHandler_H__
+/* std includes */
+#include <deque>
+#include <OrxonoxPrereqs.h>
 #include <string>
-#include <fstream>
-#include <iostream>
-#include <cassert>
 #include <CEGUIForwardRefs.h>
+#include <CEGUIcolour.h>
+/* project includes */
+#include <OrxonoxPrereqs.h>
+#include <core/BaseObject.h>
+#include <core/PathConfig.h>
+#include "core/input/InputBuffer.h"
+#include "core/input/InputManager.h"
+#include "core/input/InputState.h"
+#include <network/ChatListener.h>
+#include <PlayerManager.h>
+#include <infos/PlayerInfo.h>
+#include "../libraries/network/Host.h"
+#include <util/Singleton.h>
+#include "util/Singleton.h"
+#include "network/ChatListener.h"
 namespace orxonox // tolua_export
 …
       /* colors for nickname coloring */
       static const int NumberOfColors = 10;
       CEGUI::colour *text_colors[ NumberOfColors ];
+      CEGUI::colour text_colors[ NumberOfColors ];
       /** input state */
 …
       /** constructor */
       ChatInputHandler();
+      ~ChatInputHandler();
       friend class Singleton<ChatInputHandler>;

code/trunk/src/orxonox/LevelInfo.h

-                      r7804
+                      r8079
             @return Returns the XML-filename (including *.oxw extension) of the Level.
             */
             inline const std::string& getXMLFilename(void) { return this->xmlfilename_; } // tolua_export
+            inline const std::string& getXMLFilename(void) const { return this->xmlfilename_; } // tolua_export
         protected:
 …
+    {
         bool operator() (const LevelInfoItem* lhs, const LevelInfoItem* rhs) const
+            { return getLowercase(lhs->getName()).compare(getLowercase(rhs->getName())) < 0; }
+            {
+                if(getLowercase(lhs->getName()).compare(getLowercase(rhs->getName())) == 0)
+                    return getLowercase(lhs->getXMLFilename()).compare(getLowercase(rhs->getXMLFilename())) < 0;
+                return getLowercase(lhs->getName()).compare(getLowercase(rhs->getName())) < 0;
+            }
     };

code/trunk/src/orxonox/LevelManager.cc

-                      r7839
+                      r8079
     LevelManager::~LevelManager()
+    {
+        // Delete all the LevelInfoItem objects because the LevelManager created them
+        std::set<LevelInfoItem*, LevelInfoCompare>::iterator it = availableLevels_.begin();
+        for (; it != availableLevels_.end(); ++it)
+            delete *it;
+    }
 …
     void LevelManager::compileAvailableLevelList()
+    {
+        // Get all files matching the level criteria
         Ogre::StringVectorPtr levels = Resource::findResourceNames("*.oxw");
+        // Iterate over all *.oxw level files.
+        // We only want to load as little as possible
+        ClassTreeMask mask;
+        mask.exclude(Class(BaseObject));
+        mask.include(Class(LevelInfo));
+        // Iterate over all the found *.oxw files
         COUT(3) << "Loading LevelInfos..." << std::endl;
+        std::set<std::string> names;
         for (Ogre::StringVector::const_iterator it = levels->begin(); it != levels->end(); ++it)
+        {
             //TODO: Replace with tag?
+            // TODO: Replace with tag?
             if (it->find("old/") != 0)
+            {
                 size_t pos = it->find(".oxw");
+                LevelInfoItem* info = NULL;
                 // Load the LevelInfo object from the level file.
-                bool infoExists = false;
                 XMLFile file = XMLFile(*it);
+                ClassTreeMask mask = ClassTreeMask();
+                mask.exclude(ClassIdentifier<BaseObject>::getIdentifier());
+                mask.include(ClassIdentifier<LevelInfo>::getIdentifier());
+                Loader::load(&file, mask, false);
+                // Iterate over all LevelInfos.
+                Loader::load(&file, mask, false, true);
+                // Find the LevelInfo object we've just loaded (if there was one)
                 for(ObjectList<LevelInfo>::iterator item = ObjectList<LevelInfo>::begin(); item != ObjectList<LevelInfo>::end(); ++item)
+                    if(item->getXMLFilename() == *it)
+                        info = item->copy();
+                // We don't need the loaded stuff anymore
+                Loader::unload(&file);
+                if(info == NULL)
+                {
+                    LevelInfoItem* info = item->copy();
+                    if(info->getXMLFilename() == *it) // If the LevelInfo for this level exists we insert it into the list of available levels.
+                    {
+                        this->availableLevels_.insert(info);
+                        infoExists = true;
+                    }
+                    // Create a default LevelInfoItem object that merely contains the name
+                    std::string filenameWOExtension = it->substr(0, it->find(".oxw"));
+                    info = new LevelInfoItem(filenameWOExtension, *it);
+                }
+                Loader::unload(&file, mask);
+                if(!infoExists) // If the LevelInfo for this level doesn't exist, we create a new one and insert it into the list of available levels.
+                    this->availableLevels_.insert(new LevelInfoItem(it->substr(0, pos), *it));
+                // Warn about levels with the same name.
+                if(!names.insert(info->getName()).second)
+                    COUT(2) << "Warning: Multiple levels (" << info->getXMLFilename() << ") with name '" << info->getName() << "' found!" << std::endl;
+                // Warn about multiple items so that it gets fixed quickly
+                if(availableLevels_.find(info) != availableLevels_.end())
+                {
+                    COUT(2) << "Warning: Multiple levels (" << info->getXMLFilename() << ") with same name '" << info->getName() << "' and filename found! Exluding..." << std::endl;
+                    // Delete LevelInfoItem to avoid a dangling pointer
+                    delete info;
+                }
+                else
+                    this->availableLevels_.insert(info);
+            }
+        }

code/trunk/src/orxonox/LevelManager.h

r7804	r8079
112	112	// Helpers to allow fast access to the availableLevels list.
113	113	unsigned int nextIndex_; //! The next expected index to be accessed.
114		std::set<LevelInfoItem*, LevelInfoCompare>::iterator nextLevel_; //! The nex expected Level to be accessed.
	114	std::set<LevelInfoItem*, LevelInfoCompare>::iterator nextLevel_; //! The next expected Level to be accessed.
115	115
116	116	// config values

code/trunk/src/orxonox/controllers/HumanController.cc

-                      r7863
+                      r8079
     SetConsoleCommand("HumanController", "cycleNavigationFocus",   &HumanController::cycleNavigationFocus).addShortcut();
     SetConsoleCommand("HumanController", "releaseNavigationFocus", &HumanController::releaseNavigationFocus).addShortcut();
+    SetConsoleCommand("HumanController", "myposition",             &HumanController::myposition    ).addShortcut();
     CreateUnloadableFactory(HumanController);
 …
     void HumanController::toggleGodMode()
+    {
+        HumanController::getLocalControllerSingleton()->setGodMode( !HumanController::getLocalControllerSingleton()->getGodMode() );
+        if (HumanController::localController_s)
+            HumanController::localController_s->setGodMode(!HumanController::localController_s->getGodMode());
+    }
+    void HumanController::myposition()
+    {
+        if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
+        {
+            const Vector3& position = HumanController::localController_s->controllableEntity_->getPosition();
+            const Quaternion& orientation = HumanController::localController_s->controllableEntity_->getOrientation();
+            COUT(0) << "position=\"" << position.x << ", " << position.y << ", " << position.z << "\" ";
+            COUT(0) << "orientation=\"" << orientation.w << ", " << orientation.x << ", " << orientation.y << ", " << orientation.z << "\"" << std::endl;
+        }
+    }

code/trunk/src/orxonox/controllers/HumanController.h

r7533	r8079
73	73	static void suicide();
74	74	static void toggleGodMode();
	75	static void myposition();
75	76
76	77	static void addBots(unsigned int amount);

code/trunk/src/orxonox/gamestates/GSLevel.cc

-                      r7879
+                      r8079
 #include "LevelManager.h"
 #include "PlayerManager.h"
+#include "GSRoot.h"
 namespace orxonox
 …
     SetConsoleCommand(__CC_startMainMenu_name, &GSLevel::startMainMenu).deactivate();
     SetConsoleCommand(__CC_changeGame_name, &GSLevel::changeGame).defaultValues(BLANKSTRING).deactivate();
+    SetConsoleCommand(__CC_changeGame_name, &GSLevel::changeGame).defaultValues("").deactivate();
     GSLevel::GSLevel(const GameStateInfo& info)
 …
         COUT(0) << "Loading level..." << std::endl;
         startFile_ = new XMLFile(LevelManager::getInstance().getDefaultLevel());
         Loader::open(startFile_);
+        bool loaded = Loader::open(startFile_);
         Core::getInstance().updateLastLevelTimestamp();
+        if(!loaded)
+            GSRoot::delayedStartMainMenu();
+    }
 …
     /*static*/ void GSLevel::changeGame(const std::string& level)
+    {
         if(level != BLANKSTRING)
+        if(level != "")
             LevelManager::getInstance().setDefaultLevel(level);

code/trunk/src/orxonox/gamestates/GSMainMenu.cc

-                      r7876
+                      r8079
     static const std::string __CC_setMainMenuSoundPath_name = "setMMSoundPath";
     SetConsoleCommand(__CC_startStandalone_name,      &GSMainMenu::startStandalone).defaultValues(BLANKSTRING).deactivate();
     SetConsoleCommand(__CC_startServer_name,          &GSMainMenu::startServer    ).defaultValues(BLANKSTRING).deactivate();
     SetConsoleCommand(__CC_startClient_name,          &GSMainMenu::startClient    ).defaultValues(BLANKSTRING).deactivate();
     SetConsoleCommand(__CC_startDedicated_name,       &GSMainMenu::startDedicated ).defaultValues(BLANKSTRING).deactivate();
+    SetConsoleCommand(__CC_startStandalone_name,      &GSMainMenu::startStandalone).defaultValues("").deactivate();
+    SetConsoleCommand(__CC_startServer_name,          &GSMainMenu::startServer    ).defaultValues("").deactivate();
+    SetConsoleCommand(__CC_startClient_name,          &GSMainMenu::startClient    ).defaultValues("").deactivate();
+    SetConsoleCommand(__CC_startDedicated_name,       &GSMainMenu::startDedicated ).defaultValues("").deactivate();
     SetConsoleCommand(__CC_setMainMenuSoundPath_name, &GSMainMenu::setMainMenuSoundPath).hide();
 …
+    {
         // show main menu
+        GraphicsManager::getInstance().setCamera(this->camera_);
         GUIManager::getInstance().showGUI("MainMenu", true);
-        GUIManager::getInstance().setCamera(this->camera_);
         GUIManager::getInstance().setBackgroundImage("MainMenuBackground", "Background");
-        GraphicsManager::getInstance().setCamera(this->camera_);
         InputManager::getInstance().enterState("MainMenuHackery");
 …
         InputManager::getInstance().leaveState("MainMenuHackery");
         GUIManager::getInstance().setCamera(0);
+        GraphicsManager::getInstance().setCamera(0);
         GUIManager::getInstance().setBackgroundImage("");
         GUIManager::hideGUI("MainMenu");
-        GraphicsManager::getInstance().setCamera(0);
         ModifyConsoleCommand(__CC_startStandalone_name).deactivate();
 …
     void GSMainMenu::startStandalone(const std::string& level)
+    {
         if(level != BLANKSTRING)
+        if(level != "")
             LevelManager::getInstance().setDefaultLevel(level);
 …
     void GSMainMenu::startServer(const std::string& level)
+    {
         if(level != BLANKSTRING)
+        if(level != "")
             LevelManager::getInstance().setDefaultLevel(level);
 …
     void GSMainMenu::startClient(const std::string& destination)
+    {
         if(destination != BLANKSTRING)
+        if(destination != "")
             Client::getInstance()->setDestination(destination, NETWORK_PORT);
 …
     void GSMainMenu::startDedicated(const std::string& level)
+    {
         if(level != BLANKSTRING)
+        if(level != "")
             LevelManager::getInstance().setDefaultLevel(level);

code/trunk/src/orxonox/gamestates/GSMainMenu.h

-                      r7876
+                      r8079
         void setMainMenuSoundPath(const std::string& path);
         static void startStandalone(const std::string& level = BLANKSTRING); //!< Start a level in standalone mode.
         static void startServer(const std::string& level = BLANKSTRING); //!< Start a level in server mode.
         static void startClient(const std::string& destination = BLANKSTRING); //!< Connect to a game as client.
         static void startDedicated(const std::string& level = BLANKSTRING); //!< Start a level in dedicated mode.
+        static void startStandalone(const std::string& level = ""); //!< Start a level in standalone mode.
+        static void startServer(const std::string& level = ""); //!< Start a level in server mode.
+        static void startClient(const std::string& destination = ""); //!< Connect to a game as client.
+        static void startDedicated(const std::string& level = ""); //!< Start a level in dedicated mode.
         static void startIOConsole();

code/trunk/src/orxonox/gamestates/GSRoot.cc

-                      r7284
+                      r8079
 #include "tools/interfaces/Tickable.h"
+#include "GSLevel.h"
 namespace orxonox
+{
 …
     static const std::string __CC_setTimeFactor_name = "setTimeFactor";
+    static const std::string __CC_setPause_name = "setPause";
     static const std::string __CC_pause_name = "pause";
+    /*static*/ bool GSRoot::startMainMenu_s = false;
     SetConsoleCommand("printObjects", &GSRoot::printObjects).hide();
     SetConsoleCommand(__CC_setTimeFactor_name, &GSRoot::setTimeFactor).accessLevel(AccessLevel::Master).defaultValues(1.0);
+    SetConsoleCommand(__CC_setPause_name,      &GSRoot::setPause     ).accessLevel(AccessLevel::Master).hide();
     SetConsoleCommand(__CC_pause_name,         &GSRoot::pause        ).accessLevel(AccessLevel::Master);
 …
         ModifyConsoleCommand(__CC_setTimeFactor_name).setObject(this);
+        ModifyConsoleCommand(__CC_setPause_name).setObject(this);
         ModifyConsoleCommand(__CC_pause_name).setObject(this);
+    }
 …
+    {
         ModifyConsoleCommand(__CC_setTimeFactor_name).setObject(0);
+        ModifyConsoleCommand(__CC_setPause_name).setObject(0);
         ModifyConsoleCommand(__CC_pause_name).setObject(0);
+    }
 …
     void GSRoot::update(const Clock& time)
+    {
+        if(startMainMenu_s)
+        {
+            delayedStartMainMenu();
+            startMainMenu_s = false;
+        }
         for (ObjectList<Timer>::iterator it = ObjectList<Timer>::begin(); it; )
+        {
 …
+    }
+    void GSRoot::setPause(bool pause)
+    {
+        if (GameMode::isMaster())
+        {
+            if (pause != this->bPaused_)
+                this->pause();
+        }
+    }
     void GSRoot::changedTimeFactor(float factor_new, float factor_old)
+    {
 …
             callStaticNetworkFunction(&TimeFactorListener::setTimeFactor, CLIENTID_UNKNOWN, factor_new);
+    }
+    /*static*/ void GSRoot::delayedStartMainMenu(void)
+    {
+        if(!startMainMenu_s)
+            startMainMenu_s = true;
+        else
+            GSLevel::startMainMenu();
+    }
+}

code/trunk/src/orxonox/gamestates/GSRoot.h

-                      r7172
+                      r8079
         // when taking the function address.
         void setTimeFactor(float factor);
+        void setPause(bool pause);
         void pause();
+        static void delayedStartMainMenu(void);
     protected:
 …
         bool                  bPaused_;
         float                 timeFactorPauseBackup_;
+        static bool           startMainMenu_s;
     };
+}

code/trunk/src/orxonox/gametypes/Gametype.cc

-                      r7801
+                      r8079
 #include "util/Math.h"
+#include "core/Core.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
 …
                     if (allplayersready && hashumanplayers)
+                    {
+                        this->gtinfo_->startCountdown_ = this->initialStartCountdown_;
+                        // If in developer's mode, there is no start countdown.
+                        if(Core::getInstance().inDevMode())
+                            this->gtinfo_->startCountdown_ = 0;
+                        else
+                            this->gtinfo_->startCountdown_ = this->initialStartCountdown_;
                         this->gtinfo_->bStartCountdownRunning_ = true;
+                    }

code/trunk/src/orxonox/graphics/Camera.cc

-                      r7163
+                      r8079
         this->bHasFocus_ = false;
         this->bDrag_ = false;
-        this->nearClipDistance_ = 1;
         this->lastDtLagged_ = false;
 …
         this->setConfigValues();
+        this->configvaluecallback_changedFovAndAspectRatio();
         this->configvaluecallback_changedNearClipDistance();
+    }
 …
         if (this->isInitialized())
+        {
-            if (GUIManager::getInstance().getCamera() == this->camera_)
-                GUIManager::getInstance().setCamera(NULL);
             this->releaseFocus();
 …
     void Camera::setConfigValues()
+    {
+        SetConfigValue(nearClipDistance_, 1.0f).callback(this, &Camera::configvaluecallback_changedNearClipDistance);
+        SetConfigValue(fov_, 80.0f)
+            .description("Horizontal field of view in degrees")
+            .callback(this, &Camera::configvaluecallback_changedFovAndAspectRatio);
+        SetConfigValue(aspectRatio_, 1.0f)
+            .description("Aspect ratio of pixels (width / height)")
+            .callback(this, &Camera::configvaluecallback_changedFovAndAspectRatio);
+        SetConfigValue(nearClipDistance_, 1.0f)
+            .description("Distance from the camera where close objects will be clipped")
+            .callback(this, &Camera::configvaluecallback_changedNearClipDistance);
+    }
+    /**
+        @brief Update FOV and the aspect ratio of the camera after the config values or the window's size have changed.
+    */
+    void Camera::configvaluecallback_changedFovAndAspectRatio()
+    {
+        // the aspect ratio of the window (width / height) has to be multiplied with the pixels aspect ratio (this->aspectRatio_)
+        float aspectRatio = this->aspectRatio_ * this->getWindowWidth() / this->getWindowHeight();
+        this->camera_->setAspectRatio(aspectRatio);
+        // Since we use horizontal FOV, we have to calculate FOVy by dividing by the aspect ratio and using some tangents
+        Radian fovy(2 * atan(tan(Degree(this->fov_).valueRadians() / 2) / aspectRatio));
+        this->camera_->setFOVy(fovy);
+    }
 …
+    {
         this->camera_->setNearClipDistance(this->nearClipDistance_);
+    }
+    /**
+        @brief Inherited from WindowEventListener.
+    */
+    void Camera::windowResized(unsigned int newWidth, unsigned int newHeight)
+    {
+        this->configvaluecallback_changedFovAndAspectRatio();
+    }

code/trunk/src/orxonox/graphics/Camera.h

-                      r6417
+                      r8079
 #include "util/OgreForwardRefs.h"
+#include "core/WindowEventListener.h"
 #include "tools/interfaces/Tickable.h"
 #include "tools/interfaces/TimeFactorListener.h"
 …
 namespace orxonox
+{
     class _OrxonoxExport Camera : public StaticEntity, public Tickable, public TimeFactorListener
+    class _OrxonoxExport Camera : public StaticEntity, public Tickable, public TimeFactorListener, public WindowEventListener
+    {
         friend class CameraManager;
 …
             void removeFocus();
             void setFocus();
+            void configvaluecallback_changedFovAndAspectRatio();
             void configvaluecallback_changedNearClipDistance();
+            void windowResized(unsigned int newWidth, unsigned int newHeight);
             Ogre::Camera*    camera_;
 …
             bool             bDrag_;
             bool             lastDtLagged_;
+            float            fov_;
+            float            aspectRatio_;
     };
+}

code/trunk/src/orxonox/graphics/GlobalShader.cc

r5781	r8079
61	61	SUPER(GlobalShader, XMLPort, xmlelement, mode);
62	62
63		XMLPortParamExtern(GlobalShader, Shader, &this->shader_, "compositor", setCompositor~~, getCompositor~~, xmlelement, mode);
	63	XMLPortParamExtern(GlobalShader, Shader, &this->shader_, "compositor", setCompositorName, getCompositorName, xmlelement, mode);
64	64	}
65	65
…	…
67	67	{
68	68	registerVariable(this->bVisible_, VariableDirection::ToClient, new NetworkCallback<GlobalShader>(this, &GlobalShader::changedVisibility));
69		registerVariable(const_cast<std::string&>(this->shader_.getCompositor~~()), VariableDirection::ToClient, new NetworkCallback<Shader>(&this->shader_, &Shader::changedCompositor~~));
	69	registerVariable(const_cast<std::string&>(this->shader_.getCompositorName()), VariableDirection::ToClient, new NetworkCallback<Shader>(&this->shader_, &Shader::changedCompositorName));
70	70	}
71	71

code/trunk/src/orxonox/graphics/GlobalShader.h

r7163	r8079
53	53	private:
54	54	void registerVariables();
55		~~void changedCompositor();~~
56	55
57	56	Shader shader_;

code/trunk/src/orxonox/graphics/Model.cc

r7183	r8079
60	60	void Model::setConfigValues()
61	61	{
62		SetConfigValueExternal(bGlobalEnableLod_, "GraphicsSettings", "enableM~~odel~~LoD", true)
	62	SetConfigValueExternal(bGlobalEnableLod_, "GraphicsSettings", "enableMeshLoD", true)
63	63	.description("Enable level of detail for models");
64	64	}

code/trunk/src/orxonox/items/Engine.cc

-                      r7547
+                      r8079
     void Engine::setConfigValues()
+    {
+        SetConfigValue(blurStrength_, 3.0f);
+        SetConfigValueExternal(bEnableMotionBlur_, "GraphicsSettings", "enableMotionBlur", true)
+            .description("Enable or disable the motion blur effect when moving very fast")
+            .callback(this, &Engine::changedEnableMotionBlur);
+        SetConfigValueExternal(blurStrength_, "GraphicsSettings", "blurStrength", 3.0f)
+            .description("Defines the strength of the motion blur effect");
+    }
 …
         this->ship_->setSteeringDirection(Vector3::ZERO);
         if (!this->boostBlur_ && this->ship_->hasLocalController() && this->ship_->hasHumanController())
+        if (this->bEnableMotionBlur_ && !this->boostBlur_ && this->ship_->hasLocalController() && this->ship_->hasHumanController())
+        {
             this->boostBlur_ = new Shader(this->ship_->getScene()->getSceneManager());
             this->boostBlur_->setCompositor("Radial Blur");
+            this->boostBlur_->setCompositorName("Radial Blur");
+        }
         if (this->boostBlur_ && this->maxSpeedFront_ != 0 && this->boostFactor_ != 1)
+            this->boostBlur_->setParameter("Ogre/Compositor/Radial_Blur", 0, 0, "sampleStrength", this->blurStrength_ * clamp((-velocity.z - this->maxSpeedFront_) / ((this->boostFactor_ - 1) * this->maxSpeedFront_), 0.0f, 1.0f));
+        {
+            float blur = this->blurStrength_ * clamp((-velocity.z - this->maxSpeedFront_) / ((this->boostFactor_ - 1) * this->maxSpeedFront_), 0.0f, 1.0f);
+            this->boostBlur_->setVisible(blur > 0);
+            this->boostBlur_->setParameter(0, 0, "sampleStrength", blur);
+        }
+    }
 …
         return this->ship_->getWorldPosition();
+    }
+    void Engine::changedEnableMotionBlur()
+    {
+        if (!this->bEnableMotionBlur_)
+        {
+            this->boostBlur_->destroy();
+            this->boostBlur_ = 0;
+        }
+    }
+}

code/trunk/src/orxonox/items/Engine.h

-                      r7552
+                      r8079
             void registerVariables();
             void networkcallback_shipID();
+            void changedEnableMotionBlur();
             SpaceShip* ship_;
 …
             Shader* boostBlur_;
             float blurStrength_;
+            bool bEnableMotionBlur_;
     };
+}

code/trunk/src/orxonox/overlays/InGameConsole.cc

-                      r7689
+                      r8079
     const float CHAR_WIDTH = 7.45f; // fix this please - determine the char-width dynamically
     SetConsoleCommand("InGameConsole", "openConsole", &InGameConsole::openConsole).addShortcut();
     SetConsoleCommand("InGameConsole", "closeConsole", &InGameConsole::closeConsole).addShortcut();
+    SetConsoleCommand("InGameConsole", "openConsole", &InGameConsole::openConsole);
+    SetConsoleCommand("InGameConsole", "closeConsole", &InGameConsole::closeConsole);
     ManageScopedSingleton(InGameConsole, ScopeID::Graphics, false);

code/trunk/src/orxonox/sound/AmbientSound.cc

-                      r7856
+                      r8079
 #include "AmbientSound.h"
+#include "core/CoreIncludes.h"
 #include "core/GameMode.h"
 #include "core/Resource.h"
 …
         : bPlayOnLoad_(false)
+    {
+        RegisterObject(AmbientSound);
         // Ambient sounds always fade in
         this->setVolume(0);

Context Navigation

Legend:

Download in other formats: